Programación C/S Básica

Transcripción

1 1 de 21 Programación C/S Básica Enrique Alba Torres Universidad de Málaga (UMA)

2 2 de 21 Los servicios Internet se ofertan como sistemas Cliente/Servidor Los protocolos de base suelen ser peer-to-peer (igual-a-igual) En cualquier caso se necesita una interfaz para programar BSD socket es una interfaz estándar orientada al paso de mensajes entre procesos para programar en red sobre TCP/IP Las primitivas (funciones en C) y tipos de datos (estructuras,...) de los sockets conforman un API para programar servicios en red Existen sockets para UNIX, Linux, Windows y otros SS.OO. Existen API s para sockets en C, C++, Java y otros lenguajes E J E M P L O #include <sys/socket.h>... main() { int sservice;... struct sockaddr_in sout;... sservice = socket( );... sout.sin_family = AF_INET;... sout.sin_port = 4000;... connect(sservice,sout, );... }

3 3 de 21 (I) Un servidor realiza un proceso repetitivo, normalmente sin final, que consiste en un bucle básico de atención a los clientes:... while(true) { esperar petición de un cliente; atender al cliente; }... La espera de peticiones puede hacerse: A. Sobre un protocolo o varios (servicio multiprotocolo) B. Para proporcionar un servicio o varios (multiservicio) La atención al cliente puede hacerla: A. Directamente el servidor (iterativo) B. Un servidor esclavo generado (concurrente) Según el nivel de transporte usado el servicio puede ser: A. Orientado a la conexión (si el servidor utiliza TCP) B. Sin conexión (si el servidor utiliza UDP)

4 4 de 21 Iterativo Concurrente Or. Conexión Sin Conexión Multiprotocolo Multiservicio Ventajas simple de programar atención al cliente indep. del servicio información fluye correcta y ordenada comunicación eficiente y ligera servicio independ. de implementación versatilidad y potencia (II) Inconvenientes la cola de clientes pendientes puede crecer gestión de procesos hijos esclavos (fork+signal) puede ser costoso para algunos servicios posible pérdidas, desorden y + complejo difícil de lograr para algunos servicios difícil de programar y mantener

5 5 de 21 Tema 6. Esquemas de Implementación C/S usando SERVIDORES ITERATIVOS Servidor SIN CONEXIÓN Socket en un puerto bien-conocido usado para toda la comunicación ORIENTADO A LA CONEXIÓN Servidor Proceso de aplicación del servidor Socket para peticiones de conexión Socket para una conexión individual Sistema operativo.

6 6 de 21 Esquemas de Implementación C/S usando SERVIDORES CONCURRENTE (CON/SIN CONEXIÓN) Maestro Esclavo1 Socket para peticiones de conexión... Esclavo n.. para conexiones individuales Procesos de aplicación del servidor Sistema Operativo VARIOS PROCESOS MONOPROCESO Servidor... Proceso de aplicación de un servidor Socket para peticiones de conexión para conexiones individuales Sistema Op.

7 7 de 21 : Básicas de Comunicación Primitiva Función socket bind Crea un TSAP del servicio especificado (TCP o UDP, p.e.) Registra en el sistema el servicio asociado a un socket listen accept connect Shutdown close sendto write recvfrom read select Crea una cola para almacenar CR que lleguen (pasivo) Saca una CR de la cola del socket o espera a que llegue una Inicia una conexión con un socket remoto (local remoto) Cierran la conexión de un socket (ambos extremos pueden usarlo independientemente) Envían un mensaje por un descriptor de socket dado normalmente de forma no bloqueante Reciben un mensaje por un descriptor de socket dado normalmente de forma bloqueante Informa sobre los sockets listos para escribir o leer de ellos

8 8 de 21 : Obtención de Información Primitiva Función gethostbyname gethostbyaddr Obtiene información de una máquina remota a partir de su nombre Obtiene información de una máquina remota a partir de su dirección IP getservbyport getservbyname getaddrinfo Obtiene información de un servicio a partir del puerto Obtiene información de un servicio a partir del nombre Combina en una sola primitiva la funcionalidad de todas las anteriores primitivas getprotobyname Obtiene información de un protocolo a partir de su nombre getprotobynumber Obtiene información de un protocolo a partir de su número

9 9 de 21 Familias de Direcciones (I) Cada familia representa un dominio con sockets de similares características La familia determina el formato y los protocolos disponibles Las direcciones determinan el host y la aplicación de manera inequívoca La estructura genérica de una dirección es: struct sockaddr { u_short sa_family; /* Familia: ctes. de la forma AF_xxx */ char sa_data[14]; /* 14 bytes dependientes de la familia */ }; Algunos de los donimios disponibles son: AF_INET: protocolos de Internet AF_UNIX: sockets locales que corresponden a ficheros AF_CCITT: protocolos CCITT como X.25 AF_SNA: protocolos de redes IBM SNA AF_DECnet: protocolos de redes DEC La estructura para Internet-TCP/IP (AF_INET) es como sigue: struct sockaddr_in { short sin_family; /* Valor AF_INET*/ u_short sin_port; /* 16 bits con el número del puerto */ u_long sin_addr; /* 32 bits (red+ host)*/ char sin _zero[8]; /* 8 bytes no usados */ };

10 10 de 21 Familias de Direcciones (II) sockaddr sa_family sa_data sockaddr_in AF_INET sin_port sin_addr sin_zero

11 11 de 21 Tema 6. Valores Nativos y Tratamiento de direcciones de IP Fisicamente los datos se pueden representar con dos formatos: A. Little-Endian Low Byte High Byte B. Big-Endian Addr Addr + 1 High Byte Low Byte Addr Addr + 1 Posibles problemas al comunicar arquitecturas diferentes. Se diferencias dos representaciones lógicas: A. Host Byte Order: Orden físico de la máquina origen/destino. B. Network Byte Order: Orden de transmisión de los datos. Funciones de conversión de formato: - Host Byte Order a Network Byte Order: htons (short) y htonl (long) - Network Byte Order a Host Byte Order: ntohs (short) y ntohl (long) Funciones de conversión de direcciones IP: - De Ascii a Network: inet_addr y inet_aton - De Network a Ascii: inet_ntoa

12 12 de 21 Tipos de Cada tipo de socket tiene ciertas propiedades para realizar las transmisiones Los tipos más utilizados son: SOCK_STREAM Orientado a la conexión (TCP si AF_INET) SOCK_DGRAM SOCK_RAW Servicio sin conexión (UDP si AF_INET) Acceso a bajo nivel (IP si AF_INET) sólo puede usarlos el root!

13 13 de 21 Tema 6. Implementación de un C/S sobre TCP CLIENTE socket (crea socket) SERVIDOR socket (crea socket) connect (con. servidor) write (pide servicio) read (rec. respuesta) close (cierra conex.) bind (qué puerto usa) listen (encolar petic.) accept (espera conex.) read (rec. petición) write (sirve petición) close (cierra conex.)

14 14 de 21 Implementación del Cliente sobre TCP (I) /****************************************************************\ * (client.c) Client for reading input messages from keybd. * \****************************************************************/ #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #include <stdio.h> #include <string.h> #define TRUE 1 #define FALSE 0 Incluimos el API Pedimos información sobre TCP main() { int sservice, end; char buf[128]; struct protoent *ppe; struct sockaddr_in sout; ppe = getprotobyname("tcp");/*get the tcp-entity data*/ /*Open the socket*/ sservice=socket(pf_inet,sock_stream,ppe->p_proto); Abrimos un TSAP

15 15 de 21 Implementación del Cliente sobre TCP (II) sout.sin_family = AF_INET; /*ARPANET */ sout.sin_addr.s_addr = getservbyport(4000,"tcp"); /* Which server?*/ sout.sin_port = 4000; /*Output port*/ /*Connect to the server*/ connect(sservice,(struct sockaddr *)&sout, sizeof(sout)); end = FALSE; while(!end) /*Client Service Loop*/ { /*Ask for the service*/ printf("\nclient> Send a message...: "); fflush(stdout); scanf("%s",buf); write(sservice,buf,strlen(buf)); printf("\nclient>client sent: %s", buf); fflush(stdout); if (!strcmp(buf,"end")) { printf("\nclient>bye..."); end=true; } } close(sservice); } /*main()*/ Dirección del Servidor Conectar con servidor Msj. para servidor Cerrar TSAP fflush(stdout);

16 16 de 21 Implementación del Servidor sobre TCP (I) /****************************************************************\ *(server.c) The Server shows received messages in the screen. * \****************************************************************/ #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <netdb.h> #include <stdio.h> #include <string.h> #define TRUE 1 #define FALSE 0 main() { int sservice, sclient, l, nbytes_read, end; char buf[128]; struct protoent *ppe; struct sockaddr_in sin, clientfsin; ppe = getprotobyname("tcp"); Incluimos el API /*Open the socket*/ sservice=socket(pf_inet,sock_stream,ppe->p_proto); /*pse = getservbyname("messages", "tcp"); <---If service is reg.*/ Abrimos un TSAP Pedimos información sobre TCP

17 17 de 21 sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY; sin.sin_port = 4000; sclient=bind(sservice, (struct sockaddr*)&sin, sizeof(sin)); /*Register serv*/ listen(sservice,5);/*up to 5 pending connections*/ sclient=accept(sservice,(struct sockaddr*) &clientfsin,&l);/*accept a client*/ /*If concurrent, a children server should be spawned here by using fork()*/ end = FALSE; while(!end) /*Give the service*/ { Implementación del Servidor sobre TCP (II) nbytes_read=read(sclient,buf,sizeof(buf)); if (nbytes_read>=0) buf[nbytes_read]='\0'; else {strcpy(buf,"\nserver>error IN SERVER!"); end=true; } printf("\nserver>server received: %s", buf);fflush(stdout); if(!strcmp(buf,"end")) end=true; } printf("\nserver>bye..."); fflush(stdout); close(sclient); /*Never forget to close a socket!*/ close(sservice); } /*main()*/ Dirección IP+TCP Registrar, conf., aceptar Leer petición Normalmente nunca cerrar sservice!

18 18 de 21 Implementación de un C/S sobre UDP CLIENTE socket (crea socket) SERVIDOR socket (crea socket) bind/connect (reg/conectar) sendto/write (pide servicio) recvfrom/read (leer respuesta) bind (registrar) recvfrom (lee petición) sendto (envía resp.) close (cierra conex.)

19 19 de 21 Programación avanzada: Opciones de sockets Obtención y manipulación de opciones de sockets : setsockopt(socket, level, optname, optval, optlen); getsockopt(socket, level, optname, optval, optlen); Principales opciones de socket (level = SOL_SOCKET): SO_DEBUG: modo depuración SO_REUSEADDR: reutilización de dirección. SO_SNDBUF: tamaño del buffer de envío SO_RCVBUF: tamaño del buffer de recepción TCP_NODELAY: no retrasar los envíos Mas propiedades de sockets (operaciones sobre ficheros): fnctl(socket, cmd, ) e ioctl(socket, cmd, ) E J E M P L O int sfd, yes = 1;... sfd = socket(af_inet, SOCK_STREAM, 0);... setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));... fnctl(sfd, F_SETFL, O_NONBLOCK);

20 20 de 21 Programación avanzada: Multiplexación de E/S select(maxfds. rfd, wfd, efd, timeour); Operaciones sobre conjunto de descriptores: FD_ZERO: Vacía el conjunto FD_SET: Añade un descriptor al conjunto FD_CLR: Elimina un descriptor al conjunto FD_ISSET: Comprueba si está activo un descriptor E J E M P L O fd_set rd, act_rd;... FD_ZERO(&rd); FD_SET(s1,&rd);FD_SET(s2,&rd);... while(1){... bcopy(&rd, &act_rd);... select(dsize, &act_rd, NULL, NULL, NULL);... if(fd_isset(s1, &act_rd))... else if(fd_isset(s2, &act_rd))...

21 21 de 21 Internetworking with TCP/IP (Vol. 1) Comer, D.E. Prentice-Hall Internetworking with TCP/IP (Vol 3) Comer D.E., Stevens, D.L. Prentice-Hall Unix Network Programming Stevens, W.R. Prentice-Hall Computer Networks and Internets (2 nd edition) Comer, D.G. Prentice-Hall A Guide to the TCP/IP Protocol Suite Wilder, F. Artech House