Gestión y Comunicación de procesos

Transcripción

1 1 Resumen Gestión y Comunicación de procesos Material de apoyo para la asignatura de Taller de Sistemas Operativos 1 Preparado por Gabriel Astudillo Muñoz Escuela de Ingeniería Civil Informática Universidad de Valparaíso Este documento tiene como objetivo ser un material de apoyo para la asignaturas de Sistemas Operativos, Taller de Sistemas Operativos y Redes de Computadores. Se describen algunas funciones del API de C relacionadas con gestión de procesos y comunicación entre procesos. Todas las funciones son relativas al kernel 3.0 de Linux. Las herramienta de compilación son: gcc 4.7.3, GNU Make Todos los códigos están disponibles en una máquina virtual 2 que contiene todas las herramientas para implentar los códigos. 2 Generalidades para programar en Unix 2.1 Conceptos básicos Al ejecutar un programa, éste se transforma en un proceso, que, en general, disponde de ciertos descriptores para recibir y enviar información desde y hacia otros procesos, tal como se muestra en la Figura 1. Estos descriptores básicos se listan en la Tabla 1. Para un uso adecuado de estos descriptores, es preferible utilizar las macros o el descriptor de los flujos determinado a través de la función fileno(). Descriptor Nombre descriptivo Macro definida en Relación con los (int) unistd.h flujos 0 Standard Input STDIN_FILENO fileno(stdin) 1 Standard Output STDOUT_FILENO fileno(stdout) 2 Standard Error STDERR_FILENO fileno(stderr) Tabla 1 stdin Descriptor Flujo (FILE*) 0 stdout 1 Figura Estructura básica de un programa para el Taller de Sistemas Operativos La estructura (esqueleto) de un programa en C será la siguiente: #include <stdio.h> //otras bibliotecas stderr int main(int argc, char *argv[]){ //Su codigo return(exit_success); En el Taller, se privilegiará el uso de macros. Para esto, se utilizará, en primera instancia, algunas definidas en la biblioteca stdlib.h 3. Macro Descripción EXIT_SUCCESS Terminación exitosa del proceso. 0 EXIT_FAILURE Terminación errónea del proceso. NULL Puntero a nulo. Tabla Última versión: Disponible en

2 2.3 Estructura básica del entorno de desarrollo El desarrollo de programas en el Taller se realizará en base a un editor de texto simple, un archivo de texto para el código fuente y para el archivo Makefile. El esquema de archivos se muestra en la Figura 2. Directorio de trabajo ejemplo.c Makefile #include <stdio.h> int main(int argc, char *argv[]){ printf( Hola Mundo!\n ); return(exit_success); # # Seccion 1 # # Esta seccion se puede modificar segun # los requerimientos de su proyecto CC=gcc OBJ=ejemplo.o BIN=ejemplo # # Seccion 2 (NO MODIFICAR!!!) # default: $(BIN) $(BIN): $(OBJ) $(CC) $^ -o $(BIN) %.o: %.c $(CC) -c -o $@ $< clean: rm -f $(OBJ) rm -f *~ rm -f $(BIN) 2.4 Estructura del Makefile Figura 2 La estructura del makefile a utilizar será similar a la que se muestra en la Figura 3. Usted sólo debería modificar la sección 1 de dicho archivo. # # Seccion 1 # # Esta seccion se puede modificar segun # los requerimientos de su proyecto CC=gcc OBJ=ejemplo.o BIN=ejemplo # # Seccion 2 (NO MODIFICAR!!!) # default: $(BIN) $(BIN): $(OBJ) $(CC) $^ -o $(BIN) Compilador a utilizar (por omisión, gcc) Códigos objeto de su proyecto Nombre del ejecutable de su proyecto %.o: %.c $(CC) -c -o $@ $< clean: rm -f $(OBJ) rm -f *~ rm -f $(BIN) Figura 3 Para mayor información acerca de Makefile, visita la página oficial de GNU Make Manejo de errores Cada operación que puede resultar errónea, debe ser manejada correctamente y ser enviada al standard error, no al standard output. Por ejemplo, se se quiere abrir el archivo conexiones.txt, el siguiente código está incompleto, ya que puede ocurrir un error al abrir el archivo solicitado y no le envía un aviso al usuario

3 #include <stdio.h> int main(int argc, char *argv[]){ FILE *archivo; archivo = fopen( conexiones.txt, r ); // Seccion que procesa el archivo return(exit_success); El código que se muesta a continuación, a pesar que le envía un aviso al usuario, está erróneo ya que el mensaje lo imprime en el standard output, a través de la función printf(). Además, no se sabe que es lo que realmente pasó (puedo no existir, no tener los permisos suficientes, etc)... if( (archivo = fopen("conexiones.txt", "r")) == NULL ){ printf("error al abrir el archivo.");... El código de más abajo, es mucho mejor que el anterior, ya que ahora si envía el mensaje expresamente al standard error. Pero no hay mayor información sobre qué error pudo suceder.... if( (archivo = fopen("conexiones.txt", "r")) == NULL ){ fprintf(stderr, "Error al abrir el archivo\n");... Para que el programa envié un mensaje de error apropiado, se debe utilizar la función perror(), disponible en stdio.h. Esta función envía el mensaje al estándar output. #include <stdio.h> int main(int argc, char *argv[]){ FILE *archivo; if( (archivo = fopen("conexiones.txt", "r")) == NULL ){ perror("error al abrir el archivo"); // Seccion que procesa el archivo return(exit_success); Si el archivo no existe, la salida del programa es (el ejecutable se llama ejemplo_error): #./ejemplo_error Error al abrir el archivo: No such file or directory # Si el archivo existe, pero no se tienen los permisos suficientes: #./ejemplo_error Error al abrir el archivo: Permission denied # 3

4 3 s en Unix 3.1 Jerarquía de procesos En la Figura 4 se visualiza un proceso inicial, denominado init, que, mediante una llamada al sistema determinada, puede generar uno o varios procesos. Cada proceso creado puede crear más subprocesos. Despues de un tiempo, se puede obtener una Jerarquía de s similar a la mostrada (Silberschatz, Galvin, & Gagne, 2003). init pid=1 pid=2 pid=3 pid=20 sshd udevd login ssh root@notty sftp server subsystem udevd --deamon /bin/bash pid=50 pid=52 pid=60 pid=100 joe tarea1.c pid=101 gcc tarea1.c pid=102 Figura API de s en C Creación de s Para crear procesos en sistemas operativos UNIX se debe utilizar la llamada al sistema de la función fork(). El proceso que realiza esta llamada es denomido padre y el nuevo proceso creado, hijo. pid_t fork(); Las consecuencias del proceso de creación son: La llamada fork() retorna valores distinto para el proceso padre y para el proceso hijo. El proceso hijo es una copia exacta del proceso padre. Ambos procesos siguen ejecutándose independientemente. pid = fork() SÍ pid<0 Error en el fork() Hijo Código proceso hijo SÍ pid==0 Padre Código proceso padre Figura 5 Al momento que se invoca la llamada fork(), el Kernel debe realizar las siguientes tareas: Reserva un espacio en la tabla de procesos para el nuevo proceso. Asigna un PID único al nuevo proceso. Realiza una copia del contexto del proceso padre. Copia los descriptores de archivos del proceso padre al hijo. La función fork() retorna: El PID del hijo en el proceso padre y 0 en el proceso hijo, si la llamada es exitosa. -1, en caso de error, 4

5 Ejemplo de uso: int main(int argc, char *argv[]) { pid_t pid; pid = fork(); if( pid < 0){ perror( Error en fork() ); else if( pid == 0 ) { //Código del hijo else if(pid>0){ //Padre //Código del padre Funciones asociadas a la creación de procesos getpid() La función getpid() retorna el identificador (PID) del proceso llamador. getppid() pid_t getpid(); La función getppid() retorna el identificador (PID) del proceso padre. pid_t getppid(); Término de un proceso Existen dos formas para que un proceso termine. Estas formas son: a) Normal Retorno de la función main(). Llamar a la función exit(int status). Efectúa una limpieza (llama funciones de término previamente registradas con atexit()) y retorna al kernel. El parámetro status puede tomar los valores EXIT_SUCCESS o EXIT_FAILURE (0 ó 1). Llamar a la función _exit(int). Retorna al kernel inmediatamente. void exit( int status); void _exit(init status); int atexit(void (*func) (void));// retorna 0 si es OK, //distinto de 0 en otro caso. b) Anormal Llamar a abort() : esta función genera la señal SIGABRT, por lo tanto es un caso particular de terminar por una señal. Término por una señal. Esto se tratará en la sección 4. 5

6 Ejemplo uso atexit() #include <stdio.h> void limpiar(); int main(){ if(atexit(limpiar)!= 0) { perror("error en atexit:"); printf("ultima instruccion...\n"); exit(exit_success); void limpiar(void){ printf("aca va el codigo final final\n"); Funciones de sincronización Algunas veces se necesita que el proceso padre, quede esperando la finalización de sus procesos hijos, debido, por ejemplo, a que los procesos hijos entregarán cierta información que después el proceso padre utilizará en el resto del programa. Las funciones que se utilizan para este fin son wait() y waitpid(). La Figura 6 muestra esta situación. wait() La función wait() forzará a un proceso padre para que espere a un proceso hijo que se detenga o termine. La función regresa el PID del hijo o -1 en caso de error. El estado de la salida hijo es regresado en la variable &statloc. waitpid() #include <sys/wait.h> pid_t wait (int *statloc); La función waitpid() es similar a wait(), salvo que explícitamente espera por un determinado proceso, especificado por pid. #include <sys/wait.h> pid_t waitpid( pid_t pid, int *statloc, int options); El valor del argumento pid puede ser: < -1 : Espera a que cualquier proceso hijo cuyo ID grupal es igual al valor absoluto de pid. = -1 : Espera por cualquier proceso hijo. Este es el mismo comportamiento que tiene wait. = 0 : Espera por cualquier proceso hijo cuyo ID grupal es igual al del proceso padre. > 0 : Espera por el proceso hijo cuyo ID es igual al valor de pid (por un proceso determinado). El valor del argumento options puede ser: WNOHANG: retorno inmediatamente si ningún hijo a terminado. WUNTRACED: también retorna si un hijo se a detenido. Alcance: la función wait(&status) es equivalente a waitpid(-1, &status, 0). 6

7 pid = fork() SÍ pid<0 Padre Hijo Error en el fork() Código del hijo Hijo SÍ pid==0 wait() Padre fork() wait() Resto del programa exit() exit() Resto del programa Figura Familia de funciones EXEC La familia de funciones exec*() se utlizan para ejecutar otro programa. En particular, se pueden usar para que un proceso hijo pueda ejecutar un programa específico, tal como se muestra en la Figura 7. Existen seis variantes de la función exec. En que el momento que cualquiera de ellas sea llamada, el proceso completo es reemplazado por un nuevo programa. El nuevo programa parte en su función main() y NO cambia el PID del proceso hijo. int execl( const char *path, const char *arg,...); int execlp( const char *file, const char *arg,...); int execle( const char * path, const char *arg,..., char * const envp[]); int execv( const char * path, char *const argv[]); int execvp( const char *file, char *const argv[]); int execve(const char *filename, char *const argv [], char *const envp[]) El primer argumento es el archivo ejecutable que se quiere llamar. Las funciones que contienen puntos suspensivos en su prototipo, los parámetros del ejecutable se incluyen ahí, en argumentos separados. Las funciones terminadas en "e" (execle() y execve()) reciben un último argumento que es un puntero a las variables de entorno. pid = fork() SÍ pid<0 Padre Hijo Sistema Operativo Error en el fork() Hijo exec( programa ) SÍ pid==0 wait() Padre fork() wait() Resto del programa exec("comando") exit() programa exit() Resto del programa Figura 7 Ejemplo: Se requiere que un proceso ejecute el comando /bin/ls la /. Esto se puede realizar como se indica en la Figura 8. 7

8 execl("/bin/ls", "ls", "-la", "/", 0); Comando a ejecutar Argumentos Nombre lógico Figura 8 Indica fin de los argumentos Función system Permite ejecutar un programa externo, desligado completamente del proceso que lo ejecuta. Esta función es internamente implementada llamando a las funciones fork(), exec(), y waitpid(). En la Figura 9 se muestra un esquema que permite ver la diferencia con la función exec(). int system(const char * prgstring); Sistema Operativo system( programa ) Resto del programa Resto del programa system( programa ) programa Figura 9 8

9 3.3 Programas de ejemplo a) Programa que crea dos procesos. El proceso hijo duerme por 5 segundos, imprime su PID, el de su padre y termina. El padre, imprime los PID de él, su hijo y su padre. Luego, termina. Compile el programa y vea el resultado. Trate de explicar lo que sucede. #include <stdio.h> int main(int argc, char *argv[]) { pid_t pid; if( (pid=fork()) == 0 ) { //Hijo sleep(5); printf("soy el Hijo: PID=%d\n", getpid()); printf("\tmi padre es: PID=%d\n", getppid()); exit(exit_success); else if(pid>0){ //Padre printf("soy el Padre: PID=%d\n", getpid()); printf("mi hijo es %d\n", pid); printf("mi padre es %d\n", getppid()); return(exit_success); b) Modificación del programa anterior. Explique lo se sucede al colocar la función waitpid(). Prueba también con wait(). Vea lo que pasa cuando la función waitpid() se coloca justo antes de return(exit_success). Explique lo que sucede. #include <stdio.h> int main(int argc, char *argv[]) { pid_t pid; int status; if( (pid=fork()) == 0 ) { //Hijo sleep(5); printf("soy el Hijo: PID=%d\n", getpid()); printf("\tmi padre es: PID=%d\n", getppid()); exit(exit_success); else if(pid>0){ //Padre waitpid(pid, &status, 0); printf("soy el Padre: PID=%d\n", getpid()); printf("mi hijo es %d\n", pid); printf("mi padre es %d\n", getppid()); return(exit_success); 9

10 c) Programa que ejecuta comandos ingresados por el usuario, a través del intérprete bash. #include <stdio.h> #include <string.h> #include <sys/wait.h> #define AVISO "Escriba un comando, ^d para terminar" #define PROMPT "$ " int main(){ char comando[100]; int pid, status; puts(aviso); printf(prompt); while( fgets(comando,100,stdin) ){ comando[strlen(comando)-1]=0; if( (pid=fork()) < 0 ){ puts("error en fork()."); else if( pid == 0 ) { execl( /bin/bash, bash, -c, comando, 0); exit(exit_success); else{ waitpid(pid,&status, 0); printf("pid= %d\n", pid); puts(aviso); printf(prompt); //fin if del fork // fin while return(exit_success); d) Realice un programa utilizando la función execl() para listar los procesos activos en el momento de ejecución. #include <sys/wait.h> #include <stdio.h> #include <errno.h> int main(){ printf ("Lista de procesos\n"); if(execl ("/bin/ps", "ps", "-aux", 0) < 0){ fprintf(stderr, "Error en exec %d\n", errno); puts("fin de la lista de procesos\n"); exit(exit_success); 10

11 4 Señales Las señales permiten generar interrupciones asincrónicos entre distintos procesos. En el proceso que recibe la señal, se genera una interrupción de software, que es atendida por una función que previamente se relacionó con la señal, tal como se muestar en la Figura 10. Curso normal de ejecución función de atención de Interrupción Señal entrante El proceso sigue dónde quedó Figura 10 Hay diversos tipos de señales y cada una de ellas tiene un identificador entero, que se encuentra definido la biblioteca signal.h 5. Existen diversas formas de generar señales. Entre las más comunes se encuentran: Eventos del teclado (^c, ^z, etc) 6. Excepciones aritméticas. Por ejemplo, división por cero. Referencias de memoria inválida. Mediante la función kill() o el comando kill. Condiciones de software. Por ejemplo, por una señal de alarma que expire, error entre la comunicación de procesos. Al momento en que un proceso recibe una señal, éste tiene tres formas distinta de tratarlas. Ignorar la señal, con lo cual no se produce efecto alguno. Existen señal que no se pueden ignorar. Invocando a una función que es aportada por el Kernel y normalmente tiene como fin terminar el proceso. Invocando a una rutina que se encarga de tratar la señal, generalmente creada por el programador. Esta rutina establece un mecanismo de comunicación entre procesos o modificar el curso normal del proceso. 4.1 Señales en Unix A continuación, se presentan la descripción de algunas señales. Cada nombre está asociado a un número entero. Señal Descripción Acción por omisión SIGINT Es enviada cuando en medio de un proceso se Termina la ejecución pulsa las teclas de interrupción (^c). del proceso que SIGQUIT Similar a SIGINT, pero es generada al pulsa la tecla de salida (^\). SIGKILL Esta señal provoca irremediablemente la terminación del proceso. No puede ser ignorada. SIGBUS Es enviada a un proceso cuando intenta acceder a datos que se encuentran fuera de su segmento de datos (Segmentation Fault). recibe la señal. Generar un archivo core y terminar el proceso. Terminar el proceso Terminar el proceso 5 Por lo general, esta biblioteca se encuentra en /usr/include. Específicamente, las definiciones de las macros de los nombres de las señales se encuentran en /usr/include/bits/signum.h. 6 La notación ^(tecla) es equivalente a la CTRL+TECLA 11

12 SIGPIPE SIGALRM SIGTERM SIGUSR1, SIGUSR2 SIGCLD Intento de escritura en una pipeline de la que no hay nadie leyendo. Evita que se pierdan datos. Cada proceso tiene asignados un conjunto de temporizadores. Si se ha activado alguno de ellos y este llega a cero, se envía esta señal al proceso Es la señal utilizada para indicarle a un proceso que debe terminar su ejecución. Esta señal no es tajante como SIGKILL y puede ser ignorada. Esta señal está reservada para el usuario. Su interpretación dependerá del código desarrollado por el programador. Es enviada al proceso padre cuando alguno de sus procesos hijos termina. Tabla 3 Terminar el proceso Terminar el proceso. 4.2 Envío de señales La función kill() envía una señal a un proceso. Análogamente, raise() envía señales al mismo proceso. #include <signal.h> int kill (pid_t pid, int signo); int raise(int signo); 4.3 Tratamiento de señales Para permitir que una señal (o su interrupción) sea correctamente tratada, hay que relacionar la interrupción generada por la señal con una función determinada. Esto se realiza a través de signal(). #include <signal.h> typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t handler); Esta función retorna retorna el valor previo del manejador de la señal o SIG_ERR en caso de error Ejemplo 1 Se quiere implementar un proceso que tenga un ciclo infinito y que cada 1 segundo imprima en pantalla Nada todavia. Cuando el usuario genere una señal SIGINT a través de la secuencia ^c, el programa deberá avisar que el proceso se va a acabar. #include <stdio.h> #include <signal.h> void func_sigint(int senal){ //Funcion que maneja la interrupcion // SIGINT (CTRL+c) printf("se termino el proceso\n"); printf("numero de senal: %d", senal); exit(exit_success); int main(int argc, char *argv[]){ signal(sigint, func_sigint); while(1){ puts("nada todavia"); sleep(1); return(exit_success); 12

13 4.3.2 Ejemplo 2 Programa que cuando reciba las siguientes señales, responda de la siguiente manera: o o o o Al recibir una señal SIGUSR1 muestre el mensaje "He recibido la señal SIGUSR1". Al recibir una señal SIGUSR2 muestre el mensaje "He recibido la señal SIGUSR2". Al recibir una señal SIGTERM muestre el mensaje "Fin de Ejecución" y termine su ejecución de forma exitosa. Al recibir una señal SIGINT, la ignore. #include <stdio.h> #include <signal.h> void manejador(int signum){ switch (signum){ case SIGUSR1: printf("he recibido la senal SIGUSR1\n"); break; case SIGUSR2: printf("he recibido la senal SIGUSR2\n"); break; case SIGTERM: printf("fin de Ejecucion\n"); exit(exit_success); int main(int argc, char *argv[]) { if (signal(sigusr1, manejador) == SIG_ERR) { perror("error en la senal SIGUSR1"); if (signal(sigusr2, manejador) == SIG_ERR) { perror("error en la senal SIGUSR2"); if (signal(sigterm, manejador) == SIG_ERR) { perror("error en SIGTERM"); if (signal(sigint, SIG_IGN) == SIG_ERR) { perror("error en SIGINT"); 4.4 Otras funciones while (1){ puts( Programa ejemplo senales\n ); pause(); alarm(): La función alarm() permite especificar un timer que expira en un tiempo determinado. Cuando expira, se genera una señal SIGALRM hacia el proceso que configuró el temporizador. unsigned int alarm(unsigned int seconds) Si seconds es 0, la alarma se desactiva y retorna la cantidad de segundos que faltan para cumplirse el plazo. 13

14 pause(): La función pause() suspende un proceso llamador hasta que llegue una señal. int pause(void); /* retorna -1 con errno en EINTR */ sleep(): La función sleep() duerme al proceso llamador por la cantidad de segundos indicada o hasta que reciba una señal que está implementada. Retorna 0 ó el tiempo que le falta por dormir, respectivamente Ejemplo 3 unsiged int sleep (unsigned int seconds); unsiged int usleep(unsigned int microseconds); #include <time.h> int nanosleep(const struct timespec *req, struct timespec *rem); Implementar un programa que acepte la entrada de una cadena de caracteres antes que se cumpla cierto tiempo. Cuando el tiempo se cumpla, el sistema debe avisar al usuario que el tiempo expiró y terminar. #include <signal.h> #include <stdio.h> #include <errno.h> static void sig_alrm(int); #define MAXLINE 200 #define TIMEOUT 5 int main(void) { int n; char line[maxline]; if (signal(sigalrm, sig_alrm) == SIG_ERR) perror("signal(sigalrm) error"); printf("ingrese un string antes de 5 segundos: "); fflush(stdout); alarm(timeout); //Configure el timer por TIMEOUT segundos. //terminado ese tiempo, se genera una //interrupcion del tipo SIGALRM if ( (n = read(stdin_fileno, line, MAXLINE)) < 0) if (errno!=eintr) perror("read error"); alarm(0); //Desactivar timer printf("lo que ingreso es: "); fflush(stdout); write(stdout_fileno, line, n); exit(exit_success); static void sig_alrm(int signo){ printf("\npaso la alarma!!!\n"); exit(exit_success); 14

15 5 Comunicación entre procesos mediante PIPES Los pipes o tuberías son un método de comunicación unidireccional entre procesos. Gráficamente, se dibuja como se indica en la Figura 11. Una pipe es simplemente un método de conexión que une la salida de un proceso a la entrada de otro. Para realizar la conexión de los procesos involucrados se utilizan descriptores de archivos, que son estructuras de datos que contienen y manejan la información de estado de archivos. Por ejemplo, se tiene un archivo de texto, denomindo conexiones.txt, que contiene las conexiones hacia un servicio determinado, tal como se muestra en la Tabla ;connected ;offline ;connected ;offline Tabla 4 Figura 11 Debido a un requerimiento externo, se desea mostrar en pantalla (standard Output) sólo las líneas que contengan la palabra connected. Esto se realiza con el siguiente comando: #cat conexiones.txt grep connected ;connected ;connected # El símbolo es la representación de una pipe en la línea de comandos de Unix. En este ejemplo, la salida estándar del proceso cat conexiones.txt es ingresada como entrada estándar al proceso grep. Esta situación se muestra en la Figura 12. READ stdin stdout stderr cat Flujo de Datos WRITE stdin stdout stderr grep Figura 12 Existen dos formas de programas pipes: con la función popen() y pipe(). 5.1 Creación de PIPES simples La función popen() crea una pipe para leer desde un comando o escribir a otro comando. Por otro lado, pclose()la cierra. El modo de uso es: #include <stdio.h> FILE *popen (const char *command, const char *type); int pclose(file * stream); El argumento command es el comando a ejecutar y type puede ser r (lectura) o w (escritura). Este función crea un nuevo proceso y ejecuta el comando. Luego crea una pipe desde la entrada o salida estándar de este proceso dependiendo de cómo se abrió. Esta situación se ilustra en la Figura

16 Transparente para el programador popen() se utiliza la pipe Resto del programa Hijo exec("comando") exit() Sistema Operativo comando Figura 13 Nótese que popen() retorna un puntero del tipo FILE*, por lo que, para leer y escribir hacia y desde una pipe, se utilizan las mismas funciones de lectura y escritura para un archivo Ejemplo Mostrar en pantalla la fecha y hora actual, con la función popen(). #include <stdio.h> #include <string.h> #include <sys/wait.h> int main(){ FILE *pf; char line[1024]; if( (pf = popen("date", "r")) == NULL ){ perror("error en popen()"); if (fgets(line, sizeof(line), pf) == NULL) { fprintf(stderr, "No hay salida del comando ejecutado\n"); printf("salida:%s\n", line); return(exit_success); 5.2 Creación de PIPES avanzadas Una pipe puede ser creada con la función pipe(): int pipe (int name[2]); Se crean dos descriptores de archivo, uno para lectura (name[0]) y otro para escritura (name[1]). Lo que se escribe por name[1] se puede leer por name[0]. Gráficamente, se tiene lo que se muestra en la Figura

17 stdin name[0] READ stdout name stderr name[1] WRITE Figura 14 Condiciones especiales: Si el extremo escritor cierra la pipa, el lector puede continuar hasta que los datos terminan y luego recibe EOF (end-of-file). Si el extremo lector cierra la pipe, un intento por escribir en la pipe genera la señal SIGPIPE. Ahora bien, el poder real de esta función, es permitir la comunicación entre un proceso padre y sus procesos hijos, debido a que la función fork() copia todos los descriptores de archivos (y una pipe es un tipo de descriptor), tal como se muestra en la Figura 15. pipe(int name[2]) fork(); stdin name[0] READ stdin name[0] READ name[0] stdin stdout name stdout Padre name Hijo stdout stderr name[1] WRITE stderr name[1] WRITE name[1] stderr Figura 15 Luego, una comunicación entre ambos procesos se logrará cuando ambos procesos cierren adecuadamente sus descriptores. 5.3 Duplicación de descriptores Un problema que nace en este tipo de comunicación es cómo copiar los datos de los descriptores básicos de un proceso (stdin, stdout y stderr). Por ejemplo, si el proceso hijo genera un resultado por su stdout, éste podría ser utilizado por el proceso padre. Para esto, el stdout debería copiarse (duplicarse) al descriptor name[1] de la pipe. Para la duplicación de descriptores, exiten las funciones dup() y dup2(), cuya sintaxis es: int dup (int file_descrip); int dup2(int file_descrip_source, int file_descrip_dest); dup() retorna un nuevo descriptor de archivo que referencia el mismo que file_descrip. dup2() causa que el descriptor de archivo file_descrip_dest se refiera al mismo contenido que file_descrip_source. El problema que se mencionó, se soluciona utilizando la función dup2() Ejemplo Se tiene un archivo de texto, denomindo conexiones.txt, que contiene las conexiones hacia un servicio determinado, tal como se muestra en la Tabla 4. Se quiere hacer un programa que muestre en 17

18 pantalla el contenido de dicho archivo, a través de la creación de un proceso y comunicación entre el hijo y el padre. El proceso hijo revisa el archivo y envía el contenido al padre. En el diseño de la solución, se debe visualizar la situación de la Figura 16, que representa el instante en que se realiza el fork() y la lógica de funcionamiento del padre y del proceso hijo. stdout stderr stdin fd[0] Padre imprime en pantalla el contenido del archivo fd[1] READ fd WRITE fd[0] Hijo cat conexiones.txt fd[1] stdin stdout stderr Figura 16 Claramente, no hay una comunicación entre ambos procesos, ya que el proceso hijo envía el contenido a su stdoout (pantalla) y éste no está conectado con nada. Bajo este diseño, el esqueleto de la solución sería: int main(){ //inicializaciones varias pid = fork(); if( pid == 0 ){ execl("/bin/cat", "cat", "conexiones.txt", 0); exit(exit_success); else if( pid > 0 ) { while (read(fd[0], line, 10) > 0) write(stdout_fileno, line, 10); //fin if del fork return(exit_success); Para lograr la comunicación, se debe programar el sistema que se muestra en la Figura 17. Para lograr que el stdout se copie en fd[1], se debe utilizar la función dup2(). stdout stderr stdin fd[0] Padre imprime en pantalla el contenido del archivo fd[1] READ fd WRITE fd[0] Hijo cat conexiones.txt fd[1] stdin stdout stderr Figura 17 Además, para forzar un funcionamiento sincrónico, es necesario que el sistema funcione como se indica en la Figura 18. Esto se logra con la función waitpid(). 18

19 Hijo Sistema Operativo fork() Resto del programa exit() exec( cat ) comando Figura 18 La segunda versión del código se muestra a continuación, resaltando las líneas que se agregaron. int main(){ //inicializaciones varias pid = fork(); if( pid == 0 ){ dup2(fd[1], STDOUT_FILENO); close(fd[0]); execl("/bin/cat", "cat", "conexiones.txt", 0); exit(exit_success); else if( pid > 0 ) { close(fd[1]); waitpid(pid, &status, 0); while (read(fd[0], line, 10) > 0) write(stdout_fileno, line, 10); //fin if del fork return(exit_success); A pesar de que este código funciona, al ejecutarlo se envían datos con ruido al padre: #./ejemplo ;connected ;offline ;connected ;offline [??`u? # La manera de leer los datos a través de una pipe, es crear un flujo de datos (parecido a un archivo) con la función fdopen()y fclose():... FILE* input;... int main() {... input = fdopen(fd[0],"r"); while( fgets(line, 100, input) ){ printf("%s", line); fclose(input);... Finalmente, el código final es: 19

20 #include <stdio.h> #include <string.h> #include <sys/wait.h> int main(){ int pid, status; char line[100]; int fd[2]; FILE* input; pipe(fd); pid = fork(); if( pid == 0 ){ dup2(fd[1], STDOUT_FILENO); close(fd[0]); execl("/bin/cat", "cat", "conexiones.txt", 0); exit(exit_success); else if( pid > 0 ) { close(fd[1]); waitpid(pid, &status, 0); input = fdopen(fd[0],"r"); while( fgets(line, 100, input) ){ printf("%s", line); fclose(input); //fin if del fork return(exit_success); 20

21 6 Comunicación entre procesos mediante FIFOS FIFO (First In First Out) se conoce también como una pipe con nombre. Es un archivo especial, donde múltiples procesos pueden abrir, leer y escribir sobre él. Es muy similar a un pipe, pero la comunicación no está confinada a procesos relacionados (padre-hijo). Para crear un FIFO, se debe utlizar la función mkfifo(), cuya sintaxis es: #include <sys/stat.h> int mkfifo (const char *path, mode_t mode);, donde path es el nombre de la FIFO a ser creada en el sistema de archivo, la cual no debe existir previamente. El parámetro mode corresponde a los permisos a nivel de sistema operativo 7. Normalmente, basta con que tengan permisos de lectura y escritura para el usuario, por lo que mode=600. Esta función retorna 0 si la operación fue exitosa, -1 en caso contrario. Al crear un FIFO, éste se bloquea por omisión. En otras palabras, si se crea un FIFO para escritura, se bloqueará hasta que cualquier otro proceso lo abra para escritura, y viceversa. Para desactivar la opción de bloqueo se puede usar la bandera O_NONBLOCK en la llamada open() Ejemplo 1 Se requiere implementar el sistema de la Figura 19. El proceso servidor espera datos que provienen de un canal de datos implementado a través de un FIFO de nombre CANAL y los imprime en pantalla. Luego, el proceso termina. El FIFO debe ser creado y eliminado por este proceso. La información enviada al canal de datos es el contenido de un archivo. Usuario envía contenido de un archivo Canal de datos Servidor Imprime contenido en pantalla Figura 19 Primero se debe crear una estructura de la solución y luego plantear el código fuente. Estructura de la solución La estructura de la solución podría ser la que se muestra en la Figura 20: Consola del sistema recibefd stdin # cat conexiones.txt > CANAL CANAL (fifo) Servidor Imprime datos del CANAL (fifo) en pantalla stdout stderr Figura 20 El ámbito del proceso servidor es el sistema bajo el rectángulo. Para implementarlo, debe cumplir con los siguientes requerimientos:

22 Código fuente 1. Crear FIFO con nombre CANAL. 2. Abrir FIFO en modo lectura, a través de un descriptor denominado recibefd. 3. Leer desde el FIFO hasta un EOF e imprimir dichos datos en patalla. 4. Cerra descriptor del FIFO. 5. Eliminar FIFO. El código fuente que implementa la estructura menciona es: #include <string.h> #include <sys/wait.h> #include <fcntl.h> #define FIFONAME "CANAL" int main(){ int n, recibefd; char buf[1024]; unlink(fifoname); if (mkfifo(fifoname, 0666) < 0) { perror("mkfifo"); if ((recibefd = open(fifoname, O_RDONLY)) < 0) { perror("open"); //Leer desde el FIFO hasta el EOF e imprimir //los datos en el stdout while ((n = read(recibefd, buf, sizeof(buf))) > 0) write(stdout_fileno, buf, n); close(recibefd); unlink(fifoname); return(exit_success); Ejemplo 2 Se tiene un archivo de texto, denomindo conexiones.txt, que contiene las conexiones hacia un servicio determinado, tal como se muestra en la Tabla 4. Se quiere hacer un sistema que muestre en pantalla el contenido de dicho archivo, a través de dos procesos comunicados por un canal de datos implementado con un FIFO. El proceso cliente revisa el archivo y envía el contenido al proceso servidor. Cliente Envia contenido Canal de datos Servidor Imprime contenido en pantalla Figura 21 En el diseño de la solución, se debe visualizar la situación de la Figura

23 stdin recibefd stdin stdout Cliente Envia contenido FIFO Servidor Imprime contenido en pantalla stdout stderr enviafd stderr Figura 22 cliente.c #define FIFONAME "CANAL" int main(){ int enviafd; if( (enviafd = open(fifoname, O_WRONLY,0)) < 0) { perror("open"); dup2(enviafd, STDOUT_FILENO); execl("/bin/cat", "cat", "conexiones.txt", 0); close(enviafd); servidor.c return(exit_success); #define FIFONAME "CANAL" int main(){ int n, fd; char buf[1024]; unlink(fifoname); if (mkfifo(fifoname, 0666) < 0) { perror("mkfifo"); if ((fd = open(fifoname, O_RDONLY)) < 0) { perror("open"); //Leer desde el FIFO hasta el EOF e imprimir //los datos en el stdout while ((n = read(fd, buf, sizeof(buf))) > 0) write(stdout_fileno, buf, n); close(fd); unlink(fifoname); return(exit_success); 23

24 Las bibliotecas utilizadas por los programas en esta sección son: #include <string.h> #include <sys/wait.h> #include <fcntl.h> 24

25 7 Comunicación entre procesos mediante Sockets 7.1 Conceptos generales de Redes de Computadores 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 23. 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 23. 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. La Figura 24 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 Servicio DNS trabaja en el puerto UDP/53 25

26 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 Capas TCP/IP Figura 24. Descripción del funcionamiento de los protocolos TCP/IP La Figura 25 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 de usuario de usuario de usuario de usuario Transporte TCP UDP Red ICMP IP IGMP ARP Interfaz de Hardware RARP Enlace de Datos Medio Físico Figura 25 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 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 26 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). 26

27 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 Demultiplexación Figura 26 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 27). 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 9 (Internet Corporation for Assigned Names and Numbers). Algunos puertos son 10 : 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. 9 ICANN: 10 Estos servicios se encuentran en el arhcivo /etc/services, en sistemas operativos Unix. 27

28 7.1.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 28 muestra el modelo de comunicación mencionado. Request Cliente Red de Datos Response Servidor Figura 28. 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 29 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 29. 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 & Calvert, 2001). 28

29 7.1.8 Sockets Un socket es una abstracción del sistema operativo mediante el cual una aplicación puede enviar y recibir datos (Donahoo & 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 30 muestra la relación lógica que existe entre las aplicación, sockets, protocolos y números de puertos en un host determinado. de usuario de usuario de usuario Socket TCP Socket TCP Socket TCP Socket UDP Socket UDP Socket UDP Puertos TCP Puertos UDP TCP UDP IP Orden de almacenamiento de los Bytes Figura 30 La forma en la que se almacenan los bytes en memoria varía de un sistema a otro (Donahoo & 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); 29

30 7.2 API de C para comunicación en red 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. #include <sys/socket.h> 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); Cierra de un socket Para cerrar el canal de comunicación, se utiliza la función shutdown(), cuyo prototipo es el siguiente: Parámetros: #include <sys/socket.h> 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. 30

31 7.2.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 31 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 31 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 Funciones del lado del cliente Conexión al servidor #include <sys/socket.h> 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. 31

32 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 7.2.6) 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: #include <sys/socket.h> 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 11. 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. #include <sys/socket.h> 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 #include <sys/socket.h> 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. 11 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. 32

33 int clntsock; //Socket del cliente struct sockaddr_in echoclntaddr; //Direccion cliente clntlen = sizeof(echoclntaddr) clntsock = accept(servsock, (struct sockaddr *) &echoclntaddr, &clntlen); Funciones de transferencia de datos #include <sys/socket.h> 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); Transformación entre nombre y dirección de máquina #include <netdb.h> extern int h_errno; struct hostent * gethostbyname(const char *name); #include <sys/socket.h> 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. 33

34 7.2.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 <sys/socket.h> #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); 34

35 7.3 Cliente Servidor TCP Iterativo En la Figura 28, se muestra un esquema Cliente-Servidor genérico. En la Figura 32 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 32 La implementación real de estos programas se muestra en la sección Cliente Servidor UDP Iterativo En la Figura 33, 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 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 33 35

36 7.5 Cliente Servidor Concurrente En la Figura 34 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 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() Padre 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 Ejemplos Programa que obtiene la IP de un servidor cualquiera. #include <stdio.h> #include <netdb.h> #include <sys/socket.h> #include <netinet/in.h> int main(int argc, char *argv[]){ struct hostent *servidor; if (argc!=2) { printf("uso: %s <hostname>\n",argv[0]); if ((servidor=gethostbyname(argv[1]))==null) { 36

37 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); 37

38 7.6.2 Cliente Servidor TCP Cliente #include <stdio.h> #include <string.h> #include <netdb.h> #include <sys/socket.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()"); 38

39 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 <string.h> #include <netdb.h> #include <sys/socket.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()"); 39

40 //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; 0){ 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)) < perror("error recv()"); close(clntsocket); 40

41 7.6.3 Cliente Servidor UDP Cliente #include <stdio.h> #include <string.h> #include <netdb.h> #include <sys/socket.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: "); 41

42 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 <string.h> #include <netdb.h> #include <sys/socket.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; 42

43 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); 43

44 7.6.4 Servidor TCP Concurrente #include <stdio.h> #include <string.h> #include <netdb.h> #include <sys/socket.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){ 44

45 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--; 45

46 Bibliografía Stallings, W. (2004). Comunicaciones y Redes de Computadores. Person Educación. Stevens, W. R. (1993). TCP/IP Illustrated Volume 1: The Protocols (Vol. 1). Addison Wesley. Donahoo, M. J., & Calvert, K. L. (2001). TCP/IP Sockets in C: Practical Guide for Programmers. Morgan Kaufmann. Silberschatz, A., Galvin, P. B., & Gagne, G. (2003). Operating System Concepts. (J. W. Sons, Ed.) 46