Sockets LECCIÓN 25: SOCKETS

Transcripción

1 LECCIÓN 25: SOCKETS 251 Introducción Creación y Supresión de un Socket Ejemplo completo La comunicación en modo conectado 15

2 LECCIÓN 25: SOCKETS 251 Introducción Una de las mayores contribuciones de las distribuciones de Berkeley al sistema UNIX es incontestablemente el interfaz de comunicación que ha sido desarrollado Ofrece un mecanismo de comunicación general entre dos procesos cualquiera que pertenezcan a un mismo sistema o a dos sistemas diferentes DEFINICIÓN DE SOCKET Un socket es un punto de comunicación por el cual un proceso puede emitir o recibir información En el interior de un proceso, se identificará por un descriptor de la misma naturaleza que los que identifican los archivos Características de un socket A cada una de ellas le corresponde una constante simbólica predefinida en el archivo <sys/socketh> Dominio de un socket: Conjunto de sockets con los cuales se podrá establecer una comunicación por medio de él Asimismo, especifica el formato de las direcciones que se podrán dar al socket y los diferentes protocolos soportados por las comunicaciones vía los sockets de este conjunto La estructura genérica para el formato de una dirección de socket es: struct sockaddr{ u_short sa_family; /* familia de dirección */ char sa_data[14]; /* 14 octetos de dirección (máximo) */ ; que será reemplazada por la estructura correspondiente del dominio de comunicación utilizado, para una aplicación particular Dominio UNIX (AF_UNIX) Los sockets son locales al sistema donde han sido definidos Permiten la comunicación interna de procesos La estructura de una dirección en este dominio está predefinida en <sys/unh> : struct sockaddr_un{ short sun_family; /* dominio UNIX: AF_UNIX */ char sun_data[108]; /* referencia de dirección */ ; Universidad de Las Palmas de Gran Canaria 25-1

3 Dominio Internet (AF_INET) Las direcciones de los sockets tienen la estructura sockaddr_in Por mediación de ésta, será posible designar un servicio sobre una máquina particular struct in_addr{ u_long s_addr; ; struct sockaddr_in{ short sin_family; /* familia de dirección: AF_INET */ u_short sin_port; /* el número de puerto */ struct in_addr sin_addr; /* la dirección Internet */ char sin_zero[8]; /* un campo de 8 ceros */ ; Para comunicar utilizando los protocolos Internet, el primer campo tendrá como valor AF_INET El segundo campo será un número de puerto; en el caso de servicios estándares, se podrá utilizar un nombre simbólico para designar el puerto (IPPORT_TCP o IPPORT_TELNET) y en el caso contrario, un número de puerto nulo o superior a IPPORT_RESERVED El tercer campo es una dirección Internet (en representación estándar) o el valor INADDR_ANY (en el caso de que el sistema local sea una pasarela y, por tanto, disponga de varias direcciones diferentes) El último campo sirve para hacer coincidir el tamaño de esta estructura con la de la estructura de dirección genérica sockaddr (14 octetos de dirección máximo-) Tipo de un socket: Define las propiedades de las comunicaciones en las cuales está implicado Propiedades de comunicación Fiabilidad de la transmisión Ningún dato transmitido se pierde Conservación del orden de los datos Los datos llegan en el orden en el que han sido emitidos No duplicación de datos Sólo llega al destino un ejemplar de cada dato emitido Comunicación en modo conectado Se establece una conexión entre dos puntos antes del principio de la comunicación A partir de entonces, una emisión desde un extremo está implícitamente destinada al otro extremo conectado Conservación de los límites de los mensajes Los límites de los mensajes emitidos se pueden encontrar en el destino Envío de mensajes <<urgentes>> Corresponde a la posibilidad de enviar datos fuera del flujo normal y por consecuencia accesibles inmediatamente (datos fuera de flujo u out of band) Tipos disponibles Universidad de Las Palmas de Gran Canaria 25-2

4 SOCK_DGRAM Sockets destinados a la comunicación en modo no conectado para el envío de datagramas de tamaño limitado Las comunicaciones correspondientes tienen la propiedad 5 En el dominio Internet, el protocolo subyacente es el protocolo UDP SOCK_STREAM Los sockets de este tipo permiten comunicaciones fiables en modo conectado (propiedades 1-4) y eventualmente autorizan (según el protocolo aplicado) los mensajes fuera de banda (propiedad 6) El protocolo subyacente en el dominio Internet es TCP SOCK_RAW Permite el acceso a los protocolos de más bajo nivel (por ejemplo, el protocolo IP en el dominio Internet) Su uso está reservado al superusuario Permite implantar nuevos protocolos 252 Creación y Supresión de un Socket Creación: int socket (dominio, tipo, protocolo) int dominio; /* AF_UNIX, AF_INET, */ int tipo; /* SOCK_DGRAM, SOCK_STREAM, */ int protocolo; /* 0: protocolo por defecto */ En caso de fallo, se devuelve el valor 1; si no, un descriptor para su uso El tercer parámetro es generalmente 0: el sistema elige entonces el protocolo por defecto asociado al tipo y al dominio del socket creado Supresión: Un socket es suprimido cuando ya no hay ningún proceso que posea un descriptor para accederlo Esta supresión es el resultado de, al menos, una llamada a la primitiva close Enlazamiento socket-dirección Primitiva bind: Después de su creación, un socket no es accesible más que por los procesos que conocen su descriptor La primitiva bind permite con una sola operación dar un nombre a un socket: int bind (sock, p_direccion, lg) Universidad de Las Palmas de Gran Canaria 25-3

5 int sock; /* descriptor de socket */ struct sockaddr *p_direccion; /* puntero de memoria a la dirección */ int lg; /* longitud de la dirección */ Para una utilización en un dominio particular, el puntero p_direccion apunta a una zona cuya estructura es la de una dirección en ese dominio (sockaddr_un para AF_UNIX y sockaddr_in para AF_INET) El socket nombrado después de realizarse con éxito la primitiva (valor de retorno 0), puede ser identificado por cualquier proceso por medio de la dirección que se le ha dado sin necesidad de poseer un descriptor (lo que es a priori imposible si el proceso no pertenece al sistema del socket) El dominio Unix: Los sockets de este dominio no se destinan más que a una comunicación local Por tanto, les corresponden direcciones locales que son referencias UNIX idénticas a las de los archivos Un socket de este dominio aparecerá después del nombrado en los resultados producidos por la orden ls con el tipo s La supresión de una referencia de este tipo es por medio de la orden rm o de la primitiva unlink La orden siguiente ilustra la creación y conexión de un socket del dominio UNIX: $ sockunix /tmp/a & [1] enlazamiento conseguido $ cat sockunixc /* Orden de creación y nombrado de un socket del dominio UNIX El nombre del socket se da como parámetro */ #include <stdioh> #include <sys/typesh> #include <sys/socketh> #include <sys/unh> void main (int n, char *v[]) { int sock; /* descriptor del socket */ static struct sockaddr_un adr; /* dirección del socket */ if (n!= 2) { fprintf(stderr, error de parámetro\n ); exit(2); Universidad de Las Palmas de Gran Canaria 25-4

6 sock = socket(af_unix, SOCK_DGRAM, 0); if (sock == -1) { perror( socket ); exit(2); adrsun_family = AF_UNIX; bcopy(v[1], adrsun_data, strlen(v[1])); if (bind(sock, &adr, sizeof(adr)) == -1) { perror( bind ); exit(2); printf( enlazamiento conseguido\n ); while (1); El dominio Internet: La conexión a una dirección Internet de un socket de este dominio necesita la preparación de un objeto que tenga la estructura sockaddr_in Esto supone: - el conocimiento de la dirección de la máquina local (primitiva gethostname y función gethostbyname) o la elección del valor INADDR_ANY; - la elección de un número de puerto Puerto de un servicio existente (función getservbyname), cualquier número de puerto (>=IPPORT_RESERVED) elegido por el usuario o elección del sistema (valor 0 en el campo sin_port) En ciertas circunstancias, un proceso puede disponer de un descriptor de un socket conectado o enlazado a una dirección, pero sin saber cuál es (si la conexión ha sido realizada por otro proceso y el proceso ha heredado el descriptor o si la conexión ha sido realizada sin especificar el número de puerto) La primitiva getsockname permite recuperar la dirección relacionada con el socket de descriptor sock int getsockname (sock, p_adr, p_lg) int sock; /* descriptor del socket */ struct sockaddr *p_adr; /* puntero a la zona de dirección */ int *p_lg; /* puntero a la longitud de la dirección */ Cuando se llama a esta primitiva, el tercer parámetro se utiliza como dato y como resultado: - en la llamada, *p_lg tiene como valor el tamaño de la zona reservada a la dirección p_addr para recuperar la dirección del socket; - en el retorno de la llamada, *p_lg tiene como valor el tamaño efectivo de la dirección Universidad de Las Palmas de Gran Canaria 25-5

7 El valor de retorno de la primitiva es 0 ó -1, según si la llamada ha tenido éxito o no A continuación, se muestra el código de una función crearsock, que permite la creación y la conexión de un socket del dominio Internet: $ cat crearsockc /* Función de creación de un socket Número de puerto dado como parámetro (modificado si 0) Se devuelve como resultado el descriptor del socket */ #include <stdioh> #include <sys/typesh> #include <sys/socketh> #include <netinet/inh> #include <netdbh> int crearsock (int *port, int type) { int desc; /* descriptor del socket */ struct sockaddr_in nom; /* dirección del socket */ int longitud; /* longitud de la dirección */ /* creación del socket */ if ( (desc = socket(af_inet, type, 0) == -1) { perror( creación imposible del socket ); exit(2); /* preparación de la dirección */ bzero((char *)&nom, sizeof(nom)); nomsin_port = *port; nomsin_addrs_addr = INADDR_ANY; nomsin_family = AF_INET; if ( bind(desc, &nom, sizeof(nom)) == -1 ) { perror( nombrado del socket imposible ); exit(3); longitud = sizeof(nom); if ( getsockname(desc, &nom, &longitud) == -1 ) { perror( obtención del nombre del socket ); exit(4); *port = ntohs(nomsin_port); return (desc); Universidad de Las Palmas de Gran Canaria 25-6

8 LA COMUNICACIÓN POR DATAGRAMAS Este apartado está dedicado al estudio de los mecanismos relativos a la comunicación de procesos por medio de sockets del tipo SOCK_DGRAM (cualquiera que sea su dominio de definición) Un proceso que desee emitir un mensaje con destino a otro debe, por una parte, disponer de un punto de comunicación local (descriptor del socket sobre el sistema local) y por otra parte, conocer una dirección del sistema al cual pertenezca su interlocutor (esperando que este interlocutor disponga de un socket conectado o enlazado a esta direccióneste tipo de comunicación no permite estar seguro de ello) Los sockets de este tipo se utilizan en modo no conectado: en principio toda petición de envío de un mensaje debe incluir la dirección del socket de destino Sin embargo, veremos que es posible establecer una <<pseudoconexión>> entre dos sockets del tipo SOCK_DGRAM haciendo implícita la dirección del socket para una emisión Operaciones de envío y de recepción Primitiva sendto: int sendto (sock, msg, lg, opcion, p_dest, lgdest) int sock; /* descriptor del socket de emisión */ char *msg; /* dirección del mensaje a enviar */ int lg; /* longitud del mensaje */ int opcion; /* = 0 para el tipo SOCK_DGRAM */ struct sockaddr *p_dest; /* puntero a la dirección del socket */ /* destino */ int lgdest; /* longitud de la dirección del socket */ /* destino */ El valor de retorno de la primitiva es, en caso de éxito, el número de caracteres enviados y 1 en caso de fallo Insistamos en el hecho de que los únicos errores detectados son los locales Así, no hay ninguna detección de que un socket esté enlazado a la dirección dada Esto significa en particular que si un mensaje se emite con destino a una máquina existente sobre un puerto no asociado a un socket, el mensaje se perderá y el emisor no será avisado Por el contrario, la validez del descriptor sock o de la dirección del mensaje se comprueban Incluso, el sistema indica un error si el tamaño del mensaje a emitir, debido al protocolo subyacente, es incompatible con la atomicidad de la emisión (de este modo, para el protocolo UDP utilizado para este tipo de envío en el dominio Internet, un mensaje debe ser en general de longitud < 2 K) Universidad de Las Palmas de Gran Canaria 25-7

9 Añadir que no es necesario que un socket esté nombrado para que pueda ser utilizado para enviar un mensaje con la primitiva sendto El sistema realiza automáticamente su conexión durante el primer envío Es práctico utilizar la primitiva sendmsg en el caso que un proceso deba realizar una sucesión de envíos de mensajes El interés de utilizar esta primitiva es que se realiza el envío de varios mensajes con una sola llamada al sistema, lo que mejora el rendimiento La forma de esta primitiva es: int sendmsg (sock, msg, opcion) int sock; /* descriptor del socket de emisión */ struct msghdr msg[]; /* tabla de los envíos a efectuar */ int opcion; La estructura msghdr está predefinida en <sys/socketh>: struct msghdr { caddr_t msg_name; /* dirección opcional */ int msg_namelen; /* tamaño de la dirección */ struct iovec *msg_iov; /* tabla de mensajes */ int msg_iovlen; /*nº elementos en msg_iov */ caddr_t msg_accrights; /* inutilizada para los sockets */ int msg_accrightslen; /* inutilizada para los sockets */ ; y la estructura iovec en <sys/uioh>: struct iovec { caddr_t iov_base; /* dirección del mensaje */ int iov_len; /* longitud del mensaje */ ; Primitiva recvfrom: int recvfrom (sock, msg, lg, opcion, p_exp, p_lgexp) int sock; /* descriptor del socket de recepción */ char *msg; /* dirección de recuperación del */ /* mensaje recibido */ int lg; /* tamaño del espacio reservado a la */ /* dirección msg */ int opcion; /* 0 ó MSG_PEEK*/ struct sockaddr *p_exp; /* para recuperar la dirección de */ Universidad de Las Palmas de Gran Canaria 25-8

10 /* expedición */ int *p_lgexp; /* tamaño del espacio reservado a */ /* p_exp y longitud del resultado */ Esta primitiva permite a un proceso extraer un mensaje de un socket del cual posea un descriptor Para que haya un mensaje, naturalmente es preciso que este socket haya sido enlazado o conectado a una dirección (o pseudoconectado en su creación con la primitiva socketpair) y que un proceso haya enviado un mensaje después de que haya tenido lugar este enlace El papel del parámetro lg es el de dar el tamaño del espacio reservado para memorizar el mensaje que será extraído Es preciso no perder de vista que se extraerá del socket un mensaje completo, que corresponde exactamente a la información enviada en una sola operación sendto La información recibida provendrá de un solo mensaje y los caracteres del mensaje se perderán si el parámetro lg es menor que la longitud del mensaje recibido La primitiva devuelve el número de caracteres recibidos (-1 en caso de error) Además, la llamada es bloqueante si no hay ningún mensaje para extraer del socket salvo petición contraria formulada previamente con una llamada a la primitiva ioctl de la forma: #include <sys/ioctlh> int sock; int on = 1; ioctl(sock, FIONBIO, &on); En el caso en el que el puntero p_exp es distinto de NULL, a la vuelta, la zona de dirección p_exp contiene la dirección del socket emisor Es esencial en el caso en que la llamada *p_lgexp contiene el tamaño de la zona reservada a la dirección p_exp; a la vuelta, *p_lgexp tiene el valor de la longitud efectiva de la dirección El proceso receptor tiene entonces la posibilidad de responder, si hay necesidad de ello, al mensaje recibido por medio de la primitiva sendto (recordemos que los sockets permiten la comunicación en los dos sentidos) Esto queda esquemáticamente en el dominio Internet: struct sockaddr_in adr; int sock, n, lg, lgrep; char msg[1024], rep[1024]; Universidad de Las Palmas de Gran Canaria 25-9

11 lg = sizeof(struct sockaddr_in); n = recvfrom(sock, msg, 1024, 0, &adr, &lg); n = sendto(sock, rep, lgrep, 0, &adr, lg); La opción MSG_PEEK permite consultar el socket: se lee un mensaje, pero no se extrae como es el caso sin esta opción La primitiva recvmsg permite realizar una serie de recepciones de mensajes: int recvmsg (sock, msg, opcion) int sock; /* descriptor del socket de recepción */ struct msghdr msg[]; /* tabla de mensajes recibidos */ int opcion; 253 Ejemplo completo El siguiente ejemplo completo pone en relación un proceso cliente con un proceso servidor (un proceso <<demonio>>) Los dos procesos intercambian datagramas en el dominio El proceso servidor está en espera de recepción de mensajes sobre un socket enlazado a un puerto UDP conocido por los clientes que quieren dirigirse a él (aquí, PORT = 2222) Una petición formulada por un cliente consiste simplemente en una cadena de caracteres que el cliente quiere saber si corresponde a la identificación de un usuario sobre el sistema al que pertenece el servidor, y si es éste el caso, obtener las informaciones (contenidas en el archivo /etc/passwd) relativas a este usuario El servidor: El código del servidor comporta las siguientes etapas: Creación y enlace al puerto de servicio de un socket (se utiliza la función crearsock descrita anteriormente) Desconexión del servidor de su terminal de lanzamiento o ejecución Bucle infinito en el cual el servidor: Espera una petición La trata (llamada a la función estándar getpwnam que permite consultar el archivo /etc/passwd) Pone la forma de respuesta (el campo type permite distinguir el caso que el usuario es desconocido (1) y el que no lo es (2) Envía la respuesta Universidad de Las Palmas de Gran Canaria 25-10

12 El servidor se ejecuta en background $ cat quienesdc /* Servidor Internet en el puerto UDP número 2222 que devuelve las */ /* informaciones relativas a un usuario cuyo nombre se le ha dado */ #include <stdioh> #include <sys/typesh> #include <sys/socketh> #include <sys/ioctlh> #include <netinet/inh> #include <pwdh> #define LGUSER 20 #define LGREP 256 #define PORT 2222 void main (int n, char *v[]) { int lg, sock, port, n; int d; char user[lguser]; /* el mensaje recibido */ struct sockaddr_in adr; /* dirección del socket remoto */ struct passwd *getpwnam(), *p; /* la respuesta enviada */ struct respuesta { char type; /* 1: error; 2: OK */ char info[lgrep]; /* las informaciones pedidas si type = 2 */ rep; port = PORT; if ( (sock = crearsock(&port, SOCK_DGRAM)) == -1 ) { fprintf(stderr, Fallo en la creación/conexión del socket\n ); exit(2); /* desconexión del servidor del terminal */ close(0); close(1); close(2); if ( (d = open( /dev/tty )) > -1 ) { ioctl(d, TIOCNOTTY, 0); close(d); setpgrp(); while (1) { /* espera de pregunta sobre el socket */ lg = sizeof(adr); bzero(user, LGUSER); bzero((char *)&rep, sizeof(rep)); n = recvfrom(sock, user, LGUSER, 0, &adr, &lg); Universidad de Las Palmas de Gran Canaria 25-11

13 if ( (p = getpwnam(user)) == NULL) reptype = 1; else { reptype = 2; sprintf(repinfo, %d %d %s %s %s\n, p->pw_uid, p->pw_gid, p->pw_gecos, p->pw_dir, p->pw_shell); /* envío de la respuesta */ n = sendto(sock, (char *)&rep, sizeof(struct respuesta), 0, &adr, lg); $ quienesd & [1] El Cliente: Su código comporta las siguientes etapas: Creación del socket local (su enlace o conexión no es necesario, ya que el cliente comenzará emitiendo y el enlace se realizará automáticamente) Preparación de la dirección del servidor Envío del mensaje Espera del resultado Explotación del resultado $ cat userc /* Programa que permite obtener las informaciones contenidas en el archivo /etc/passwd de una máquina de nombre dado como primer parámetro, concernientes a un usuario que se da como segundo parámetro El servicio correspondiente en la máquina remota está asociado al puerto 2222 */ #include <stdioh> #include <sys/typesh> #include <sys/socketh> #include <netdbh> #include <netinet/inh> #define PORT 2222 #define LGREP 256 void main (int n, char *v[]) { Universidad de Las Palmas de Gran Canaria 25-12

14 int lg, sock, uid, gid, n; char p[lgrep]; struct sockaddr_in adr; struct hostent *hp; struct { char type; char info[lgrep]; rep; if (n < 3) { fprintf(stderr, número de parámetros incorrecto\n ); exit(2); /* preparación de la dirección del socket destino */ if ( (hp = gethostbyname(v[1])) == NULL ) { perror( nombre de la máquina ); exit(2); bzero((char *)&adr, sizeof(adr)); sock = socket(af_inet, SOCK_DGRAM, 0); adrsin_family = AF_INET; adrsin_port = htons(port); bcopy(hp->h_addr, &adrsin_addr, hp->h_length); /* envío del mensaje constituido por el nombre del usuario */ if ( sendto(sock, v[2], strlen(v[2]), 0, &adr, sizeof(adr)) == -1 ) { perror( sendto ); exit(2); /* espera de la respuesta por parte del servidor */ lg = sizeof(adr); n = recvfrom(sock, (char *)&rep, sizeof(rep), 0, &adr, &lg); /* explotación de la respuesta */ if ( reptype == 1 ) fprintf(stderr, %s: usuario desconocido en %s\n, v[2], v[1]); else { printf( usuario %s en %s\n\n, v[2], v[1]); sscanf(repinfo, %d %d % [^\n], &uid, &gid, p); printf( uid = %d gid = %d \n, uid, gid); printf( %s \n, p); $ user germinal dupond dupond: usuario desconocido en germinal $ user germinal jmr usuario jmr en germinal Universidad de Las Palmas de Gran Canaria 25-13

15 uid = 102 gid = 20 Rifflet Jean-Marie /ens/jmr /bin/csh La estructura hostent se encuentra predefinida en netdbh y corresponde a una entrada en el archivo /etc/hosts: struct hostent{ char *h_name; /* nombre oficial de la máquina */ char **h_aliases; /* lista de alias */ int h_addrtype; /* tipo de dirección: AF_INET */ int h_length; /* longitud de la dirección */ char **h_addr_list; /* lista de direcciones */ #define h_addr h_addr_list[0] /* la primera dirección de la lista */ ; Las <<pseudoconexiones>> Este mecanismo permite simplemente alegar la escritura de aplicaciones en el caso de que un socket del tipo SOCK_DGRAM no se utilice más que para comunicar sólo con otro Sin embargo, es necesario tener en cuenta que una pseudocomunicación de este tipo no modifica en nada las características generales del modo de comunicación (en particular en lo que concierne a su fiabilidad) Primitiva connect: Utilizada con sockets del tipo SOCK_DGRAM, permite asociar un socket de dirección dada a un socket local (dado por su descriptor) Se verá que tiene un papel diferente con los sockets SOCK_STREAM int connect (sock, p_adr, lgadr) int sock; /* descriptor del socket local */ struct sockaddr *p_adr; /* puntero a la dirección del socket asociado */ int lgadr; /* longitud de la dirección */ Después de la <<pseudoconexión>> de un socket a otro, todas las emisiones de mensajes, vía el primero, tendrán como destino el segundo, que no podrá recibir más que los mensajes que provengan del otro Es importante notar que esta pseudoconexión es local: no tiene ninguna incidencia sobre el socket del cual se ha dado la dirección (la dirección del socket remoto está memorizada en la estructura asociada al socket local) Un segundo parámetro igual a NULL en una llamada a la primitiva connect suprime una asociación anterior Primitiva socketpair: Permite crear dos sockets y asociarlos Universidad de Las Palmas de Gran Canaria 25-14

16 int socketpair (dominio, tipo, protocolo, p_sock) int dominio; /* AF_UNIX */ int tipo; /* SOCK_DGRAM, SOCK_STREAM */ int protocolo; /* 0 */ int *p_sock; /* tabla de dos enteros */ Se recupera en la dirección *p_sock el valor de los descriptores de los dos sockets creados Además, con esta primitiva no se puede trabajar más que localmente (es decir, en el dominio UNIX) Primitiva send: La dirección de destino es implícita int send (sock, msg, lg, opcion) int sock; /* descriptor del socket local */ char *msg; /* dirección de memoria del mensaje */ int lg; /* longitud del mensaje */ int opcion; /* = 0 */ Primitiva recv: La dirección de origen es implícita int recv (sock, msg, lg, opcion) int sock; /* descriptor del socket local */ char *msg; /* dirección de memoria para guardar el */ /* mensaje */ int lg; /* longitud de la zona reservada a la */ /* dirección msg */ int opcion; /* 0 ó MSG_PEEK*/ 254 La comunicación en modo conectado Es el modo utilizado por las aplicaciones estándar de la familia Internet, tales como telnet, ftp o aplicaciones UNIX como rlogin Aporta la fiabilidad de los intercambios de información con el precio de un incremento de su volumen Universidad de Las Palmas de Gran Canaria 25-15

17 Como indica el nombre de este modo de comunicación, es necesario para utilizarlo realizar una conexión (establecer un <<circuito virtual>>) entre dos puntos Las características importantes de la comunicación en este modo son: la fiabilidad; el aspecto continuo de la información (<<flujo>>) Punto de vista del servidor Su papel es pasivo en el establecimiento de la comunicación: después de haber avisado al sistema al que pertenece de que está preparado para responder a las peticiones de servicio, el servidor se pone a la espera de peticiones de conexión que provengan de clientes Para esto dispone de un socket de escucha, enlazado al puerto TCP correspondiente al servicio, sobre el que espera las peticiones de conexión Cuando llega al sistema una petición de este tipo, se despierta al proceso servidor y se crea un nuevo socket: es este último, que llamaremos socket de servicio, el que se conecta al del cliente Entonces el servidor podrá, por una parte, delegar el trabajo necesario para la realización del servicio a un nuevo proceso (creado por fork) que utilizará entonces efectivamente la conexión y, por otra parte, retomará su <<vigilia>> sobre el socket de escucha El esquema general de funcionamiento de un servicio se presenta a continuación: Creación y enlace del socket de escucha socket/bind Apertura del servicio listen Espera de demanda de conexión accept PADRE Creación de un subproceso fork HIJO Tratamiento de la demanda Universidad de Las Palmas de Gran Canaria 25-16

18 No se volverá sobre la primera etapa cuyo objetivo es simplemente dotar al servidor de un punto de comunicación direccionable desde el exterior Primitiva listen: Esta primitiva permite a un servidor señalar a un sistema que acepta las peticiones de conexión Para llamar con éxito a la primitiva listen (por tanto, con valor de retorno 0), el proceso debe disponer de un descriptor de socket del tipo SOCK_STREAM Si el socket no está previamente enlazado a un puerto, el sistema procede a este enlace En este caso, será necesario hacer una llamada a la primitiva getsockname para conocer el número del puerto atribuido int listen (sock, nb) int sock; /* descriptor del socket de escucha */ int nb; /* número máximo de peticiones de conexión pendientes */ El segundo parámetro define el tamaño de un archivo en el cual se memorizan las peticiones de conexión formuladas, preparadas (desde el punto de vista de los clientes están establecidas), pero todavía no notificadas al servidor El tamaño del archivo está limitado a un cierto valor por el sistema (en general cinco) Primitiva accept: Esta primitiva permite extraer una conexión pendiente en el archivo asociado a un socket para la cual se ha realizado una llamada a listen De esta manera, el sistema toma conocimiento de un enlace realizado Como se ha dicho, el enlace con el socket del cliente se realiza con un nuevo socket cuyo descriptor se envía como resultado de la función: int accept (sock, p_adr, p_lgadr) int sock; /* descriptor del socket */ struct sockaddr *p_adr; /* dirección del socket conectado */ int *p_lgadr; /* puntero al tamaño de la zona reservada a */ /* p_adr */ El socket de servicio creado se enlaza a un nuevo puerto (tomado del conjunto de puertos no reservados) A la vuelta, también se recupera en memoria, en la zona apuntada por p_adr, la dirección del socket del cliente con el cual se ha establecido la conexión El valor de Universidad de Las Palmas de Gran Canaria 25-17

19 *p_lgadr se modifica: si en la llamada era el tamaño de la zona reservada para guardar la dirección, en el retorno da el tamaño efectivo de la dirección En el caso en el que no existe ninguna conexión pendiente en el archivo, el proceso se bloquea hasta que exista una ( o hasta que llegue una señal!) a menos que el socket esté en modo no bloqueante En este último caso, la primitiva devuelve el valor 1 y la variable errno tiene como valor EWOULDBLOCK $ cat servidorc #include <stdioh> #include <sys/typesh> #include <sys/socketh> #include <signalh> #include <netinet/inh> #include <fcntlh> #include <sys/ioctlh> #include <netdbh> #define PORT 1234 void service (int sock) /* Proceso de servicio: redirección de entrada/salida en el socket de servicio cuyo descriptor se da como parámetro y ejecución de un shell interactivo */ { int i; for (i=0;i<3;i++) { close(i); dup(sock); execl("/bin/bsh", "bsh", "-i", 0); int crearsock (int *port, int type) /* Función de creación de un socket Número de puerto dado como parámetro (modificado si 0) Se devuelve como resultado el descriptor del socket */ { int desc; /* descriptor del socket */ struct sockaddr_in nom; /* dirección del socket */ int longitud; /* longitud de la dirección */ /* creación del socket */ if ( (desc = socket(af_inet, type, 0)) == -1) { perror("creación imposible del socket"); exit(2); Universidad de Las Palmas de Gran Canaria 25-18

20 /* preparación de la dirección */ bzero((char *)&nom, sizeof(nom)); nomsin_port = *port; nomsin_addrs_addr = INADDR_ANY; nomsin_family = AF_INET; if ( bind(desc, &nom, sizeof(nom)) == -1 ) { perror("nombrado del socket imposible"); exit(3); longitud = sizeof(nom); if ( getsockname(desc, &nom, &longitud) == -1 ) { perror("obtención del nombre del socket"); exit(4); *port = ntohs(nomsin_port); return (desc); void main (int n, char *v[]) /* Servidor Internet en el puerto TCP número 1234 */ { int sock_escucha, sock_service; struct sockaddr_in adr; int lgadr = sizeof(adr); int d; int port = PORT; /* creación del socket de escucha */ if ( (sock_escucha = crearsock(&port, SOCK_STREAM)) == -1 ) { fprintf(stderr, "Fallo en la creación/conexión del socket\n"); exit(2); /* desconexión del servidor del terminal */ close(0); close(1); close(2); if ( (d = open("/dev/tty", O_RDWR)) > 0 ) { ioctl(d, TIOCNOTTY, 0); close(d); /* eliminación de procesos de servicio que terminan; */ /* el proceso servidor ignora la señal SIGCLD */ signal(sigcld, SIG_IGN); /* creación de la cola de conexiones pendientes */ listen(sock_escucha, 5); /* bucle de aceptación de la conexión */ while (1) { lgadr = sizeof(adr); Universidad de Las Palmas de Gran Canaria 25-19

21 sock_service = accept(sock_escucha, &adr, &lgadr); if (fork() == 0) { /* el proceso de servicio no utiliza el socket de escucha */ close(sock_escucha); /* llamada a la función de servicio */ service(sock_service); exit(0); /* el proceso padre no utiliza el socket de servicio */ close(sock_service); Punto de vista del cliente Un cliente es la entidad activa en el establecimiento de una conexión: es el que toma la iniciativa de la demanda de conexión a un servidor Esta demanda se realiza por medio de la primitiva connect de la que ya se ha hablado para el establecimiento de pseudoconexiones de sockets del tipo SOCK_DGRAM Sin embargo, aquí la semántica de la primitiva es completamente diferente: solicita el establecimiento de una conexión que será conocida por los dos extremos Además, el cliente está informado del éxito o del fracaso del establecimiento de la conexión La organización general de un cliente se presenta a continuación: Creación (y eventualmente enlace de un socket) socket/bind Construcción de la dirección del servidor Fallo Demanda de conexión connect Éxito Diálogo con el servidor Universidad de Las Palmas de Gran Canaria 25-20

22 Primitiva connect: Toda conexión entre dos sockets del tipo SOCK_STREAM, en un dominio distinto del UNIX, es el resultado de una llamada con éxito a esta primitiva (en el dominio UNIX, una llamada a la primitiva socketpair crea un par de sockets conectados) Así, se crea un circuito virtual entre los dos procesos cuyos extremos son los sockets Este circuito permite intercambios bidireccionales La forma de la primitiva es idéntica a la que hemos dado para la pseudoconexión de sockets dedicados al intercambio de datagramas: int connect (sock, p_adr, lgadr) int sock; /* descriptor del socket local */ struct sockaddr *p_adr; /* dirección del socket remoto */ int lgadr; /* longitud de la dirección */ El socket correspondiente al descriptor sock será conectado o enlazado a una dirección local, en el caso de que no lo estuviera ya previamente La conexión puede establecerse (y la primitiva connect devuelve el valor 0) si se cumplen las siguientes condiciones: los parámetros son <<localmente>> correctos; la dirección *p_adr se asocia a un socket del tipo SOCK_STREAM en el mismo dominio que el socket local de descriptor sock y un proceso (servidor) tiene solicitado escuchar sobre este socket (por una llamada a listen); la dirección *p_adr no está utilizada por otra conexión; el archivo de conexiones pendientes del socket distante o remoto no está lleno En caso de éxito, el socket local sock está conectado con un nuevo socket y la conexión está pendiente hasta que el servidor tenga conocimiento de ella a través de la primitiva accept Sin embargo, el cliente puede comenzar a escribir o a leer del socket En el caso de que no se cumpla alguna de las condiciones a), b) o c), el valor devuelto por la primitiva es 1 y la variable errno permite conocer la razón del fallo El comportamiento de la primitiva es particular si no se cumple la condición d): Si el socket es de modo bloqueante, el proceso se bloquea La petición de conexión se repite durante un cierto tiempo; si al cabo de este lapso de tiempo la conexión no se ha podido establecer, el proceso es despertado (valor devuelto 1 y errno = ETIMEDOUT) Si el socket es de modo bloqueante, la vuelta es inmediata (errno = EINPROGRESS) Sin embargo, la petición de conexión no se abandona en seguida (se repite durante el mismo lapso de tiempo) Universidad de Las Palmas de Gran Canaria 25-21

23 El diálogo Servidor / Cliente Una vez establecida la conexión entre un servidor y un cliente a través de dos sockets, los dos procesos pueden intercambiar flujos de información A diferencia de lo que pasa en la comunicación por datagramas, el corte en diferentes mensajes no está preservado en el socket destino Esto significa que el resultado de una operación de lectura puede provenir de la información resultado de varias operaciones de escritura Además, en el caso de los sockets del dominio Internet, una petición de escritura de una cadena de caracteres larga, puede provocar el partido de esta cadena, siendo accesibles los diferentes fragmentos por el socket destino En este caso, la única garantía que proporciona el protocolo TCP es que los fragmentos son accesibles en el orden correcto Esto implica que la sincronización de una recepción y una emisión en una conexión de un mismo número de elementos no está asegurada por este mecanismo La emisión: La escritura sobre un socket conectado es directamente realizable por medio de la primitiva de escritura estándar write: int write (sock, msg, lg) int sock; /* descriptor del socket local */ char *msg; /* dirección de memoria del mensaje a enviar */ int lg; /* longitud del mensaje */ Sin embargo, una operación de este tipo no permite utilizar plenamente los mecanismos ofertados por los protocolos particulares (por ejemplo, para el protocolo TCP, la posibilidad de enviar informaciones urgentes) En el caso en que se desea explotar estas posibilidades, es necesario utilizar la primitiva específica send: int send (sock, msg, lg, opcion) int int sock; /* descriptor del socket local */ char *msg; /* dirección de memoria del mensaje a enviar */ int lg; /* longitud del mensaje */ opcion; /* 0 ó MSG_OOB*/ El uso de esta primitiva con el valor 0 para el parámetro opcion es equivalente al de la primitiva write La escritura en un socket bloquea el proceso que la realiza en el caso de que se dé alguna de las dos condiciones siguientes: - el tampón de recepción del socket destino esté lleno; - el tampón de emisión del socket local esté lleno Universidad de Las Palmas de Gran Canaria 25-22

24 Sin embargo, un socket puede convertirse en no bloqueante mediante una llamada a la primitiva ioctl El valor devuelto es el número de caracteres emitidos (-1 en caso de error) La recepción: Igual que para la emisión sobre un socket, es posible utilizar la primitiva estándar de lectura: int read (sock, msg, lg) int sock; /* descriptor del socket local */ char *msg; /* dirección de memoria para grabar el mensaje */ int lg; /* longitud de la zona reservada a la dirección msg */ y la primitiva recv que permite, por una parte, la extracción de información urgente (MSG_OOB) y, por otra parte, la consulta sin extracción (MSG_PEEK) int recv (sock, msg, lg, opcion) int sock; /* descriptor del socket local */ char *msg; /* dirección de memoria para grabar el mensaje */ int lg; /* longitud de la zona reservada a la dirección msg */ int opcion; /* 0 ó MSG_OOB ó MSG_PEEK */ Estas diferentes primitivas son bloqueantes, salvo solicitud contraria: si no llega ningún carácter al socket (y la conexión todavía está establecida), el proceso lector está bloqueado El corte de la conexión: La primitiva: int shutdown (desc, sens) int desc; /* descriptor de socket */ int sens; /* 0, 1 ó 2 */ permite a un proceso especificar que ya no desea recibir (sens = 0), emitir (sens = 1) o ni recibir ni emitir (sens = 2) sobre un socket conectado de descriptor desc $ cliente germinal 1234 $ hostname /* en la máquina remota */ germinal $ ^D $ /* volvemos a la máquina local */ Universidad de Las Palmas de Gran Canaria 25-23

25 $ cat clientec /* Programa que recibe como parámetros el nombre de la máquina remota y el * puerto de escucha al que solicita una conexión A continuación, lee una orden del * teclado, la transmite y lee la respuesta en el socket; finalmente visualiza el * resultado en la pantalla */ #include <stdioh> #include <sys/typesh> #include <sys/socketh> #include <netdbh> #include <netinet/inh> #define TAMANO 256 void main (int n, char *v[]) { int desc; /* descriptor del socket creado */ struct sockaddr_in nom; /* dirección del socket destino */ struct hostent *hp, *gethostbyname(); char com[tamano]; /* para las comunicaciones */ if (n!= 3) { fprintf(stderr, "número de parámetros incorrecto\n"); exit(1); /* creación del socket */ if ( (desc = socket(af_inet, SOCK_STREAM, 0)) == -1 ) { perror("creación del socket imposible"); exit(2); /* búsqueda de la dirección internet del servidor */ if ( (hp = gethostbyname(v[1])) == NULL ) { fprintf(stderr, "%s: lugar desconocido\n", v[1]); exit(3); /* preparación de la dirección del socket destino */ bcopy(hp->h_addr, &nomsin_addr, hp->h_length); nomsin_family = AF_INET; nomsin_port = htons(atoi(v[2])); /* demanda de conexión */ if ( connect(desc, &nom, sizeof(nom)) == -1 ) { perror("connect"); exit(4); bzero(com, TAMANO); while ( scanf("%s", com)!= EOF ) { com[strlen(com)] = '\n'; /* Indispensable al shell!!! */ send(desc, com, strlen(com), 0); Universidad de Las Palmas de Gran Canaria 25-24

26 bzero(com, TAMANO); recv(desc, com, TAMANO, 0); printf("%s", com); bzero(com, TAMANO); Universidad de Las Palmas de Gran Canaria 25-25

27 Universidad de Las Palmas de Gran Canaria 25-1