CENTRO DE ESTUDIOS NOVA - Cartagena Laboratorio de Software de Comunicaciones TEMA 1 FUNDAMENTOS DE SOCKETS TCP Y UDP

Transcripción

1 TEMA 1 FUNDAMENTOS DE SOCKETS TCP Y UDP Concepto de UDP UDP son las siglas de Protocolo de Datagrama de Usuario (en inglés User Datagram Protocol) un protocolo sin conexión que, como TCP, funciona en redes IP. UDP/IP proporciona muy pocos servicios de recuperación de errores, ofreciendo en su lugar una manera directa de enviar y recibir datagramas a través una red IP. Se utiliza sobre todo cuando la velocidad es un factor importante en la transmisión de la información, por ejemplo, RealAudio utiliza el UDP. El FTP utiliza TCP/IP, mientras que TFTP utiliza UDP. TFTP son las siglas de Protocolo de Transferencia de Archivos Triviales (en inglés Trivial File Transfer Protocol), y puesto que es trivial, perder algo de información en la transferencia no es crucial. Concepto de TCP El Protocolo de Control de Transmisión (TCP en sus siglas en inglés, Transmission Control Protocol que fue creado entre los años por Vint Cerf y Robert Kahn) es uno de los protocolos fundamentales en Internet. Muchos programas dentro de una red de datos compuesta por ordenadores pueden usar TCP para crear conexiones entre ellos a través de las cuales enviarse datos. El protocolo garantiza que los datos serán entregados en su destino sin errores y en el mismo orden en que se transmitieron. También proporciona un mecanismo para distinguir distintas aplicaciones dentro de una misma máquina, a través del concepto de puerto (computación). TCP soporta muchas de las aplicaciones más populares de Internet, incluidas HTTP, SMTP y SSH. Servicio Orientado a la Conexión Se dice que un servicio de comunicación entre dos entidades es orientado a conexión cuando antes de iniciar la comunicación se verifican determinados datos (disponibilidad, alcance, etc.) entre estas entidades y se negocian unas credenciales para hacer esta conexión más segura y eficiente. Este tipo de conexiones suponen mayor carga de trabajo a una red (y tal vez retardo) pero aportan la eficiencia y fiabilidad necesaria a las comunicaciones que la requieran. Servicio No Orientado a la Conexión En telecomunicaciones, no orientado a la conexión significa una comunicación entre dos puntos finales de una red en los que un mensaje puede ser enviado desde un punto final a otro sin acuerdo previo. El dispositivo en un extremo de la comunicación transmite los datos al otro, sin tener que asegurarse de que el receptor esté disponible y listo para recibir los datos. El emisor simplemente envía un mensaje dirigido al receptor. Cuando se utiliza esta forma de comunicación son más frecuentes los problemas de transmisión que con los protocolos orientado a la conexión y puede ser necesario reenviar varias veces los datos. Los protocolos no orientados a la conexión son a menudo rechazados por los administradores de redes que Página 1 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

2 utilizan cortafuegos porque los paquetes maliciosos son más difíciles filtrar. Elprotocolo IP y el protocolo UDP son protocolos no orientados a la conexión, pero TCP es un protocolo orientado a la conexión. Los protocolos no orientados a la conexión son descritos generalmente como sin estado porque los puntos finales no guardan información para recordar una "conversación" de cambios de mensajes. La alternativa al enfoque no orientado a la conexión es utilizar protocolos orientados a la conexión, que son descritos a veces como con estado porque pueden seguir una conversación. Simplex Sólo permiten la transmisión en un sentido. Un ejemplo típico es el caso de la fibra óptica; en estos casos se puede recurrir a sistemas en anillo o con doble fibra para conseguir una comunicación completa. Aunque en la actualidad ya existe la posibilidad de enviar y recibir señal a través de una sola fibra óptica pero en diferentes longitudes de onda.una conexión semidúplex (a veces denominada una conexión alternativa o semi-dúplex) es una conexión en la que los datos fluyen en una u otra dirección, pero no las dos al mismo tiempo. Con este tipo de conexión, cada extremo de la conexión transmite uno después del otro. Este tipo de conexión hace posible tener una comunicación bidireccional utilizando toda la capacidad de la línea. Half Duplex En ocasiones encontramos sistemas que pueden transmitir en los dos sentidos, pero no de forma simultánea. Puede darse el caso de una comunicación por equipos de radio, si los equipos no son full dúplex, uno no podría transmitir (hablar) si la otra persona está también transmitiendo (hablando) porque su equipo estaría recibiendo (escuchando) en ese momento.en radiodifusión, se da por hecho que todo duplex ha de poder ser bidireccional y simultáneo, pues de esta manera, se puede realizar un programa de radio desde dos estudios de lugares diferentes. Full Duplex La mayoría de los sistemas y redes de comunicaciones modernos funcionan en modo dúplex permitiendo canales de envío y recepción simultáneos. Podemos conseguir esa simultaneidad de varias formas: Empleo de frecuencias separadas (multiplexación en frecuencia) Cables separados Nota: Por definición no deben existir colisiones en Ethernet en el modo <full-duplex> aunque inusualmente existen. Página 2 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

3 Conceptos del Protocolo TCP EL SERVIDOR Para proporcionar servicio debe disponer de: Dirección IP del servidor. Servicio que queremos crear / utilizar: Estos números son enteros normales y van de 1 a Los número bajos, desde 1 a 1023 están reservados para servicios habituales de los sistemas operativos (www, ftp, mail, ping, etc). El resto están a disposición del programador Página 3 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

4 Pasos a realizar: Apertura de un socket, mediante la función socket(). Esta función devuelve un descriptor de fichero normal, como puede devolverlo open(). La función socket() no hace absolutamente nada, salvo devolvernos y preparar un descriptor de fichero que el sistema posteriormente asociará a una conexión en red. Avisar al sistema operativo de que hemos abierto un socket y queremos que asocie nuestro programa a dicho socket. Se consigue mediante la función bind(). El sistema todavía no atenderá a las conexiones de clientes, simplemente anota que cuando empiece a hacerlo, tendrá que avisarnos a nosotros. Es en esta llamada cuando se debe indicar el número de servicio al que se quiere atender. Avisar al sistema de que comience a atender dicha conexión de red. Se consigue mediante la función listen(). A partir de este momento el sistema operativo anotará la conexión de cualquier cliente para pasárnosla cuando se lo pidamos. Si llegan clientes más rápido de lo que somos capaces de atenderlos, el sistema operativo hace una "cola" con ellos y nos los irá pasando según vayamos pidiéndolo. Pedir y aceptar las conexiones de clientes al sistema operativo. Para ello hacemos una llamada a la función accept(). Esta función le indica al sistema operativo que nos dé al siguiente cliente de la cola. Si no hay clientes se quedará bloqueada hasta que algún cliente se conecte. Escribir y recibir datos del cliente, por medio de las funciones write() y read(), que son exactamente las mismas que usamos para escribir o leer de un fichero. Obviamente, tanto cliente como servidor deben saber qué datos esperan recibir, qué datos deben enviar y en qué formato. Puedes ver cómo se pueden poner de acuerdo en estos mensajes en el apartado de mensajes. Cierre de la comunicación y del socket, por medio de la función close(), que es la misma que sirve para cerrar un fichero. EL CLIENTE Los pasos que debe seguir un programa cliente son los siguientes: Apertura de un socket, como el servidor, por medio de la función socket() Solicitar conexión con el servidor por medio de la función connect(). Dicha función quedará bloqueada hasta que el servidor acepte nuestra conexión o bien si no hay servidor en el sitio indicado, saldrá dando un error. En esta llamada se debe facilitar la dirección IP del servidor y el número de servicio que se desea. Escribir y recibir datos del servidor por medio de las funciones write() y read(). Cerrar la comunicación por medio de close(). Página 4 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

5 Funciones TCP sockfd = socket ( int dominio, int tipo, int protocolo ); sockfd Es el descriptor de socket devuelto. Luego se utilizará para conectarse, recibir conexiones, enviar y recibir datos, etc. Retorna un descriptor de socket, que es tipo int. Si hubo algún error, socket() retorna -1 y la variable global errno se establece con un valor que indica el error que se produjo ( ver man 3 perror). dominio El dominio de comunicación nos dice donde se encuentran los procesos que se van a intercomunicar. Si los procesos están en el mismo sistema, el dominio de comunicación será AF_UNIX, si los procesos están en distintos sistemas y estos se hallan unidos mediante una red TCP/IP, el dominio de comunicación será AF_INET. Cabe aclarar que existen otros dominios de comunicación. Los sockets no se han diseñado solamente para TCP/IP. La idea original fue que se usase la misma interfaz también para distintas familias de protocolos. En esta introducción solo trataremos el dominio AF_INET. Algunos dominios: AF_INET ( unidos mediante una red TCP/IP). AF_UNIX (en el mismo sistema). Otros dominios. Para este tutor siempre será AF_INET. tipo Podrá ser SOCK_STREAM o SOCK_DGRAM o SOCK_RAW. protocolo 0 (cero, selecciona el protocolo más apropiado). Página 5 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

6 int bind(int sockfd, struct sockaddr *my_addr, int addrlen) El socket se crea sin nombre, debemos asignarle uno para poder recibir conexiones. bind () se utiliza para darle un nombre al socket, osea una dirección IP y número de puerto del host local por donde escuchará, al especificar una IP del host local le estamos diciendo por cual interfaz física escuchará (el sistema puede tener varias interfaces ethernet, ppp, etc). Es necesario llamar a bind() cuando se está programando un servidor. Cuando se está programando un cliente generalmente no se utiliza esta función, el kernel le asignará al socket la dirección IP y número de puerto disponible al llamar a ciertas funciones, por ejemplo cuando llamamos a connect() para conectarnos con un sistema remoto. En el servidor es necesario llamar a bind() debido a que el número de puerto debe ser conocido para que los clientes puedan conectarse. Por ejemplo si estamos programando un servidor de telnet debemos llamar a bind() para asignarle al socket el puerto 23. En la aplicación cliente se puede llamar a bind() y asignarle un número de puerto, pero no es necesario porque nadie va a tratar ni podra conectarse con él. sockfd: Es el descriptor de socket devuelto por la función socket(). my_addr: Es un puntero a una estuctura sockaddr que contiene la IP del host local y el número de puerto que se va a asignar al socket.(mas abajo se detalla). addrlen: Debe ser establecido al tamaño de la estuctura sockaddr. sizeof(struct sockaddr). Ejemplo : int sockfd; struct sockaddr_in servaddr; sockfd = socket (AF_INET, SOCK_STREAM, 0); if (sockfd <= 0){ printf ("Error\n"); exit(1); bzero(&servaddr, sizeof(struct sockaddr_in)); servaddr.sin_family = AF_INET; servaddr.sin_port htons(puerto); servaddr.sin_addr.s_addr =htonl(inaddr_any); if (bind (sockfd,(struct sockaddr *)&servaddr, sizeof(struct sockaddr_in))<0){ printf ("Error\n"); exit(1); Página 6 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

7 Estructuras necesarias para la función bind. struct sockaddr{ unsigned short sa_family; // AF_* char sa_data[14]; // Direccion de protocolo. ; Almacena la dirección de protocolo para muchos tipos de protocolos. sa_family puede ser AF_INET, AF_UNIX u otros dominios sa_data contiene la dirección IP y número de puerto asignado al socket. struct in_addr{ unsigned long int s_addr; // Dirección local a la que se asigna el socket struct sockaddr_in { short int sin_family; // AF_INET unsigned short sin_port; // Numero de puerto. struct in_addr sin_addr; // Dirección IP. unsigned char sin_zero[8]; // Relleno. ; Se creó la esctuctura sockaddr_in para el caso de internet, para poder referenciar los elementos de forma más fácil. sin_family sera AF_INET. No debe convertirse a network byte order porque es solo usado por el kernel y no es enviado por la red. sin_port (número de puerto) deberá estar en network byte order, osea habrá que usar htons(). sin_addr (dirección IP) deberá estar en network byte order, osea habrá que usar htons(). sin_zero se utiliza para rellenar la estructura a la longuitud de sockaddr, debe estar inicializada a cero con la función bzero(). Ver la página del manual Los punteros a la estructura sockaddr_in deben ser precedidos con un cast tipo * struct sockaddr antes de pasarlos como parámetros a funciones. int sockfd; struct sockaddr_in servaddr; sockfd = socket (AF_INET, SOCK_STREAM, 0); if (sockfd <= 0){ printf ("Error\n"); exit(1); bzero(&servaddr, sizeof(struct sockaddr_in)); servaddr.sin_family = AF_INET; servaddr.sin_port htons(puerto); servaddr.sin_addr.s_addr= =inet_addr( ); if (bind(sockfd, (struct sockaddr *)& servaddr, sizeof(struct sockaddr_in))<0){ printf ("Error\n"); exit(1); Página 7 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

8 Funciones utiles para programación con socket Ordenación de bytes Host byte order (little-endian): Byte menos significativo primero Network byte order (big-endian): Byte más significativo primero Todos los campos de socketaddr_in han de almacenarse en Network byte order Network Byte Order & Host Byte Order Cuando se estan enviando datos por algun tipo de red, estos deben de viajar en un orden tal, que puedan ser leidos, por lo regular se convierten al tipo Network Byte Order (Orden de Byte de Red), y cuando esos datos se procesan en un ordenador se deben de convertir a Host Byte Order (Orden de Byte de Red). Esto se puede hacer con funciones predefinidas de las API de Socket como son: htons() -> ``Nodo a variable corta de Red'' htonl() -> ``Nodo a variable larga de Red'' ntohs() -> ``Red a variable corta de Nodo'' ntohl() -> ``Red a variable larga de Nodo'' int inet_aton(const char *cp, struct in_addr *inp); Convierte la dirección de Internet cp desde la notación estándar de números y puntos a la representación binaria, y la guarda en la estructura a la que apunte inp. Devuelve no-cero si la dirección es válida, cero si no. struct sockaddr_in servaddr; inet_aton(" ", &servaddr.sin_addr); // almacena IP en servaddr in_addr_t inet_addr(const char *cp); La función inet_addr() convierte la dirección de Internet cp desde la notación de números y puntos a la de datos binarios en orden de bytes del ordenador local. Si la entrada no es válida, devuelve INADDR_NONE (usualmente -1). Ésta es una interfaz obsoleta a inet_aton, descrita anteriormente; es obsoleta porque -1 es una dirección válida ( ), e inet_aton porporciona una manera más clara para indicar que ha ocurrido un error. struct sockaddr_in servaddr; servaddr.sin_addr.s_addr = inet_addr(" "); Página 8 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

9 in_addr_t inet_network(const char *cp); La función inet_network() extrae el número de red en orden de bytes de red desde la dirección cp a la notación de números y puntos. Si la entrada es inválida, devuelve -1. char *inet_ntoa(struct in_addr in); La función inet_ntoa() convierte la dirección de Internet in dada en orden de bytes de red a una cadena de caracteres en la notación estándar de números y puntos. La cadena se devuelve en un búfer reservado estáticamente, que será sobreescrito en siguientes llamadas. // if added to the above inet_addr() code, this would print " ": char *s = inet_ntoa(destaddr.sin_addr); printf("dotted decimal address is %s\n", s); struct in_addr inet_makeaddr(int net, int host); La función inet_makeaddr() construye una dirección de Internet en orden de bytes de red combinando el número de red net con la dirección local host en la red net, ambas en orden de bytes de ordenador local. in_addr_t inet_lnaof(struct in_addr in); La función inet_lnaof() devuelve la parte del ordenador local de la dirección de Internet in. La dirección de ordenador local se devuelve en orden de bytes de ordenador local. in_addr_t inet_netof(struct in_addr in); La función inet_netof() devuelve la parte de número de red de la dirección de Internet in. El número de red se devuelve en orden de bytes de ordenador local. int listen ( int sockfd, int backlog) Se llama desde el servidor, habilita el socket para que pueda recibir conexiones. Solo se aplica a sockets tipo SOCK_STREAM. sockfd: Es el descriptor de socket devuelto por la función socket() que será utilizado para recibir conexiones. backlog: Es el número máximo de conexiones en la cola de entrada de conexiones. Las conexiones entrantes quedan en estado de espera en esta cola hasta que se aceptan. Página 9 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

10 int accept ( int sockfd, void *addr, int *addrlen) Se utiliza en el servidor, con un socket habilitado para recibir conexiones ( listen() ). Esta función retorna un nuevo descriptor de socket al recibir la conexión del cliente en el puerto configurado. La llamada a accept() no retornará hasta que se produce una conexión o es interrumpida por una señal. sockfd :Es el descriptor de socket habilitado para recibir conexiones. addr :Puntero a una estructura sockadd_in. Aquí se almacenará informacion de la conexión entrante. Se utiliza para determinar que host está llamando y desde qué número de puerto. addrlen :Debe ser establecido al tamaño de la estuctura sockaddr. struct sockaddr_in remote_addr; int addrlen; new_sockfd = accept ( sockfd, &remote_addr, &addrlen); close ( sockfd) Finalizan la conexión del descriptor de socket. Despues de utilizar close, el socket queda desabilitado para realizar lecturas o escrituras. read (int sockfd, void *buff, int len) Devuelve longitud de lo leído si lectura OK y -1 si no. sockfd: descriptor de socket. buff: direccionamiento al búfer de almacenamiento de la información. Len: tamaño del búfer. Para su medición funciones sizeof() y strlen(). Usada por clientes y servidores. write (int sockfd, void *buff, int len) Devuelve longitud de lo escrito si escritura OK y -1 si no. sockfd: descriptor de socket. buff: direccionamiento al búfer de lectura de la información. Len: tamaño del búfer. Para su medición funciones sizeof() y strlen(). Usada por clientes y servidores. int connect(int sockfd, const struct sockaddr *serv_addr, int addrlen); La función connect solicita poder conectar el socket especificado por sockfd a un socket remoto cuya direccíon y puerto se especifica en serv_addr. Los parámetros son: Página 10 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

11 sockfd: Descriptor del socket creado con anterioridad. serv_addr: Estructura de datos donde se especifica la dirección y puerto con el que deseamos establecer la conexión. addrlen: Longitud de la estructura de datos anterior. La función devuelve el valor -1 si error o 0 si su llamada tiene éxito. Ejemplo Servidor TCP if ((listenfd = socket(af_inet,sock_stream,0))<= 0) { printf ("ERROR \n"); exit(1); servaddr.sin_family= AF_INET; servaddr.sin_addr.s_addr= htonl (INADDR_ANY); servaddr.sin_port=htons (SERVER_PORT); bzero(&servaddr, sizeof (servaddr)); if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)<0){ printf("error \n"); exit (1); listen (listenfd, LISTENQ); //Preparado para aceptar la entrada de los posibles clientes. clilen=sizeof(cliaddr); connfd =accept(listenfd, (struct_sockaddr *) &cliaddr, &clilen); //Se acepta el cliente. read (connfd, datos, strlen(datos)); //Se entiende que es lo primero que se hace. write (connfd, respuesta, strlen(respuesta)); // Resuelve close (connfd); close (listenfd). Ejemplo Cliente TCP if ((listenfd = socket(af_inet,sock_stream,0))<= 0) { printf ("ERROR \n"); exit(1); servaddr.sin_family= AF_INET; servaddr.sin_addr.s_addr= inet_addr (SERVIDOR); servaddr.sin_port=htons (SERVER_PORT); bzero(&servaddr, sizeof (servaddr)); clilen=sizeof(servaddr); connfd =connect(listenfd, (struct_sockaddr *) &servaddr, clilen); //Se inicia la conexión. write (listenfd, peticion, strlen(peticion)); // Se realiza petición read (listenfd respuesta strlen(respuesta)); //Se entiende que se recibe respuesta close (listenfd). Página 11 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

12 Características UDP El Protocolo de datagramas de usuario (UDP) es un estándar TCP/IP que está definido en RFC 768, "User Datagram Protocol (UDP)". Algunos programas utilizan UDP en lugar de TCP para el transporte de datos rápido, compacto y no confiable entre hosts TCP/IP. UDP proporciona un servicio de datagramas sin conexión que ofrece entrega de mejor esfuerzo, lo que significa que UDP no garantiza la entrega ni comprueba la secuencia de los datagramas. Un host de origen que necesita comunicación confiable debe utilizar TCP o un programa que proporcione sus propios servicios de secuencia y confirmación. Los mensajes UDP están encapsulados y se envían en datagramas IP, como se muestra en la siguiente ilustración. UDP y TCP En general, las diferencias en cómo entregan los datos UDP y TCP son similares a las diferencias entre una llamada telefónica y una tarjeta postal. TCP funciona como una llamada telefónica, ya que comprueba que el destino está disponible y preparado para la comunicación. UDP funciona como una tarjeta postal: los mensajes son pequeños y la entrega es probable, pero no siempre está garantizada. Normalmente, utilizan UDP los programas que transmiten pequeñas cantidades de datos a la vez o que tienen requisitos de tiempo real. En estas situaciones, las capacidades de carga pequeña y multidifusión de UDP (por ejemplo, un datagrama, muchos destinatarios) resultan más apropiadas que TCP. UDP es notablemente diferente de los servicios y características que proporciona TCP. En la siguiente tabla se comparan las diferencias en el modo de administrar la comunicación TCP/IP según se utilice UDP o TCP para el transporte de datos. UDP TCP Servicio sin conexión; no se establece una sesión entre los hosts. UDP no garantiza ni confirma la entrega, y no secuencia los datos. Servicio orientado a la conexión; se establece una sesión entre los hosts. TCP garantiza la entrega mediante el uso de confirmaciones y la entrega secuenciada de datos. Los programas que utilizan UDP son Los programas que utilizan TCP proporcionan la responsables de proporcionar la confiabilidad seguridad del transporte de datos confiable. necesaria para el transporte de datos. UDP es rápido, tiene requisitos de carga TCP es más lento, tiene requisitos de carga mayores y pequeños y puede admitir la comunicación sólo admite la comunicación punto a punto. punto a punto y de un punto a varios puntos. UDP y TCP utilizan puertos para identificar las comunicaciones para cada programa TCP/IP. Página 12 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

13 Recomendaciones de uso UDP/TCP UDP se utiliza: Comunicaciones breves, que no necesiten grandes requisitos de fiabilididad. Ej: DNS Comunicaciones con requisitos de tiempo: Tiempo real Video, sonido. Comunicaciones que requieren comunicaciones simultaneas entre 1 servidor y varios clientes Comunicaciones en las que la fiabilidad esta garantizada, como redes locales LAN. TCDP se utiliza: En general, Internet. Entornos con condicionantes de riesgo Transferencia de ficheros, excepción: TFTP. Comunicaciones largar, sin requisitos de tiempo real. Pasos necesarios para realizar una conexión UDP EL SERVIDOR Abrir un socket con la función socket() Asociar el socket a un puerto con bind() Leer mensaje con recvfrom(). Responder mensaje con sendto() EL CLIENTE Abrir un socket con socket() Enviar mensaje al servidor con sendto() Leer respuesta con recvfrom() Página 13 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

14 Funciones UDP sockfd = socket ( int dominio, int tipo, int protocolo ); (Ver funciones TCP. Unica diferencia en tipo, que debemos indicar SOCK_DGRAM) int recvfrom ( int sockfd, void *buf, int len, unsigned int flags, struct sockaddr *from, int *fromlen ) sockfd : Descriptor socket por donde se recibirán los datos. buf : Puntero a un buffer donde se almacenarán los datos recibidos. len : Longitud del buffer buf. flags : Ver la página del manual de recv(). Normalmente 0 from : Puntero a una estructura sockaddr que contiene la dirección IP y número de puerto del host origen de los datos. fromlen : Debe ser inicializado al tamaño de struct sockaddr ( sizeof (struct sockaddr) ). Si no hay datos a recibir en el socket, la llamada a recvfrom() no retorna (bloquea) hasta que llegan datos, se puede establecer al socket como no bloqueante (ver: man 2 fcntl ) de manera que cuando no hay datos para recibir la función retorna -1 y establece la variable errno=ewouldblock. Más adelante se hablará de esto. recvfrom() retorna el numero de bytes recibidos, igual que recv(). int sendto(int sockfd, const void *msg, int len, unsigned int flags, const struct sockaddr *to, int tolen) sockfd : Descriptor socket por donde se enviarán los datos. msg : Puntero a los datos a ser enviados. len : Longitud de los datos en bytes. flags : Leer : man 2 sendto. Normalmente 0. to : Puntero a una estructura sockaddr que contiene la dirección IP y número de puerto destino. tolen : Debe ser inicializado al tamaño de struct sockaddr ( sizeof (struct sockaddr) ). sendto() retorna el número de bytes enviados, el cual puede ser menor que len, igual que en send(). Página 14 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

15 Ejemplo UDP Servidor ECO #define MAXLINE 256 #define SERVER_PORT 3000 main ( ) { int sockfd; struct sockaddr_in, server_addr, cli_addr; int n; socklen_t len; char mess[maxline]; servaddr.sin_family= AF_INET; servaddr.sin_addr.s_addr= htonl (INADDR_ANY); servaddr.sin_port=htons (SERVER_PORT); bzero(&servaddr, sizeof (servaddr)); if ((listenfd = socket(af_inet,sock_dgram,0))<= 0) { printf ("ERROR \n"; exit(1); if ((bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr))<0) { printf ("ERROR \n"; exit(1); ; for ( ; ; ) { clilen=sizeof(cliaddr); n = recvfrom(listenfd, mess, MAXLINE, 0, (struct sockaddr *) &cliaddr, &clilen); sendto (listenfd, mess, n, 0, (struct sockaddr *) &cliaddr, len); ; close (listenfd). Página 15 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

16 Ejemplo UDP Cliente ECO #define MAXLINE 256 #define SERVER_PORT 3000 main (int argc, char* argv ) { int sockfd; struct sockaddr_in server_addr; int n; char sendline[maxline], recvline[maxline +1]; servaddr.sin_family= AF_INET; inet_pton (AF_INET, argv[1], &serveraddr.sin_addr.s_addr); servaddr.sin_port=htons (SERVER_PORT); bzero(&servaddr, sizeof (servaddr)); if ((sockfd = socket(af_inet,sock_dgram,0))<= 0) { printf ("ERROR \n"; exit(1); ; while (fgets (sendline, MAXLINE,stdin)!= NULL) { sendto (sockfd, sendline, MAXLINE, 0, (struct_sockaddr *) &serverddr, sizeof(serveraddr)); n = recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL); recvline [n]= \0 ; //Terminar texto. fputs (stdout, recvline, n+1); // Presentacion ; close (listenfd) int inet_pton(int af, const char *src, void *dst); inet_pton - Crea una estructura de dirección de red Esta función convierte la cadena de caracteres src en una estructura de dirección de red de la familia af, y copia la estructura de dirección de red a dst. Servidor con multiples clientes En TCP, el proceso consiste en crear múltiples procesos servidores hijos, individuales para cada uno de los clientes. En general, este proceso es muy ineficiente. Se deben duplicar pilas, recursos, etc. En UDP, el proceso es considerablemente más sencillo, además es más natural. No se duplican recursos y es mas eficiente. Página 16 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

17 Pérdida de datagramas Los errores en los sockets UDP que se producn de forma asíncrona (no temporizadis) no son detectados, para ello disponemos de una forma de controlarlos mediente el uso de la función connect. El funcionamiento de connect en UDP es distinto al de TCP ya que no envía ningún paquete de conexión SYN, lo que realiza es una configuración interna (local) del sistema y vuelve al funcionamiento de la aplicación. int connect(int sockfd, const struct sockaddr *serv_addr, int addrlen); Connect configura localmente, dirección y puerto del servidor. Se genera una nueva familia de sockets, los socket UDP conectados No se puede especificar nunca más las direcciones destino y puerto destino. Se utiliza write() o send(). No se utiliza recvfrom. Se utiliza recv() o read() Página 17 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

18 Ejemplo 1: Conexión Cliente Servidor. Envio de Mensaje de Bienvenida indicando ip del servidor en el cliente. SERVIDOR /* Estos son los ficheros de cabecera usuales */ #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #define PORT 3550 /* El puerto que será abierto */ #define BACKLOG 2 /* El número de conexiones permitidas */ main() { int fd, fd2; /* los ficheros descriptores */ struct sockaddr_in server; /* para la información de la dirección del servidor */ struct sockaddr_in client; /* para la información de la dirección del cliente */ int sin_size; if ((fd=socket(af_inet, SOCK_STREAM, 0)) == -1 ) { printf("error en socket()\n"); exit(-1); server.sin_family = AF_INET; server.sin_port = htons(port); /*?Recuerdas a htons() de la sección "Conversiones"? =) */ server.sin_addr.s_addr = INADDR_ANY; /* INADDR_ANY coloca nuestra dirección IP automáticamente bzero(&(server.sin_zero),8); /* escribimos ceros en el reto de la estructura */ if(bind(fd,(struct sockaddr*)&server, sizeof(struct sockaddr))==-1) { printf("error en bind() \n"); exit(-1); if(listen(fd,backlog) == -1) { printf("error en listen()\n"); exit(-1); while(1) { sin_size=sizeof(struct sockaddr_in); if ((fd2 = accept(fd,(struct sockaddr *)&client, &sin_size))==-1) { printf("error en accept()\n"); exit(-1); printf("se obtuvo una conexión desde %s\n",inet_ntoa(client.sin_addr) ); /* mostrar la IP del cliente */ send(fd2,"bienvenido a mi servidor.\n",22,0); /* que envia el mensaje de bienvenida al cliente */ close(fd2); /* cierra fd2 */ Página 18 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

19 CLIENTE #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> /* netbd.h es necesitada por la estructura hostent ;-) */ #define PORT 3550 /* El Puerto Abierto del nodo remoto */ #define MAXDATASIZE 100 /* El número máximo de datos en bytes */ int main(int argc, char *argv[]) { int fd, numbytes; /* ficheros descriptores */ char buf[maxdatasize]; /* en donde es almacenará el texto recibido */ struct hostent *he; /* estructura que recibirá información sobre el nodo remoto */ struct sockaddr_in server; /* información sobre la dirección del servidor */ if (argc!=2) { /* esto es porque nuestro programa sólo necesitará Un argumento, (la IP) */ printf("uso: %s <Dirección IP>\n",argv[0]); exit(-1); if ((he=gethostbyname(argv[1]))==null){ /* llamada a gethostbyname() */ printf("gethostbyname() error\n"); exit(-1); if ((fd=socket(af_inet, SOCK_STREAM, 0))==-1){ /* llamada a socket() */ printf("socket() error\n"); exit(-1); server.sin_family = AF_INET; server.sin_port = htons(port); /* htons() es necesaria nuevamente ;-o */ server.sin_addr = *((struct in_addr *)he->h_addr); /*he->h_addr pasa la información de ``*he'' a "h_addr" bzero(&(server.sin_zero),8); if(connect(fd, (struct sockaddr *)&server, sizeof(struct sockaddr))==-1){ /* llamada a connect() */ printf("connect() error\n"); exit(-1); if ((numbytes=recv(fd,buf,maxdatasize,0)) == -1){ /* llamada a recv() */ printf("error en recv() \n"); exit(-1); buf[numbytes]='\0'; printf("mensaje del Servidor: %s\n",buf); /* muestra el mensaje de bienvenida del servidor =) */ close(fd); /* cerramos fd =) */ Página 19 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

20 Programa cliente - servidor mediante sockets en C que en la parte servidor me genera un numero aleatorio entre 1 y 100 y los clientes le van escribiendo numero y el server comprueba si es mayor, menor o han acertado... Cliente.c #include <sys/types.h> #include <sys/socket.h> #include <stdio.h> #include <netinet/in.h> #include <arpa/inet.h> #include <unistd.h> #include <stdlib.h> int main() { int sockfd; int len; struct sockaddr_in address; int result; char numero; char respuesta ='1'; //Inicializamos a 1 para que entre en el while while(respuesta!= '0') { printf("escribe un número entre 1 y 100: "); scanf("%s",&numero); sockfd = socket(af_inet, SOCK_STREAM, 0); address.sin_family = AF_INET; address.sin_addr.s_addr = inet_addr(" "); address.sin_port = htons(9734); len = sizeof(address); result = connect(sockfd, (struct sockaddr *)&address, len); if(result == -1) { perror("oops: client3"); exit(1); write(sockfd, &numero, 1); //printf("el cliente envia: %c\n",numero); read(sockfd, &respuesta, 1); //printf("el cliente recibe: %c\n",respuesta); if (respuesta == '1') { printf("el número es mayor que %c\n", numero); if (respuesta == '2') { printf("el número es menor que %c\n", numero); close(sockfd); printf("has acertado!!! %c era el número!!!\n", numero); exit(0); Página 20 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

21 Servidor.c #include <sys/types.h> #include <sys/socket.h> #include <stdio.h> #include <netinet/in.h> #include <arpa/inet.h> #include <unistd.h> #include <stdlib.h> #include <math.h> int main() { int server_sockfd, client_sockfd; int server_len, client_len; struct sockaddr_in server_address; struct sockaddr_in client_address; server_sockfd = socket(af_inet, SOCK_STREAM, 0); server_address.sin_family = AF_INET; server_address.sin_addr.s_addr = htonl(inaddr_any); server_address.sin_port = htons(9734); server_len = sizeof(server_address); bind(server_sockfd, (struct sockaddr *)&server_address, server_len); int aleatorio; aleatorio = (1+rand()%100); listen(server_sockfd, 5); //Punto A while(1) { char numero; char respuesta; printf("servidor esperando peticiones...\n"); client_len = sizeof(client_address); client_sockfd = accept(server_sockfd,(struct sockaddr *)&client_address, &client_len); read(client_sockfd, &numero, 1); //1 un numero de 1 cifra, 2 de 2 cifras int numeroacomp = atoi(&numero); if(aleatorio > numeroacomp) { respuesta = '1'; //Si retorna 1 es que el valor es menor al número del cliente else{ if(aleatorio < numeroacomp){ respuesta = '2'; //Si retorna 2 es que el valor es mayor al núm del cliente else{ respuesta = '0'; //Si retorna 0 es que el valor es el correcto. exit(0); write(client_sockfd, &respuesta, 1); close(client_sockfd); Página 21 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

22 #include <sys/socket.h> #include <sys/types.h> #include <stdio.h> #include <stdlib.h> #include <netinet/in.h> #include <arpa/inet.h> #include <netdb.h> #include <unistd.h> #include <sys/select.h> #define LISTENQ 5 // Tamaño de lista de clientes (4 también sería válido) #define MAXCLIENT 5 // Número máximo de clientes #define MSG_SIZE 1024 //Tamaño máximo del mensaje de texto #define SERVER_PORT 3000 int main (int argc, char **argv) { int i, maxi, maxfd, listenfd, connfd, sockfd, nready; int client[maxclient]; ssize_t n; fd_set rset, allset; char msg[msg_size]; socklen_t clilen; struct sockaddr_in cliaddr, servaddr; if ((listenfd = socket(af_inet,sock_stream,0))<= 0) { printf ("ERROR \n"; exit(1); servaddr.sin_family= AF_INET; servaddr.sin_addr.s_addr=htonl(inaddr_any); servaddr.sin_port=htons(server_port); bzero(&servaddr, sizeof (servaddr)); if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(struct sockaddr_in)<0) { printf("error \n"); exit (1); listen (listenfd, LISTENQ); //Preparado para aceptar la entrada de 5 clientes maxfd=listenfd; maxi=-1; for (i=0; i<max_client;i++) //Inicialización del array de clientes client[i]=-1; FD_ZERO(&allset); //Inicialización de los conjuntos de descriptores FD_ZERO(&rset); FD_SET(listenfd,&allset); for(;;){ rset=allset; nready=select (maxfd+1, &rset, NULL,NULL,NULL); //Bloqueo en espera de entradas if ( FD_ISSET(listenfd, &rset){ //CLIENTE NUEVO clilen=sizeof(cliaddr); connfd =accept(listenfd, (struct_sockaddr *) &cliaddr, &clilen); //Se acepta el cliente for (i=0; i<max_client; i++) //Actualización del array if (client[i]<0) { client[i]=connfd; break; FD_SET(connfd,&allset); //Actualización del conjunto de descriptores if (connfd > maxfd) //Actualización de variables maxfd=connfd; if (i>maxi) maxi=i; Página 22 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.:

23 if (--nready<=0) continue; //Previsión para más de una interrupción /* ESPACIO RESERVADO PARA EL PROCESADO DEL SERVIDOR*/ //Del bucle principal //Del main. Otras Estructuras de Interes struct hostent *gethostbyname(const char *name); struct hostent { char *h_name; /* official name of host */ char **h_aliases; /* alias list */ int h_addrtype; /* host address type */ int h_length; /* length of address */ char **h_addr_list; /* list of addresses */ struct hostent *hent; hent = gethostbyname(" Página 23 de 23 Tema 1 Fundamentos de Sockets TCP y UDP Telf.: