Comunicación entre procesos mediante Sockets Preparado por Gabriel Astudillo Muñoz Escuela de Ingeniería Civil Informática Universidad de Valparaíso

Transcripción

1 1 Resumen Comunicación entre procesos mediante Sockets Preparado por Gabriel Astudillo Muñoz Escuela de Ingeniería Civil Informática Universidad de Valparaíso Este documento tiene como objetivo describir algunas funciones del API de C relativas a la comunicación entre procesos a través de sockets. Todas las funciones son relativas al kernel 2.6 de Linux. Las herramienta de compilación son: gcc 4.4.5, make Conceptos generales de Redes de Computadores 2.1 Definiciones Tarjeta de red: Elemento de hardware que permite que un sistema computacional se pueda conectar a una red de datos. Se suele denominar NIC (Network Interface Card) HOST: Es cualquier nodo conectado a una red de datos. Puede ser un computador, tablet, teléfono, etc. Necesariamente debe tener por lo menos una tarjeta de red. Algunas veces se utiliza la palabra máquina, para referirse a un host. Número IP: Es identificador de un host en una red. En el caso de la dirección IPv4 (32 bits) se representa como un número de 4 dígitos, cada uno de ellos de 8 bits. Por ejemplo: Nombre de host: Es el nombre que está asociado a la IP del host. Generalmente, el servicio que permite la traducción de IP a nombre y viceversa en el servicio DNS Capas de abstracción Los protocolos de red son desarrollados en capas, donde cada capa es responsable de una función determinada dentro de una comunicación [STALLINGS, 2004]. El conjunto de protocolos TCP/IP es una combinación de protocolos en varias capas. Normalmente, se considera como un sistema de 4 capas, tal como se muestra en la Figura 1. Algunos autores, agregan la capa Medio Físico, para separar lo que es el control de la transmisión que realiza la capa de Enlace de la trasmisión misma de los datos. Aplicación SSH, , Navegador Web Transporte TCP, UDP Red IP, ICMP, IGMP Enlace de Datos Device driver, NIC Figura 1. Capas del conjunto de protocolos TCP/IP La capa de enlace de datos (data link), incluye la tarjeta de red (Network Interface Card, NIC), el driver respectivo y todo lo relacionado con comunicación a través del medio. El direccionamiento en esta capa es través de las direcciones de acceso al medio, conocidas como direcciones MAC. La para de red, denominada Capa de Internet, maneja el movimiento de datos a través de la red. El direccionamiento se realiza a través de la dirección IP. Una de las principales funciones de esta capa es el ruteamiento. Los protocolos asociados a esta capa son IP (Internet Protocol), ICMP (Internet Control Message Protocol) y IGMP (Internet Group Managment Protocolo). La capa de transporte provee un flujo de datos entre dos host. Este flujo tiene asociado un número 16 bits. Los protocolos más utilizados son TCP (Transporte Control Protocol) y UDP (User Datagram Protocol). El primero ofrece una trasferencia confiable, divide los datos a enviar en paquetes, envía acuses de recibo, maneja temporizadores y otros elementos que permiten una correcta entrega de información. El segundo, provee una comunicación más simple. Sólo envía paquetes de datos (denominados Datagramas) de un host a otro, pero no garantiza que ellos lleguen se forma correcta. Al utilizar este tipo de comunicación, es la capa de aplicación la que debe tener la capacidad de manejar la confiabilidad del flujo de datos. La capa de aplicación, maneja los detalles de una aplicación determinada. 1 Servicio DNS trabaja en el puerto UDP/53 1

2 La Figura 2 muestra cómo se realiza la comunicación entre dos host en dos redes distintas [STEVENS, 1993]. Esta situación representa el caso más general. Esta comunicación se realiza bajo el modelo Cliente-Servidor, que será formalizado en la sección 2.7. Host Ciente Cliente Web (Navegador) Protocolo HTTP Host Servidor Servidor Web TCP Protocolo TCP TCP IP Protocolo IP IP Router Protocolo IP IP Red A driver Protocolo Red A Red A driver Red B driver Protocolo Red B Red B driver Red A Red B 2.3 Capas TCP/IP Figura 2. Descripción del funcionamiento de los protocolos TCP/IP La Figura 3 muestra un diagrama que muestra cómo las distintas capas se conectan entre sí. Además, se detallan algunos protocolos que están asociados a cada capa. Aplicación Proceso de usuario Proceso de usuario Proceso de usuario Proceso de usuario Transporte TCP UDP Red ICMP IP IGMP ARP Interfaz de Hardware RARP Enlace de Datos Medio Físico Figura 3 ICMP utiliza IP para intercambiar mensaje de control entre distintos host. Algunos comando que utilizan ICMP son ping y traceroute. IGMP es ampliamente utiliza en multicasting, que es enviar datagrama UDP a múltiples host. ARP (Address Resolution Protocol) y RARP (Reverse Address Resolution Protocol) son protocolos especializados que se utilizan en algunas redes LAN (Ethernet, por ejemplo), para convertir las direcciones utilizadas por la capa de red (IP) a direcciones utilizadas en la tarje de red. 2.4 Encapsulación Una de las consecuencias del modelo por capas, es que cada una de ellas agrega datos de control adicionales a los que ya vienen de la capa superior, que se denominan cabeceras. La Figura 4 muestra esta situación. Las unidades de datos de cada protocolo son llamadas PDU (Protocol Data Unit). En la capa de transporte, el PDU de TCP es denominado Segmento y el de UDP es denominado Datagrama. En la capa de red, el PDU se llama Paquete. El de la capa de Enlace de Datos, Frame. Finalmente, el del medio físico, se denomina Símbolo (un símbolo pueden ser 1 o más bits). 2

3 Dato de usuario Cabecera Aplicación Dato de usuario PDU Aplicación Aplicación Cabecera TCP Dato Capa Aplicación PDU TCP (Segmento) Transporte Cabecera IP Segmento TCP PDU IP (Datagrama) Red Cabecera Ehernet Datagrama IP Fin Ehernet PDU Enlace (Frame) Enlace de Datos Frame Ethernet PDU Físico (Símboos) Medio Físico 2.5 Demultiplexación Figura 4 Cuando un frame Ethernet es recibido, éste es enviado a través de cada protocolo que tenga implementado el receptor, removiendo cada cabezera respectiva. Este proceso se denomina demultiplexación (Figura 5). Aplicación Aplicación 1 Aplicación n Aplicación 1 Aplicación m Transporte TCP UDP Demultiplexación basada en número de puerto de destino en el header TCP o UDP ICMP Red IP Demultiplexación basada en el tipo de protocolo que está en la cabecera IP ARP RARP Enlace de Datos Ethernet Driver Demultiplexación basada en el tipo de frame que está en la Cabecera ethernet Medio Físico Frame Ethernet entrante Figura Puertos de servicios En el punto 2.4 se mencionó que tanto TCP como UDP tienen asociados cierta cantidad de servicios, cada uno de ellos con un número de 16 bits. Estos números son estándar y son administrados por la ICANN 2 (Internet Corporation for Assigned Names and Numbers). Algunos puertos son 3 : ftp-data 20/udp # File Transfer [Default Data] ftp-data 20/tcp # File Transfer [Default Data] ftp 21/udp # File Transfer [Control] ftp 21/tcp # File Transfer [Control] ssh 22/udp # SSH Remote Login Protocol ssh 22/tcp # SSH Remote Login Protocol telnet 23/udp # Telnet telnet 23/tcp # Telnet smtp 25/udp # Simple Mail Transfer smtp 25/tcp # Simple Mail Transfer domain 53/udp # Domain Name Server domain 53/tcp # Domain Name Server http 80/udp # World Wide Web HTTP http 80/tcp # World Wide Web HTTP Normalmente, los puertos inferiores a 1024 son utilizados por el sistema operativo. Los puertos mayores o iguales a 1024 son utilizados por las aplicaciones que necesitan comunicarse con otros hosts. 2 ICANN: 3 Estos servicios se encuentran en el arhcivo /etc/services, en sistemas operativos Unix. 3

4 2.7 Modelo Cliente Servidor La mayor parte de las aplicaciones de red son desarrolladas asumiendo que consisten en dos partes: un lado servidor y otro lado cliente. El propósito de la aplicación es que el servidor provee algún servicio definido para los clientes que lo solicitan. La Figura 6 muestra el modelo de comunicación mencionado. Request Cliente Red de Datos Response Servidor Figura 6. Modelo cliente servidor. Desde el punto de vista de TCP/IP, cada solicitud y respuesta son flujos TCP/UDP, que quedan determinados por la dupla <IP, Nro Puerto>. Así, por ejempo, en la Figura 7 se muestra un modelo cliente-servidor para una conexión HTTP, entre un navegador y un sitio web. Navegador web Request Red de Datos Response Servidor web IP: Puerto: IP: Puerto: Tipos de servidores Servidores Iterativos Este tipo de servidores siguen los siguientes pasos: Figura 7. Modelo cliente servidor para una conexión HTTP. 1. Espera por el arribo de una solicitud de un cliente. 2. Procesa dicha solicitud 3. Envía la respuesta de vuelta al cliente que envío la solicitud. 4. Vuelve al paso 1. El problema con este tipo de servidor es que el paso 2 puede tomar mucho tiempo. Durante este lapso, no puede atender otros clientes. Servidor concurrente 1. Este tipo de servidores siguen los siguientes pasos: 2. Espera por el arribo de una solicitud de un cliente 3. Inicia un nuevo servidor que maneje la solicitud del cliente. Esto implica la creación de un nuevo proceso. Los detalles de cómo se realiza esta tarea depende del sistema operativo. 4. El nuevo servidor maneja completamente la solicitud del cliente. Cuando esta lista, envía la respuesta respectiva y termina. 5. Vuelve al paso 1 La ventaje de un servidor concurrente es que el servidor sólo crea otros servidores que manejan las solicitudes que llegan. Cada cliente, en esencia, tiene su propio servidor. Asumiendo que el sistema operativo permite multiprogramación, múltiples clientes pueden ser servidos concurrentemente [DONAHOO e CALVERT, 2001]. 4

5 2.8 Sockets Un socket es una abstracción del sistema operativo mediante el cual una aplicación puede enviar y recibir datos [DONAHOO e CALVERT, 2001]. Existen distintos tipos de sockets, cada uno de ellos corresponden a diferentes familias de protocolos de red. En este documento sólo se tratarán los relativos a la familia de protocolos TCP/IP. Los principales tipos de socket para esta familia son los sockets de conexión virtual y los sockets de datagramas. Los primeros utilizan TCP como protocolo de extremo a extremo, proveyendo una comunicación confiable. Por otro lado, los sockets de datagramas utilizan UDP, con lo que proveen una comunicación no confiable. Un socket que utilice TCP/IP es identificado por una dirección IP y un protocolo de extremo a extremo, que se representa por un número de puerto. Cuando un socket es creado, es asociado a un protocolo, pero no tiene una dirección IP o un número de puerto. Cuando un socket es asociado a un puerto, recién puede enviar y recibir información. La Figura 8 muestra la relación lógica que existe entre las aplicación, sockets, protocolos y números de puertos en un host determinado. Proceso de usuario Proceso de usuario Proceso de usuario Socket TCP Socket TCP Socket TCP Socket UDP Socket UDP Socket UDP Puertos TCP Puertos UDP TCP UDP IP Figura Orden de almacenamiento de los Bytes La forma en la que se almacenan los bytes en memoria varía de un sistema a otro [DONAHOO e CALVERT, 2001]. Para evitar problemas cuando se reciban o envíen datos a través de la red, es necesario convertirlos a un formato estándar, denominado formato de red. Las funciones de conversión son: htonl(): Host to Network long. Convierte un long int en formato de host a formato de red #include <arpa/inet.h> uint32_t htonl(uint32_t hostlong); htons(): Host to Network short. Convierte un short int en formato de host a formato de red #include <arpa/inet.h> uint16_t htons(uint16_t hostshort); ntohl(): Network to host long. Convierte un long int en formato de red a formato de de host. #include <arpa/inet.h> uint32_t ntohl(uint32_t netlong); ntohs(): Network to host short. Convierte un short int en formato de red a formato de de host. #include <arpa/inet.h> uint16_t ntohs(uint16_t netshort); 5

6 3 API de C para comunicación en red 3.1 Creación de socket El socket es la abstracción usada para definir un punto de comunicación. La función socket() crea un punto de comunicación y retorna un descriptor de él, similar a un descriptor de archivo. int socket (int domain, int type, int protocol); El parámetro domain especifica la familia de direcciones en que se debe interpretar la dirección del socket. Puede ser: AF_UNIX, AF_LOCAL : la comunicación va a ser local en el host. AF_INET : para comunicación que utilicen IPv4. AF_INET6 : para comunicación que utilicen IPv6. AF_PACKET : para comunicación a nivel de capa de Enlace de Datos. El parámetro type puede ser: SOCK_STREAM, lo cual especifica una conexión de circuito virtual. Es bidireccional y contínuo. En la Internet, esto significa que el protocolo de transprote es TCP. SOCK_DGRAM, lo cual especifica envío de datagramas. Esto significa que se utiliza UDP como protocolo de transporte. SOCK_RAW para acceso a un protocolo "crudo", por ejemplo directo a IP. SOCK_RDM provee servicio garantizado pero sin comprometer orden. El parámetro protocol es el número del protocolo específico a utilizar de tipo señalado. Normalmente sólo un protocolo es soportado de un tipo dado dentro de una familia de protocolos. Lo mejor es dejarlo en cero y el sistema resuelve el valor que corresponde a ese protocolo según el valor dado en type. Si la operación se realiza de forma exitosa, socket() retorna un descriptor. En caso constrario, -1. Ejemplo: Crear un socket, denominado sock, para ser utilizar para una comunicación TCP. int sock; sock = socket(af_inet, SOCK_STREAM, 0); 3.2 Cierra de un socket Para cerrar el canal de comunicación, se utiliza la función shutdown(), cuyo prototipo es el siguiente: Parámetros: int shutdown(int s, int how); s: socket a cerrar. how: cómo se va a cerrar: o 0 : Prohibido recibir. Se puede seguir enviando. o 1 : Prohibido enviar. Se puede seguir recibiendo. o 2 : Prohibido recibir y enviar. Es equivalente a close(). Retorna 0 si la operación se realizó con éxito. -1 en caso contrario. Observación: generalmente, se utiliza la función close() para cerrar el canal de comunicación. 6

7 3.3 Especificación de direcciones de internet El API de socket define una estructura genérica, denominada socketaddr, para especificar las direcciones asociadas a ellos. struct socketaddr { u_short sa_family; // Familias de direcciones (Ej. AF_INET) char sa_data[14]; // Informacion especifica El primer campo de la estructura define la familiar de direcciones a utilizar. Normalmente, se utilizrá la constante AF_INET, la que especifa la familiar de direcciones de Internet. La segunda parte es un conjunto de bits que dependen de la familia escogida. Para evitar problemas con la eterogeneidad de los sistemas operativos, se establece un largo de 14 Bytes para este campo. Los socket TCP/IP utilizan la structura socketaddr_in. En la Figura 9 se muestran las diferencias entre esta estructura y la genérica, socketaddr. struct socketaddr_in { u_short sin_family; // AF_INET u_short sin_port; // puerto de servicio struct in_addr sin_addr; // dirección asociada al puerto struct in_addr { unsigned long s_addr; ; sockaddr sa_family Familia sa_data 2 Bytes 2 Bytes 4 Bytes 8 Bytes sockaddr_in Familia Puerto Dirección de Internet No utilizado sin_family sin_port sin_addr Figura 9 Ejemplo: Se desea rellenar la estructura sockaddr_in con los datos IP/Puerto de un servidor. Los datos de él son: IP= y Puerto=80 struct sockaddr_in servidor; char *servip; u_short servport servip = ; servport = 80; bzero(&servidor, sizeof(echoservaddr)); //Rellena con ceros servidor.sin_family = AF_INET; //Familia Internet servidor.sin_addr.s_addr = inet_addr(servip);//ip del servidor servidor.sin_port = htons(echoservport); //Puerto En la especificación del puerto, se debe utilizar la función htons() debido a que se debe priorizar el hecho de que el código puede ser compilado en cualquier plataforma y su ejecución debe ser el mismo. 3.4 Funciones del lado del cliente Conexión al servidor int connect (int s, struct socketaddr *name, int addrlen); Esta función conecta el socket s con el servidor corriendo en la máquina y puerto especificada en name. Puede ser usada en conexiones datagramas o de circuito virtual. En el primer caso esta función deja claro que los próximos datagramas están dirigidos al destido donde se hace la conexión. En el segundo caso, la dirección destino debe ser especificada en cada llamado de envío del paquete de datos. 7

8 Ejemplo: Se desea conectar, mediante el socket sock, al servidor especificado por la estructura servidor. connect(sock, (struct sockaddr *)&servidor, sizeof(servidor)); Si la función connect() retorna satisfactoriamente, el socket sock está conectado y la comunicación puede proceder a utilizar las funciones de transferencias de datos send() y recv()(sección 3.6). 3.5 Funciones del lado del servidor Asociación El servidor debe asociar el socket con una puerta y dirección de interfaz de red para que los clientes puedan acceder a él. Esto se logra con la función bind(). Parámetros: int bind(int s, const sockaddr* name, int addrlen); s: socket previamente creado. addrlen: es el largo de la estructura name. name es del tipo sockaddr_in. Los host pueden tener más de una dirección Internet 4. Por ello, se debe especificar la dirección sin_addr. Si queremos atender requerimientos entrando por cualquier interfaz de red, se puede usar INADDR_ANY como dirección asociada a la interfaz Esperando por conexiones Este paso es requerido sólo en el caso de conexiones TCP. int listen (int s, int queuelimit); Esta función indica al kernel que el socket s está listo para recibir conexiones. El parámetro queuelimit especifica el máximo número de requerimientos de conexión que pueden estar pendientes en cada momento (conexiones encoladas). Si hay más clientes que el valor del parámetro tratando de conectarse, el cliente recibe un mensaje connection refused. Ejemplo: Prepare para recibir conexiones TCP en el socket servsock, con un máximo de encolamiento de 10 clientes. listen(servsock, 10); Aceptando conexiones int accept (int s, struct sockaddr *clientaddress, int *addresslength); Esta función desencola la próxima conexión. Si está vacía, bloquea el proceso hasta que llegue una conexión. Cuando se realiza de forma satisfactorio, esta función llena adecuadamente la estructura sockaddr apuntada por clientaddresss, con la dirección del host en el otro extremo de la conexión. Además, retorna un nuevo descriptor de socket que el servidor usa para comunicarse con el cliente. addresslength especifica el tamaño máximo de la estructura clientaddress y contiene la cantidad de bytes que actualmente se utilizan para la dirección después que la función retorna. Ejemplo: en el siguiente ejemplo, el socket clntsock, después de la función accept(), se debe utilizar para comunicarse con el host que se conectó al servidor. 4 Esto se logra a través de múltiples tarjetas de red o a través de interfaces virtuales. En el caso de linux, las interfaces reales ethernet se denomina, por ejemplo, eth0. Dicha interfaz, puede tener muchas interfaces virtuales, llamados eth0:0; eth0:1, etc. 8

9 int clntsock; //Socket del cliente struct sockaddr_in echoclntaddr; //Direccion cliente clntlen = sizeof(echoclntaddr) clntsock = accept(servsock, (struct sockaddr *) &echoclntaddr, &clntlen); 3.6 Funciones de transferencia de datos int recv (int s, char * msg, int len, int flags); int send (int s, const char * msg, int len, int flags); Son idénticas a read() and write(), sólo que ellas tienen un cuarto argumento, flags, para especificar como enviar o recibir los datos a través del socket s. Si este parámetro es 0, el comportamiento es el por omisión. Cuando se usa conexión datagrama, el servidor no llama a las funciones listen() y accept(), y el cliente generalemente no llama a la función connect(). En estos casos se usan las funciones: int recvfrom(int s, char * buf, int len, int flags, struct sockaddr *from, int fromlen); int sendto(int s, const char *buf, int len, int flags, struct sockaddr *to, int tolen); Ejemplo: Se desea enviar el string almacenado en la variable mensaje a través del socket sock. char* mensaje= Hola Mundo! ; send(sock, mensaje, strlen(mensaje), 0); Ejemplo: Se desea recibir un dato en la variable buffer, desde el socket sock. char buffer[1024]; recv(sock, buffer, 1024, 0); 3.7 Transformación entre nombre y dirección de máquina #include <netdb.h> extern int h_errno; struct hostent * gethostbyname(const char *name); struct hostent * gethostbyaddr(const char *address, int addresslength, int addressfamily); La estructura hostent está definida en netdb.h: struct hostent { char *h_name; //nombre oficial char **h_aliases; //alias int h_addrtype; //Tipo de direccion: AF_INET, AFINET6 int h_length; //Largo de la direccion, en bytes char **h_addr_list; Las funciones retornan una estructura hostent o un NULL en caso de error. En este último caso, la variable h_errno (definida en netdb.h) tiene el número de error, que puede ser: HOST_NOT_FOUND : El host no existe. NO_ADDRESS o NO_DATA : El nombre solicitado es válido pero no tiene una IP. NO_RECOVERY : Error en el servidor de nombres. TRY_AGAIN : Error temporal. Tratar nuevamente. 9

10 3.8 Funciones para manipular números IP El API de socket de C, tiene algunas funciones que ayudan a manipular direcciones IP. En esta sección se describirán las funciones inet_addr() y inet_ntoa(). La función inet_addr()convierte una dirección IP en un entero largo sin signo. La función inet_ntoa()convierte una dirección IP en un string. #include <netinet/in.h> #include <arpa/inet.h> in_addr_t inet_addr(const char *cp); char *inet_ntoa(struct in_addr in); Ejemplo: almacenar la ip en la estructura destino. sockaddr_in destino; destino.sin_addr.s_addr = inet_addr( ); Ejemplo: Determinar la IP que está almacenada en la estructura destino. char *ip; ip = inet_ntoa(destino.sin_addr); printf( La dirección es: %s\n, ip); 10

11 4 Cliente Servidor TCP Iterativo En la Figura 6, se muestra un esquema Cliente-Servidor genérico. En la Figura 10 se muestra un diagrama de flujo en donde se visualiza la relación que hay entre un proceso cliente y otro servidor, cuando la transmisión es orientada a la conexión (TCP), a nivel del API del lenguaje C. Cliente Inicio Servidor Inicio sock = socket(af_inet, SOCK_STREAM, 0) servsock = socket(af_inet, SOCK_STREAM, 0) bind(servsock, IP_local) connect(sock, IP_del_servidor) solicitud de conexión respuesta listen(servsock,...) clientsock = accept(servsock, &echoclntaddr) send(sock, DATOS) recv(clientsock, BUFFER) recv(sock, BUFFER) send(clientsock, DATOS) close(sock) close(clientsock) Fin Figura 10 La implementación real de estos programas se muestra en la sección Cliente Servidor UDP Iterativo En la Figura 11, se muestra un diagrama de flujo para una estructa Cliente-Servidor orientado al datagrama. La implementación en C se muestra en la sección 7.3. Cliente Inicio Servidor Inicio sock = socket(af_inet, SOCK_DGRAM, 0) servsock = socket(af_inet, SOCK_DGRAM, 0) bind(servsock, IP_local) sendto(sock, DATOS, &echoserveraddr) recvfrom(servsock, BUFFER, &echoclntaddr) recvfrom(sock, BUFFER, fromaddr) sendto(servsock, DATOS, &echoclntaddr) Verificar si el origen de los datos es válido close(sock) Fin Figura 11 11

12 6 Cliente Servidor Concurrente En la Figura 12 se muestra un diagrama de flujo de una implementación de un servidor TCP concurrente. Se basa en utilizar la función fork(). La idea es que el cliente se conecte en forma preliminar al proceso Servidor y luego sea atendido por un proceso hijo. La implementación en C se muestra en la sección 7.4. Cliente Inicio Servidor Inicio sock = socket(af_inet, SOCK_STREAM, 0) servsock = socket(af_inet, SOCK_STREAM, 0) bind(servsock, IP_local) connect(sock, IP_del_servidor) solicitud de conexión conexión aceptada listen(servsock,...) clientsock = accept(servsock, &echoclntaddr) fork() Proceso Padre Proceso Hijo close(servsock) close(clientsock) send(sock, DATOS) recv(clientsock, BUFFER) Esperar que cada hijo termine recv(sock, BUFFER) send(clientsock, DATOS) close(sock) close(clientsock) Fin Fin Figura 12 7 Ejemplos 7.1 Programa que obtiene la IP de un servidor cualquiera. #include <stdio.h> #include <stdlib.h> #include <netdb.h> #include <netinet/in.h> int main(int argc, char *argv[]){ struct hostent *servidor; if (argc!=2) { printf("uso: %s <hostname>\n",argv[0]); 12

13 if ((servidor=gethostbyname(argv[1]))==null) { printf("error de gethostbyname(). Error %d\n", h_errno); printf("nombre del host: %s\n",servidor->h_name); printf("dirección IP: %s\n", inet_ntoa(*((struct in_addr *)servidor->h_addr))); return(exit_success); 13

14 7.2 Cliente Servidor TCP Cliente #include <stdio.h> #include <stdlib.h> #include <string.h> #include <netdb.h> #include <unistd.h> #include <netinet/in.h> #define RCVBUFSIZE 2048 int main(int argc, char *argv[]){ int sock; // Descriptor socket struct sockaddr_in echoservaddr; // Direccion del servidor unsigned short echoservport; // Puerto del servidor char *servip; // IP del servidor (A.B.C.D) char *echostring; // String a enviar al servidor char echobuffer[rcvbufsize]; // int bytesrcvd // cantidad de bytes recibidos en recv() if(argc < 3 argc > 4){ fprintf(stderr, "Uso: %s <Server IP:A.B.C.D> <Echo Word> [<Echo Port>]\n", argv[0]); servip = argv[1]; echostring = argv[2] ; if (argc == 4) echoservport = atoi(argv[3]); // Utilice este puerto else echoservport = 7; //Puerto 7 es el estandar //para el servicio de eco if ((sock = socket(pf_inet, SOCK_STREAM, 0)) < 0){ perror("error en socket()"); bzero(&echoservaddr, sizeof(echoservaddr));//rellena con ceros echoservaddr.sin_family = AF_INET; //Familia Internet echoservaddr.sin_addr.s_addr = inet_addr(servip);//ip del servidor echoservaddr.sin_port = htons(echoservport); //Puerto if( connect( sock, (struct sockaddr *) &echoservaddr, sizeof(echoservaddr) ) < 0) { perror("error en Connect"); if (send(sock, echostring, strlen(echostring), 0)!= echostringlen){ perror("error en send()"); 14

15 printf("recibidos: "); bytesrcvd = recv(sock, echobuffer, RCVBUFSIZE, 0); echobuffer[bytesrcvd] = '\0'; printf(echobuffer); printf("\nbytes recibidos=%d\n", bytesrcvd); printf("\n"); close(sock); return(exit_success); Servidor #include <stdio.h> #include <stdlib.h> #include <string.h> #include <netdb.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #define MAXPENDING 5 #define RCVBUFSIZE 2048 void AtenderTCPCliente(int clntsocket); int main(int argc, char *argv[]) { int servsock; //Socket del servidor int clntsock; //Socket del cliente struct sockaddr_in echoservaddr; //Direccion Local struct sockaddr_in echoclntaddr; //Direccion cliente unsigned short echoservport; //Puerto del servidor unsigned int clntlen; if (argc!= 2){ fprintf(stderr, "USO: %s <Server Port>\n", argv[0]) ; echoservport = atoi(argv[1]); //Crear el socket para las conexiones entrantes if ((servsock = socket(pf_inet, SOCK_STREAM, 0)) < 0){ perror("error en socket()"); //Rellenar la estructura para la direccion local bzero(&echoservaddr, sizeof(echoservaddr)); echoservaddr.sin_family = AF_INET; echoservaddr.sin_addr.s_addr = htonl(inaddr_any); echoservaddr.sin_port = htons(echoservport); //Asociar a la direccion local if (bind(servsock, (struct sockaddr *)&echoservaddr, sizeof(echoservaddr)) < 0){ perror("error en bin()"); 15

16 //Hacer que el socket escuche las conecciones entrantes if (listen(servsock, MAXPENDING) < 0){ perror("error en listen()"); for(;;){ /* Set the size of the in-out parameter */ clntlen = sizeof(echoclntaddr); // Esperar que un cliente se conecte if((clntsock = accept(servsock, (struct sockaddr *) &echoclntaddr, &clntlen)) < 0) { perror("error accept()"); printf("atendiendo cliente %s\n", inet_ntoa(echoclntaddr.sin_addr)); AtenderTCPCliente(clntSock); return(exit_success); void AtenderTCPCliente(int clntsocket){ char echobuffer[rcvbufsize]; int recvmsgsize; if((recvmsgsize = recv(clntsocket, echobuffer, RCVBUFSIZE, 0)) < 0) { perror("error en recv"); while (recvmsgsize > 0){ //Cero indica EOT //Enviar el mensaje de vuelta al cliente if(send(clntsocket, echobuffer, recvmsgsize, 0)!= recvmsgsize){ perror("error send()"); //Verificar si hay mas data que recibir if((recvmsgsize = recv(clntsocket, echobuffer, RCVBUFSIZE, 0)) < 0){ perror("error recv()"); close(clntsocket); 16

17 7.3 Cliente Servidor UDP Cliente #include <stdio.h> #include <stdlib.h> #include <string.h> #include <netdb.h> #include <unistd.h> #include <netinet/in.h> #define RCVBUFSIZE 2048 int main(int argc, char *argv[]){ int sock; // Descriptor socket struct sockaddr_in echoservaddr; // Direccion del servidor struct sockaddr_in fromaddr; // Direccion de origen unsigned short echoservport; // Puerto del servidor unsigned int fromsize; // char *servip; // IP del servidor (A.B.C.D) char *echostring; // String a enviar al servidor char echobuffer[rcvbufsize]; // int echostringlen; int respstringlen; if(argc < 3 argc > 4){ fprintf(stderr, "Uso: %s <Server IP:A.B.C.D> <Echo Word> [<Echo Port>]\n", argv[0]); servip = argv[1]; echostring = argv[2] ; if(argc == 4) echoservport = atoi(argv[3]); // Utilice este puerto else echoservport = 7; //Puerto 7 es el estandar para el servicio de eco if((sock = socket(pf_inet, SOCK_DGRAM, 0)) < 0){ perror("error en socket()"); bzero(&echoservaddr, sizeof(echoservaddr)); //Rellena con ceros echoservaddr.sin_family = AF_INET; //Familia Internet echoservaddr.sin_addr.s_addr = inet_addr(servip);//ip del servidor echoservaddr.sin_port = htons(echoservport); //Puerto if(sendto(sock, echostring, strlen(echostring), 0, (struct sockaddr *)&echoservaddr, sizeof(echoservaddr)) < 0){ perror("error en sendto()"); printf("recibidos: "); 17

18 fromsize = sizeof(fromaddr); if((respstringlen = recvfrom(sock, echobuffer, RCVBUFSIZE, 0, (struct sockaddr*)&fromaddr, &fromsize)) < 0){ perror("error en recvfrom()"); if(echoservaddr.sin_addr.s_addr!= fromaddr.sin_addr.s_addr){ fprintf(stderr, "Error: received a packet from unknown source.\n"); echobuffer[respstringlen] = '\0'; printf( %s\n ;echobuffer); close(sock); return(exit_success); Servidor UDP #include <stdio.h> #include <stdlib.h> #include <string.h> #include <netdb.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #define RCVBUFSIZE 2048 int main(int argc, char *argv[]) { int servsock; //Socket del servidor struct sockaddr_in echoservaddr; //Direccion Local struct sockaddr_in echoclntaddr; //Direccion cliente unsigned short echoservport; //Puerto del servidor unsigned int cliaddrlen; //Largo del mensaje entrante int recvmsgsize; //Tamano del mensaje recibido char echobuffer[rcvbufsize]; if(argc!= 2){ fprintf(stderr, "USO: %s <Server Port>\n", argv[0]) ; echoservport = atoi(argv[1]); //Crear el socket para las conexiones entrantes if((servsock = socket(af_inet, SOCK_DGRAM, 0)) < 0){ perror("error en socket()"); //Rellenar la estructura para la direccion local bzero(&echoservaddr, sizeof(echoservaddr)); echoservaddr.sin_family = AF_INET; 18

19 echoservaddr.sin_addr.s_addr = htonl(inaddr_any); echoservaddr.sin_port = htons(echoservport); //Asociar a la direccion local if(bind(servsock, (struct sockaddr *)&echoservaddr, sizeof(echoservaddr)) < 0){ perror("error en bin()"); for(;;){ cliaddrlen = sizeof(echoclntaddr); // Esperar que un cliente se conecte if( (recvmsgsize = recvfrom(servsock, echobuffer, RCVBUFSIZE, 0, (struct sockaddr *) &echoclntaddr, &cliaddrlen ) ) < 0 ) { perror("error recvfrom()"); printf("atendiendo cliente %s\n", inet_ntoa(echoclntaddr.sin_addr)); printf("\tdato recibido : %s\n",echobuffer); printf("\tbytes recibidos: %d\n", recvmsgsize); //Enviar el datagrama de vuelta al cliente if( sendto(servsock, echobuffer, recvmsgsize, 0, (struct sockaddr *) &echoclntaddr, sizeof(echoclntaddr)) < 0 ){ perror("error sendto()"); return(exit_success); 19

20 7.4 Servidor TCP Concurrente #include <stdio.h> #include <stdlib.h> #include <string.h> #include <netdb.h> #include <unistd.h> #include <netinet/in.h> #include <arpa/inet.h> #include <sys/wait.h> /* * Servidor TCP */ #define MAXPENDING 5 #define RCVBUFSIZE 2048 void AtenderTCPCliente(int clntsocket); int main(int argc, char *argv[]) { int servsock; //Socket del servidor int clntsock; //Socket del cliente struct sockaddr_in echoservaddr; //Direccion Local struct sockaddr_in echoclntaddr; //Direccion cliente unsigned short echoservport; //Puerto del servidor unsigned int clntlen; pid_t pid; int countchild; if (argc!= 2){ fprintf(stderr, "USO: %s <Server Port>\n", argv[0]) ; echoservport = atoi(argv[1]); //Crear el socket para las conexiones entrantes if ((servsock = socket(pf_inet, SOCK_STREAM, 0)) < 0){ perror("error en socket()"); //Rellenar la estructura para la direccion local bzero(&echoservaddr, sizeof(echoservaddr)); echoservaddr.sin_family = AF_INET; echoservaddr.sin_addr.s_addr = htonl(inaddr_any); echoservaddr.sin_port = htons(echoservport); //Asociar a la direccion local if(bind(servsock, (struct sockaddr *)&echoservaddr, sizeof(echoservaddr)) < 0){ perror("error en bin()"); //Hacer que el socket escuche las conecciones entrantes if (listen(servsock, MAXPENDING) < 0){ 20

21 perror("error en listen()"); for(;;){ /* Set the size of the in-out parameter */ clntlen = sizeof(echoclntaddr); // Esperar que un cliente se conecte if ((clntsock = accept(servsock, (struct sockaddr *) &echoclntaddr, &clntlen)) < 0) { perror("error accept()"); printf("conexion aceptada del cliente %s\n", inet_ntoa(echoclntaddr.sin_addr)); if( (pid = fork()) < 0) { perror("error en fork()"); else if(pid == 0){ //Codigo del hijo close(servsock); printf("atendiendo cliente %s\n", inet_ntoa(echoclntaddr.sin_addr)); printf("con proceso %d\n", getpid()); AtenderTCPCliente(clntSock); exit(exit_success); close(clntsock); countchild++; while (countchild) { pid = waitpid((pid_t) -1, NULL, WNOHANG); if(pid < 0){ perror("error en waitpid."); if(pid == 0) break; else{ printf("eliminando proceso %d\n", pid); countchild--; 21

22 Bibliografía STALLINGS, W. Comunicaciones y Redes de Computadores. [S.l.]: Person Educación, p. ISBN DONAHOO, M. J.; CALVERT, K. L. TCP/IP Sockets in C: Practical Guide for Programmers. [S.l.]: Morgan Kaufmann, p. ISBN STEVENS, W. R. TCP/IP Illustrated Volume 1: The Protocols. [S.l.]: Addison Wesley, v. 1, p. ISBN