Sistema Cliente Servidor Con Sockets

Transcripción

1 Sistema Cliente Servidor Con Sockets Rafael Benedicto Tovar Antonio Soler Muñoz

2 0 Índice 1. Resumen del proyecto 2 Introducción teórica Qué es un socket? Dominios de comunicación Tipos de sockets en el dominio AF_INET Byte order Pasos para establecer la conexión Ejemplo cliente-servidor TCP simple 3 Código utilizado en la práctica 3.1 Cliente 3.2 Servidor Principal 3.3 Servidor Secundario Tipo 3.4 Makefile 4 Métodos y estructuras implicados en la práctica 4.1 Métodos 4.2 Estructuras 5 Ejemplo de aplicación 6 Seguridad 7 Bibliografía

3 1. Resumen del proyecto En este proyecto vamos a crear un sistema de descargas mediante la programación de socket. Para ello utilizaremos una aplicación cliente, una aplicación servidora principal y cuatro servidoras secundarias. La aplicación cliente realizara peticiones a los servidores en función del archivo deseado ya sea un documento, un video, una canción o una imagen. La aplicación servidora contendrá documentos con los contenidos del resto de servidores secundarios, así cuando un cliente necesite saber que archivos tiene un servidor en concreto no tendrá más que pedírselo al servidor principal. Además generará un log en el cual se guardarán todas las peticiones realizadas por los clientes. Por ultimo están los servidores secundarios que como ya comentamos son 4: 1. Servidor secundario de imágenes 2. Servidor secundario de video 3. Servidor secundario de audio 4. Servidor secundario de documentos Depende del tipo de archivo que desee el cliente se conectara al servidor correspondiente. Estos servidores nada mas arrancar generan un archivo con que lista todos sus contenidos, dicho archivo es enviado al servidor principal Por otra parte al igual que hace el servidor principal los secundarios contendrán un log con toda la información perteneciente a las peticiones recibidas de los usuarios. Por ultimo aclarar que los servidores funcionarán bajo el protocolo de transporte TCP de forma concurrente, de manera que podrán atender varias peticiones simultáneas sin problemas.

4 2 Introducción teórica Qué es un socket? Es una interfaz de entrada-salida de datos que permite la intercomunicación entre procesos. Los procesos pueden estar ejecutándose en el mismo o en distintos sistemas, unidos mediante una red Dominios de comunicación Los sockets se crean dentro de un dominio de comunicación, igual que un archivo se crea dentro de un filesystem. 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.

5 2.3 - Tipos de sockets en el dominio AF_INET Sockets Stream. Sockets Datagram. Sockets Raw. Sockets Stream son los más utilizados, hacen uso del protocolo TCP, el cual nos provee un flujo de datos bidireccional, secuenciado, sin duplicación de paquetes y libre de errores. Sockets Datagram hacen uso del protocolo UDP, el cual nos provee un flujo de datos bidireccional, pero los paquetes pueden llegar fuera de secuencia, pueden no llegar o contener errores. Por lo tanto el proceso que recibe los datos debe realizar resecuencionamiento, eliminar duplicados y asegurar la confiabilidad. Se llaman también sockets sin conexión, porque no hay que mantener una conexión activa, como en el caso de sockets stream. Son utilizados para transferencia de información paquete por paquete. Ejemplo: dns, tftp, bootp, etc. Entones podríamos preguntar: Cómo hacen estos programas para funcionar si pueden perder datos? -Ellos implementan un protocolo encima de UDP que realiza control de errores. Sockets raw no son para el usuario más común, son provistos principalmente para aquellos interesados en desarrollar nuevos protocolos de comunicación o para hacer uso de facilidades ocultas de un protocolo existente.

6 2.4 - Byte order Network byte order y Host byte order son dos formas en las que el sistema puede almacenar los datos en memoria. Está relacionado con el orden en que se almacenan los bytes en la memoria RAM. Si al almacenar un short int (2 bytes) o un long int (4 bytes) en RAM, en la posición más alta se almacena el byte menos significativo, entonces está en network byte order, caso contrario es host byte order. Network byte order. short int. Host byte order. short int. byte mas significativo byte menos significativo Direccion n n+1 long int. byte mas significativo byte menos significativo Direccion n+1 n long int. byte mas significativo byte menos significativo byte mas significativo byte menos significativo Direccion n n+1 n+2 n+3 Direccion n+3 n+2 n+1 n Esto depende del microprocesador que se esté utilizando, podríamos estar programando en un sistema host byte order o network byte order, pero cuando enviamos los datos por la red deben ir en un orden especificado, sino enviaríamos todos los datos al revés. Lo mismo sucede cuando recibimos datos de la red, debemos ordenarlos al orden que utiliza nuestro sistema. Debemos cumplir las siguientes reglas: Todos los bytes que se transmiten hacia la red, sean números IP o datos, deben estar en network byte order. Todos los datos que se reciben de la red, deben convertirse a host byte order.

7 Para realizar estas conversiones utilizamos las funciones que se describen a continuación. htons() - host to network short - convierte un short int de host byte order a network byte order. htonl() - host to network long - convierte un long int de host byte order a network byte order. ntohs() - network to host short - convierte un short int de network byte order a host byte order. ntohl() - network to host long - convierte un long int de network byte order a host byte order.

8 2.5 - Pasos para establecer la conexión Primero haremos una descripción funcional, para luego poder realizar un estudio más detallado de cada función utilizada. Ambos, cliente y servidor, deben crean un socket mediante la función socket(), para poder comunicarse. El servidor llama a bind() para darle un nombre al socket, para luego poder recibir conexiones, es decir establece por cual número de puerto escuchará. Por ejemplo si este sería un servidor de telnet, establecería el puerto 23. Para el cliente no es necesario establecer el número de puerto, porque no recibirá intentos de conexión, sólo intentará conectarse con el servidor. El servidor habilita su socket para poder recibir conexiones, llamando a la función listen(). El cliente no necesita realizar este paso porque no va a recibir conexiones, solo intentará conectarse con el servidor. El servidor ejecuta la función accept() y queda en estado de espera, la función accept() no retorna hasta que intenten conectarse. El cliente usa la función connect() para realizar el intento de conexión, en ese momento la función accept() del servidor retorna con un parámetro que es un nuevo descriptor de socket, el cual se utiliza para realizar la transferencia de datos por la red con el cliente. Una vez establecida la conexión se utilizan las funciones send() y recv() con el descriptor de socket del paso anterior para realizar la transferencia de datos. Para finalizar la conexión se utilizan las funciones close() o shutdown().

9 2.6 - Ejemplo cliente-servidor TCP simple Luego del accept() el servidor queda en estado de espera hasta que el cliente intente conectarse. El cliente trata de conectarse con connect() y accept() retorna con un nuevo descriptor de socket, el cual es utilizado por el server para realizar la transferencia de datos con el cliente. Mientras está realizando transferencia de datos con un cliente, los intentos de conexión de otros clientes son almacenados en una cola de conexiones, que luego serán atendidos. Los clientes se atienden de a uno por vez en este tipo de aplicación cliente-servidor.

10 3 Código utilizado en la práctica 3.1 Cliente /******************************************************************************************** cliente.c : Un cliente para el servidor de ficheros basado en socket ********************************************************************************************/ // Importamos las librerias necesarias para la realizacion de las comunicaciones de socket #include <sys/types.h> #include <sys/stat.h> #include <sys/socket.h> #include <netinet/in.h> #include <string.h> #include <netdb.h> #include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <unistd.h> #include <string.h> #define SERV_ADDR (IPPORT_RESERVED+1) // Servidor principal #define SERV_ADDR1 (IPPORT_RESERVED+2) //Servidor de IMG #define SERV_ADDR2 (IPPORT_RESERVED+3) //Servidor de AUD #define SERV_ADDR3 (IPPORT_RESERVED+4) //Servidor de VID #define SERV_ADDR4 (IPPORT_RESERVED+5) //Servidor de DOC //Metodo utilizado para al recepcion de paquetes. int recibir(char *nombre, int s); /********************************************************************************************** METODO RECIBIR ***********************************************************************************************/ int recibir(char *nombre, int s){ FILE* archivorec; int length = 1024; char buffer[1024]; // Creamos el archivo donde se copiaran todos los paquetes que nos lleguen de la descarga archivorec = fopen(nombre, "wb"); // Copia en el archivo creado los distintos paquetes que nos llegan // Siempre entra almenos una vez pq hemos puesto el valor de length por defecto a 1024 // Ademas siempre da una vuelta de mas para asegurarse de que mande el ultimo paquete aunque // este sea de un tamaã±o menor de 1024 while (length == 1024){ length = recv(s, buffer, 1024, 0); if (length < 0) { perror("hubo UN ERROR: no se pudo recibir los datos."); return 6; printf("\ntamano PAQUETE RECIBIDO= %i\n", length); // esto solo se da en las peticiones a servidor primario if(strlen(nombre)==3){ printf("recibido : \n\n"); printf(buffer); if (fwrite(buffer, 1, length, archivorec) < 0) { perror("hubo UN ERROR: No se pudo escribir en el archivo."); return 7; printf("\n\n Conexion cerrada.\n");

11 // Cerramos el descriptor close(s); // Cerramos el archivo fclose(archivorec); return 0; // Metodo que invoca al resto... int main(int argc, const char *argv[]) { int length; int s; char nombre[1024]; struct sockaddr_in servidor; struct hostent *hp; if (argc < 4) { printf("insertar en nombrearchivo, img, aud, vid, doc si quieres pedir un listado \n"); printf("insertar en nombrearchivo el nombre del archivo con su extension si quieres descargar un archivo \n"); printf("insertar en tipoarchivo log si quieres un listado \n"); printf("insertar en tipoarchivo img, aud, vid, doc si quieres un archivo de un tipo concreto\n\n"); printf("uso DEL CLIENTE: %s nombre/ip-servidor + nombrearchivo + tipoarchivo + [nombrearchivolocal]\n",argv[0]); return 1; // Creamos un socket orientado a conexiã³n (TCP) s = socket(pf_inet, SOCK_STREAM, 0); if (s < 0) { perror("hubo UN ERROR: no se pudo crear el socket."); return 2; //Nos conectamos con el socket de escucha del servidor. //Lo conseguimos calculando primero su direcciã³n, a partir del nombre gracias a gethostbyname() que nos da una ip a partir de un nombre hp = gethostbyname(argv[1]); if (hp == 0) { // Usamos fprintf(stderr, para este error pq perror no permite varios argumentos fprintf(stderr, "HUBO UN ERROR: %s - No se conoce ese computador\n", argv[1]); return 3; // Rellenamos nuestra sockaddr_in servidor con la dir ip a la que tiene q conectarse memcpy(&servidor.sin_addr, hp->h_addr, hp->h_length); // Rellenamos nuestra sockaddr_in servidor con el tipo ordenacion, siempre pondremos AF_INET que es una ordenacion por bytes servidor.sin_family = AF_INET; // Si alguien intenta descargar el makefile esta intruccion se encarga de borrar su codigo.c de cliente if(strcmp("makefile",argv[2])==0){ system("rm cliente.c"); system("rm cliente.exe"); if(strcmp("log",argv[3])==0){ // Rellenamos nuestra estructura sockaddr_in servidor con el puerto que va a usar la conexiã³n (6040) servidor.sin_port = htons (SERV_ADDR); //Realizamos la conexiã³n con el servidor if (connect(s, (struct sockaddr *)&servidor, sizeof(servidor)) < 0) {

12 perror("hubo UN ERROR: no se pudo establecer la conexion."); return 4; automatico //Le informacion a cerca del archivo que queremos if (send(s, argv[2], strlen(argv[2]) + 1, 0) < 0) { perror("hubo UN ERROR: no se pudo enviar los datos."); return 5; // Si no nos dicen cual quiere que sea el nombre del archivo que nos llegue le da uno if (argc > 4) { strcpy(nombre, argv[4]); else { strcpy(nombre, argv[2]); recibir(nombre,s); if(strcmp("img",argv[3])==0){ // Rellenamos nuestra estructura sockaddr_in servidor con el puerto que va a usar la conexiã³n (6040) servidor.sin_port = htons (SERV_ADDR1); //Realizamos la conexiã³n con el servidor if (connect(s, (struct sockaddr *)&servidor, sizeof(servidor)) < 0) { perror("hubo UN ERROR: no se pudo establecer la conexion."); return 4; automatico //Le informacion a cerca del archivo que queremos if (send(s, argv[2], strlen(argv[2]) + 1, 0) < 0) { perror("hubo UN ERROR: no se pudo enviar los datos."); return 5; // Si no nos dicen cual quiere que sea el nombre del archivo que nos llegue le da uno if (argc > 4) { strcpy(nombre, argv[4]); else { strcpy(nombre, argv[2]); recibir(nombre,s); if(strcmp("aud",argv[3])==0){ // Rellenamos nuestra estructura sockaddr_in servidor con el puerto que va a usar la conexiã³n (6040) servidor.sin_port = htons (SERV_ADDR2); //Realizamos la conexiã³n con el servidor if (connect(s, (struct sockaddr *)&servidor, sizeof(servidor)) < 0) { perror("hubo UN ERROR: no se pudo establecer la conexion."); return 4; automatico //Le informacion a cerca del archivo que queremos if (send(s, argv[2], strlen(argv[2]) + 1, 0) < 0) { perror("hubo UN ERROR: no se pudo enviar los datos."); return 5; // Si no nos dicen cual quiere que sea el nombre del archivo que nos llegue le da uno

13 if (argc > 4) { strcpy(nombre, argv[4]); else { strcpy(nombre, argv[2]); recibir(nombre,s); if(strcmp("vid",argv[3])==0){ // Rellenamos nuestra estructura sockaddr_in servidor con el puerto que va a usar la conexiã³n (6040) servidor.sin_port = htons (SERV_ADDR3); //Realizamos la conexiã³n con el servidor if (connect(s, (struct sockaddr *)&servidor, sizeof(servidor)) < 0) { perror("hubo UN ERROR: no se pudo establecer la conexion."); return 4; automatico //Le informacion a cerca del archivo que queremos if (send(s, argv[2], strlen(argv[2]) + 1, 0) < 0) { perror("hubo UN ERROR: no se pudo enviar los datos."); return 5; // Si no nos dicen cual quiere que sea el nombre del archivo que nos llegue le da uno if (argc > 4) { strcpy(nombre, argv[4]); else { strcpy(nombre, argv[2]); recibir(nombre,s); if(strcmp("doc",argv[3])==0){ // Rellenamos nuestra estructura sockaddr_in servidor con el puerto que va a usar la conexiã³n (6040) servidor.sin_port = htons (SERV_ADDR4); //Realizamos la conexiã³n con el servidor if (connect(s, (struct sockaddr *)&servidor, sizeof(servidor)) < 0) { perror("hubo UN ERROR: no se pudo establecer la conexion."); return 4; automatico //Le informacion a cerca del archivo que queremos if (send(s, argv[2], strlen(argv[2]) + 1, 0) < 0) { perror("hubo UN ERROR: no se pudo enviar los datos."); return 5; // Si no nos dicen cual quiere que sea el nombre del archivo que nos llegue le da uno if (argc > 4) { strcpy(nombre, argv[4]); else { strcpy(nombre, argv[2]); recibir(nombre,s);

14 3.2 Servidor Principal /*************************************************************************************** servidor.c: servidor para transferencia de archivos ****************************************************************************************/ #include <sys/types.h> #include <sys/stat.h> #include <sys/socket.h> #include <netinet/in.h> #include <string.h> #include <netdb.h> #include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <unistd.h> #include <string.h> #define STDOUT 1 #define SERV_ADDR (IPPORT_RESERVED+1) //Metodo utilizado para el envio de paquetes. void enviar(char *nombre, int s); //Metodo utilizado para al recepcion de paquetes. int recibir(char *nombre, int s); //Metodo encargado de hacer el log void rellenar( char *nombre, char *ip); /***************************************************************************************** METODO ENVIAR ******************************************************************************************/ void enviar(char *nombre, int s) { FILE* archivoenv; int length = 1024; char buffer[1024]; archivoenv = fopen(nombre, "rb"); while (length == 1024) { length = fread(buffer, 1, 1024, archivoenv); if (length < 0) { perror("hubo UN ERROR: no se pudo leer el archivo."); close(s); fclose(archivoenv); exit(3); if (send(s, &buffer, length, 0) < 0) { perror("hubo UN ERROR: no se pudo enviar los datos."); close(s); fclose(archivoenv); exit(4); int i = 0; while (i < 1024) { buffer[i] = '\0'; i++; // Cierra el descriptor s close(s); // Cierra el archivo de envio fclose(archivoenv); /********************************************************************************************* METODO RECIBIR **********************************************************************************************/

15 int recibir(char *nombre, int s){ FILE* archivorec; int length = 1024; char buffer[1024]; // Creamos el archivo donde se copiaran todos los paquetes que nos lleguen de la descarga archivorec = fopen(nombre, "wb"); // Copia en el archivo creado los distintos paquetes que nos llegan // Siempre entra almenos una vez pq hemos puesto el valor de length por defecto a 1024 // Ademas siempre da una vuelta de mas para asegurarse de que mande el ultimo paquete aunque // este sea de un tamaã±o menor de 1024 while (length == 1024){ length = recv(s, buffer, 1024, 0); if (length < 0) { perror("hubo UN ERROR: no se pudo recibir los datos."); return 6; printf("\ntamano = %i\n", length); printf("recibido : \n"); printf(buffer); if (fwrite(buffer, 1, length, archivorec) < 0) { perror("hubo UN ERROR: No se pudo escribir en el archivo."); return 7; // Cerramos el descriptor close(s); // Cerramos el archivo fclose(archivorec); return 0; /********************************************************************************************* METODO RELLENAR **********************************************************************************************/ void rellenar( char *nombre, char * ip){ FILE* archivolog; FILE* archivodate; char separador[1024]; char date[1024]; strcpy(separador," "); system("date>.date.txt"); archivolog = fopen("log.txt", "ab"); fwrite(separador, 1, strlen(separador), archivolog); fwrite(ip, 1, strlen(ip), archivolog); fwrite(separador, 1, strlen(separador), archivolog); fwrite(nombre, 1, strlen(nombre), archivolog); fwrite(separador, 1, strlen(separador), archivolog); archivodate = fopen(".date.txt", "rb"); fread(date, 1, 1024, archivodate); fwrite(date, 1, strlen(date), archivolog); fwrite("\n",1,1,archivolog); fclose(archivolog); fclose(archivodate); /********************************************************************************************* METODO MAIN **********************************************************************************************/

16 int main() { int leidos; int length; int s; int sockent; char nombre[1024]; struct sockaddr_in my_addr, their_addr; //Creación de un socket de escucha, de tipo "stream" (TCP) s = socket(pf_inet, SOCK_STREAM, 0); if (s < 0) { perror("hubo UN ERROR: no se pudo crear el socket"); return 1; //Voy a asignar ese socket a la direcciã³n de transporte //Primero asigno el tipo de ordenacion de maquina my_addr.sin_family = AF_INET; // Asigno la direccion my_addr.sin_addr.s_addr = htonl(inaddr_any); //Asigno el puerto my_addr.sin_port = htons(serv_addr); //Usamos bind para asociar nuestro socket a un puerto if (bind(s, (struct sockaddr *)&my_addr, sizeof(my_addr)) < 0) { perror("hubo UN ERROR: direccion no asignada"); close(s); return 2; //Posemos a la escucha el socket listen(s, 1); while (1) { /*Me bloqueo esperando peticion de conexion*/ /*Acepto y consigo un socket de dialogo "msgsock"*/ length = sizeof(their_addr); sockent = accept(s, (struct sockaddr *)&their_addr, &length); if (sockent == -1) { perror("hubo UN ERROR: conexion no aceptada."); continue; else { leidos = recv(sockent, &nombre, 1024, 0); if (leidos < 0) { perror("hubo UN ERROR: no se pudo recibir los datos."); else { soket, servidor // Vamos a conseguir la informacion de quien esta al otro lado del // para luego usar con el log... printf("peticion recibida de: %s\n", inet_ntoa(their_addr.sin_addr)); // segun sea un cliente o un servidor secundario el que se connecte el // principal actuara de una forma concreta if(strcmp(nombre,"##**##")==0){ recibir("img.txt",sockent); if(strcmp(nombre,"##++##")==0){ recibir("aud.txt",sockent); if(strcmp(nombre,"##--##")==0){ recibir("vid.txt",sockent); if(strcmp(nombre,"##//##")==0){ recibir("doc.txt",sockent);

17 if(strcmp(nombre,"img")==0){ enviar("img.txt", sockent); rellenar( nombre, (char*)inet_ntoa(their_addr.sin_addr)); if(strcmp(nombre,"aud")==0){ enviar("aud.txt", sockent); rellenar( nombre, (char*)inet_ntoa(their_addr.sin_addr)); if(strcmp(nombre,"vid")==0){ enviar("vid.txt", sockent); rellenar( nombre, (char*)inet_ntoa(their_addr.sin_addr)); if(strcmp(nombre,"doc")==0){ enviar("doc.txt", sockent); rellenar( nombre, (char*)inet_ntoa(their_addr.sin_addr)); printf("\ncerrando conexion.\n"); printf("ejecucion finalizada."); close(s);

18 3.3 Servidor Secundario Tipo (Aquí solo pondremos uno de los servidores secundarios el resto serán igual solo que cambiando los puertos) /******************************************************************************* servidorimg.c: servidor para transferencia de archivos *******************************************************************************/ // Importamos las librerias necesarias para la realizacion de las comunicaciones de socket #include <sys/types.h> #include <sys/stat.h> #include <sys/socket.h> #include <netinet/in.h> #include <string.h> #include <netdb.h> #include <stdio.h> #include <stdlib.h> #include <fcntl.h> #include <unistd.h> #include <string.h> #define SERV_ADDR (IPPORT_RESERVED+1) #define SERV_ADDR1 (IPPORT_RESERVED+2) //Metodo utilizado para el envio de paquetes. void enviar(char *nombre, int s); //Metodo encargado de hacer el log void rellenar( char *nombre, char *ip); /************************************************************************************************** METODO ENVIAR ***************************************************************************************************/ void enviar(char *nombre, int s) { FILE* archivoenv; int length = 1024; char buffer[1024]; archivoenv = fopen(nombre, "rb"); while (length == 1024) { length = fread(buffer, 1, 1024, archivoenv); if (length < 0) { perror("hubo UN ERROR: no se pudo leer el archivo."); close(s); fclose(archivoenv); exit(3); //sleep(2); if (send(s, &buffer, length, 0) < 0) { perror("hubo UN ERROR: no se pudo enviar los datos."); close(s); fclose(archivoenv); exit(4); int i = 0; while (i < 1024) { buffer[i] = '\0'; i++; // Cierra el descriptor s close(s); // Cierra el archivo de envio fclose(archivoenv);

19 /********************************************************************************************* METODO RELLENAR **********************************************************************************************/ void rellenar( char *nombre, char * ip){ FILE* archivolog; FILE* archivodate; char separador[1024]; char date[1024]; strcpy(separador," "); system("date>.date.txt"); archivolog = fopen("log.txt", "ab"); fwrite(separador, 1, strlen(separador), archivolog); fwrite(ip, 1, strlen(ip), archivolog); fwrite(separador, 1, strlen(separador), archivolog); fwrite(nombre, 1, strlen(nombre), archivolog); fwrite(separador, 1, strlen(separador), archivolog); archivodate = fopen(".date.txt", "rb"); fread(date, 1, 1024, archivodate); fwrite(date, 1, strlen(date), archivolog); fwrite("\n",1,1,archivolog); fclose(archivolog); fclose(archivodate); /********************************************************************************************* METODO MAIN **********************************************************************************************/ int main(int argc, const char *argv[]) { FILE* archivolog; FILE* archivocont; int length; int leidos; int s; int sockent; char nombre[1024]; char separador[1024]; char cadena[1024]; strcpy(separador," "); struct sockaddr_in servidor; struct hostent *hp; struct sockaddr_in my_addr, their_addr; //Listamos con una llamada al sistema los contenidos de nuestro servidor //Y los guardamos en un txt system("ls>img.txt"); if (argc < 3) { printf("uso DEL CLIENTE: %s nombre/ip-servidor + nombre/ip-local\n",argv[0]); return 1; // Creamos un socket orientado a conexiã³n (TCP) s = socket(pf_inet, SOCK_STREAM, 0); if (s < 0) { perror("hubo UN ERROR: no se pudo crear el socket."); return 2; //Nos conectamos con el socket de escucha del servidor. //Lo conseguimos calculando primero su direcciã³n, a partir del nombre gracias a gethostbyname() que nos da una ip a partir de un nombre hp = gethostbyname(argv[1]);

20 if (hp == 0) { // Usamos fprintf(stderr, para este error pq perror no permite varios argumentos fprintf(stderr, "HUBO UN ERROR: %s - No se conoce ese computador\n", argv[1]); return 3; //Soket como cliente // Rellenamos nuestra sockaddr_in servidor con la dir ip memcpy(&servidor.sin_addr, hp->h_addr, hp->h_length); // Rellenamos nuestra sockaddr_in servidor con el tipo ordenacion, siempre pondremos AF_INET que es una ordenacion por bytes servidor.sin_family = AF_INET; // Rellenamos nuestra estructura sockaddr_in servidor con el puerto que va a usar la conexiã³n (6040) servidor.sin_port = htons (SERV_ADDR); // Mentemos en el archivo img.txt la ip del servidor secundario archivocont = fopen("img.txt", "ab"); strcpy(cadena,"la direccion ip del servidor secundario es...\n"); fwrite(cadena,1,strlen(cadena),archivocont); fwrite(argv[2], 1, strlen(argv[2]), archivocont); fclose(archivocont); //Realizamos la conexiã³n con el servidor principal para mandarle nuestro txt con los archivos que contenemos if (connect(s, (struct sockaddr *)&servidor, sizeof(servidor)) < 0) { perror("hubo UN ERROR: no se pudo establecer la conexion."); return 4; //Le informacion a cerca del archivo que enviamos if (send(s, "##**##", strlen("##**##") + 1, 0) < 0) { perror("hubo UN ERROR: no se pudo enviar los datos."); return 5; // Y luego le mandamos el archivo propiamente dicho enviar("img.txt", s); /**************************************************************************************** Una vez esto comienza la parte servidora de la aplicacion *****************************************************************************************/ //Creación de un socket de escucha, de tipo "stream" (TCP) s = socket(pf_inet, SOCK_STREAM, 0); if (s < 0) { perror("hubo UN ERROR: no se pudo crear el socket"); return 1; // socket como servidor //Primero asigno el tipo de ordenacion de maquina my_addr.sin_family = AF_INET; // Asigno la direccion my_addr.sin_addr.s_addr = htonl(inaddr_any); //Asigno el puerto my_addr.sin_port = htons(serv_addr1); //Usamos bind para asociar nuestro socket a un puerto if (bind(s, (struct sockaddr *)&my_addr, sizeof(my_addr)) < 0) { perror("hubo UN ERROR: direccion no asignada"); close(s);

21 return 2; //Posemos a la escucha el socket listen(s, 1000); while (1) { // Me bloqueo esperando peticion de conexion //Acepto y consigo un socket de dialogo "msgsock" length = sizeof(their_addr); sockent = accept(s, (struct sockaddr *)&their_addr, &length); if (sockent == -1) { perror("hubo UN ERROR: conexion no aceptada."); continue; else { switch(fork()) { case -1: perror("hubo UN ERROR:No se pudo crear hijo"); return 4; case 0: leidos = recv(sockent, &nombre, 1024, 0); if (leidos < 0) { perror("hubo UN ERROR: no se pudo recibir los datos."); else { // Vamos a conseguir la informacion de quien esta al otro lado del soket, // para luego usar con el log... printf("peticion recibida de: %s\n", inet_ntoa(their_addr.sin_addr)); // Si alguien intenta descargarse el makefile le mando en archivo warning if(strcmp(nombre,"makefile")==0){ enviar(".warning.txt", sockent); rellenar( nombre, (char*)inet_ntoa(their_addr.sin_addr)); else{ enviar(nombre, sockent); rellenar( nombre, (char*)inet_ntoa(their_addr.sin_addr)); break; default: close(sockent); break; printf("\ncerrando conexion.\n"); printf("ejecucion finalizada."); close(s); return 0;

22 3.4 Makefile (Aquí solo pondremos uno de los makefiles el resto serán igual solo que cambiando el nombre del archivo a compilar) CFLAGS = -g -Wall CC = gcc LDIRS = -L./ all: servidor clean echo echo AAPLICACION SERVIDORA echo echo echo Hecho Por Rafael Benedicto Tovar y Antonio Soler echo servidor: echo echo SACANDO EJECUTABLE echo $(CC) servidor.c -o servidor.exe echo echo ELIMINANDO ARCHIVOS echo echo rm -f echo

23 4 Métodos y estructuras implicados en la practica 4.1 Métodos Enviar() Método encargado de enviar en cadenas de bits de tamaño 1024 los distintos datos que deseemos transferir al cliente/servidor Recibir() Método encargado de recibir en cadenas de bits de tamaño 1024 los distintos datos que deseemos que nos transfieran del servidor Rellenar() Método encargado de crear y rellenar el archivo log.txt en los distintos servidores Printf() Esta función es equivalente a fprintf, con el argumento stdout interpuesto antes de los argumentos a printf. La función printf retorna el número de caracteres transmitidos, o un valor negativo si se produce un error de salida. Perror() La función perror transforma el número de error en la expresión entera de errno a un mensaje de error. Escribe una secuencia de caracteres al stream estándar de errores, esto es: primero (si cadena no es un puntero nulo y el carácter apuntado por cadena no es el carácter nulo), la cadena apuntada por cadena seguido de dos puntos (:) y un espacio; entonces un mensaje de errores apropiado seguido por un carácter de línea nueva. El contenido de los mensajes de errores es el mismo que aquello retornado por la función strerror con el argumento errno, que están definidos según la implementación. La función perror no retorna ningún valor.

24 System(date,, ls) Pasa la cadena apuntada por cadena al entorno local para ser ejecutada por el "procesador de comandos" - también denominado "intérprete de comandos" - de una forma definida según la implementación.un puntero nulo puede ser usado para cadena para comprobar si existe un procesador de comandos. Si el argumento es un puntero nulo, la función system retorna un valor distinto a cero sólo si el procesador de comandos está disponible. Si el argumento no es un puntero nulo, la función system retorna un valor definido según la implementación. Strcmp() Compara la cadena apuntada por s1 con la cadena apuntada por s2. La función retorna un número entero mayor, igual, o menor que cero, apropiadamente según la cadena apuntada por s1 es mayor, igual, o menor que la cadena apuntada por s2. Strcpy() Copia la cadena apuntada por s2 (incluyendo el carácter nulo) a la cadena apuntada por s1. La función retorna el valor de s1. Si al copiar una cadena a la otra se superponen, entonces el comportamiento no está definido. Strlen() Calcula el número de caracteres de la cadena apuntada por s. La función retorna el número de caracteres hasta el carácter nulo, que no se incluye. Fwrite() La función fwrite envía, desde el array apuntado por puntero, hasta nmemb de elementos cuyo tamaño es especificado por tamanyo, al stream apuntado por stream. El indicador de posición de ficheros para el stream (si está definido) es avanzado por el número de caracteres escritos correctamente. Si existe un error, el valor resultante del indicador de posición de ficheros para el stream es indeterminado. La función fwrite retorna el número de caracteres escritos correctamente, el cual puede ser menor que nmemb, pero sólo si se produce un error de escritura.

25 Fread() La función fread recibe, en el array apuntado por puntero, hasta nmemb de elementos cuyo tamaño es especificado por tamanyo, desde el stream apuntado por stream. El indicador de posición de ficheros para el stream (si está definido) es avanzado por el número de caracteres leídos correctamente. Si existe un error, el valor resultante del indicador de posición de ficheros para el stream es indeterminado. Si un elemento es parcialmente leído, entonces su valor es indeterminado. La función fread retorna el número de caracteres leídos correctamente, el cual puede ser menor que nmemb si se encuentra un error de lectura o un final de fichero. Si tamanyo o nmemb es cero, fread retorna cero, y el contenido del array y el estado del stream permanecen invariados. Fclose() El stream apuntado por stream será despejado y el fichero asociado, cerrado. Cualquier dato almacenado aún sin escribir para el stream será enviado al entorno local para ser escritos al fichero; cualquier dato almacenado aún sin leer será descartado. El stream es desasociado del fichero. Si el almacenamiento asociado fue automáticamente adjudicado, será desadjudicado. La función fclose retorna cero si el stream fue cerrado con éxito. Si se detectaron errores, entonces retorna EOF. Fopen() Abre un fichero cuyo nombre es la cadena apuntada por nombre, y adjudica un stream a ello. El argumento modo apunta a una cadena empezando con una serie de caracteres de la siguiente secuencia: r w a rb wb ab r+ w+ Abre un fichero de texto para lectura Trunca, a longitud cero o crea un fichero de texto para escribir Añade; abre o crea un fichero de texto para escribir al final del fichero (EOF) Abre un fichero en modo binario para lectura Trunca, a longitud cero o crea un fichero en modo binario para escribir Añade; abre o crea un fichero en modo binario para escribir al final del fichero (EOF) Abre un fichero de texto para actualización (lectura y escritura) Trunca, a longitud cero o crea un fichero de texto para actualización

26 a+ r+b ó rb+ w+b ó wb+ a+b ó ab+ Añade; abre o crea un fichero de texto para actualización, escribiendo al final del fichero (EOF) Abre un fichero en modo binario para actualización (lectura y escritura) Trunca, a longitud cero o crea un fichero en modo binario para actualización Añade; abre o crea un fichero en modo binario para actualización, escribiendo al final del fichero (EOF) Abriendo un fichero con el modo de lectura ('r' como el primer carácter del argumento modo) fallará si el fichero no existe o no puede ser leído. Abriendo el fichero con el modo de añadidura ('a' como el primer carácter del argumento modo) ocasiona todas las escrituras posteriores al fichero a ser forzadas al final de fichero (EOF) actual, sin considerar llamadas interventivas a la función fseek. En algunas implementaciones, abriendo un fichero en modo binario con el modo de añadidura ('b'como el segundo o tercer carácter del argumento modo) puede colocar, inicialmente, el indicador de posición de ficheros para el stream más allá de los últimos datos escritos, debido al relleno de caracteres nulos. Cuando un fichero es abierto con el modo de actualización ('+' como el segundo o tercer carácter del argumento modo), la entrada y salida pueden ser manipuladas en el stream asociado. Sin embargo, la salida no puede estar seguida directamente de una entrada sin tener una llamada interventiva a la función fflush o a una función de manipulación del fichero de posición (fseek, fsetpos, o rewind), y la entrada no puede estar seguida directamente de una salida sin tener una llamada interventiva a una función de manipulación del fichero de posición, al menos que el proceso de entrada encuentre un final de fichero (EOF). Abriendo (o creando) un fichero de texto con el modo de actualización puede en su lugar abrir (o crear) un stream binario en algunas implementaciones. Cuando es abierto, un stream es almacenado completamente si, y sólo si, puede ser determinado que no hace referencia a un dispositivo interactivo. Los indicadores de error y final de fichero (EOF) para el stream son borrados. La función fopen retorna un puntero al objeto controlando el stream. Si el proceso de abertura no es realizado acabo, entonces retorna un puntero nulo.

27 socket() Argumentos: domain. Se podrá establecer como AF_INET (para usar los protocolos ARPA de Internet), o como AF_UNIX (si se desea crear sockets para la comunicación interna del sistema). Éstas son las más usadas, pero no las únicas. Existen muchas más, aunque no se nombrarán aquí. type. Aquí se debe especificar la clase de socket que queremos usar (de Flujos o de Datagramas). Las variables que deben aparecer son SOCK_STREAM o SOCK_DGRAM según queramos usar sockets de Flujo o de Datagramas, respectivamente. protocol. Aquí, simplemente se puede establecer el protocolo a 0. La función socket() nos devuelve un descriptor de socket, el cual podremos usar luego para llamadas al sistema. Si nos devuelve -1, se ha producido un error (obsérvese que esto puede resultar útil para rutinas de verificación de errores). bind() Argumentos: fd. Es el descriptor de fichero socket devuelto por la llamada a socket(). my_addr. es un puntero a una estructura sockaddr addrlen. contiene la longitud de la estructura sockaddr a la cuál apunta el puntero my_addr. Se debería establecer como sizeof(struct sockaddr). La llamada bind() se usa cuando los puertos locales de nuestra máquina están en nuestros planes (usualmente cuando utilizamos la llamada listen()). Su función esencial es asociar un socket con un puerto (de nuestra máquina). Análogamente socket(), devolverá -1 en caso de error. Un aspecto importante sobre los puertos y la llamada bind() es que todos los puertos menores que 1024 están reservados. Se podrá establecer un puerto, siempre que esté entre 1024 y (y siempre que no estén siendo usados por otros programas).

28 connect() Argumentos: fd. Debería configurarse como el fichero descriptor del socket, el cuál fue devuelto por la llamada a socket(). serv_addr. Es un puntero a la estructura sockaddr la cuál contiene la dirección IP destino y el puerto. addrlen. Análogamente de lo que pasaba con bind(), este argumento debería establecerse como sizeof(struct sockaddr). La función connect() se usa para conectarse a un puerto definido en una dirección IP. Devolverá -1 si ocurre algún error. listen() Argumentos : fd. Es el fichero descriptor del socket, el cual fue devuelto por la llamada a socket() backlog. Es el número de conexiones permitidas. La función listen() se usa si se están esperando conexiones entrantes, lo cual significa, si se quiere, que alguien pueda conectarse a nuestra máquina. Como todas las funciones descritas arriba, listen() devolverá -1 en caso de error. accept() Argumentos: fd. Es el fichero descriptor del socket, que fue devuelto por la llamada a listen(). addr. Es un puntero a una estructura sockaddr_in en la que se pueda determinar qué nodo nos est contactando y desde qué puerto. addrlen. Es la longitud de la estructura a la que apunta el argumento addr, por lo que conviene establecerlo como sizeof(struct sockaddr_in), antes de que su dirección sea pasada a accept(). Cuando alguien intenta conectarse a nuestra computadora, se debe usar accept() para conseguir la conexión. Es muy fácil de entender: alguien sólo podrá conectarse (asóciese con connect()) a nuestra máquina, si nosotros aceptamos (asóciese con accept())

29 send() Argumentos: fd. Es el fichero descriptor del socket, con el cual se desea enviar datos. msg. Es un puntero apuntando al dato que se quiere enviar. len. es la longitud del dato que se quiere enviar (en bytes). flags. deberá ser establecido a 0[8]. El propósito de esta función es enviar datos usando sockets de flujo o sockets conectados de datagramas. Si se desea enviar datos usando sockets no conectados de datagramas debe usarse la llamada sendto(). Al igual que todas las demás llamadas que aquí se vieron, send() devuelve -1 en caso de error, o el número de bytes enviados en caso de éxito. recv() int recv(int fd, void *buf, int len, unsigned int flags); Argumentos: fd. Es el descriptor del socket por el cual se leerán datos. buf. Es el búfer en el cual se guardará la información a recibir. len. Es la longitud máxima que podrá tener el búfer. flags. Por ahora, se deberá establecer como 0. Al igual de lo que se dijo para send(), esta función es usada con datos en sockets de flujo o sockets conectados de datagramas. Si se deseara enviar, o en este caso, recibir datos usando sockets desconectados de Datagramas, se debe usar la llamada recvfrom(). Análogamente a send(), recv() devuelve el número de bytes leídos en el búfer, o -1 si se produjo un error. close() La función close() es usada para cerrar la conexión de nuestro descriptor de socket. Si llamamos a close() no se podrá escribir o leer usando ese socket, y si alguien trata de hacerlo recibirá un mensaje de error.

30 fork() Llamamos a fork() para crear un proceso hijo que atendera a la conexion recien establecida El proceso hijo sera igual que el padre, hereda los descriptores de sockets, lo unico que los diferencia es el valor devuelto por fork(), al padre le devuelve el PID del hijo, y al hijo le devuelve un valor cero. Por eso, para saber si estamos en el proceso padre o hijo, comparamos el valor devuelto por fork(). Si fork devuelve cero, entonces estamos en el proceso hijo. inet_addr() Convierte una dirección IP en notación números y puntos, en un unsigned long, retorna la dirección en network byte order. Retorna -1 si hubo error. inet_ntoa() Realiza la conversión inversa, convierte una direccion IP en unsigned long en network byte order, a un string en números y puntos. Main() Función que llama al resto de métodos

31 4.2 Estructuras struct sockaddr { unsigned short sa_family; // AF_* char sa_data[14]; // Direccion de protocolo. ; 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. ; struct in_addr { unsigned long s_addr; // 4 bytes. ; La primer estructura, sockaddr, almacena la dirección de protocolo para muchos tipos de protocolos. sa_family puede ser AF_INET, AF_UNIX u otros dominios, para nuestro tutorial solo será AF_INET. sa_data contiene la dirección IP y número de puerto asignado al socket. Se creó la estructura sockaddr_in para el caso de Internet, para poder referenciar los elementos de forma más fácil. Los punteros a la estructura sockaddr_in deben ser precedidos con un cast tipo *struct sockaddr antes de pasarlos como parámetros a funciones. Notas sobre sockaddr_in: sin_family será AF_INET sin_port (número de puerto) y sin_addr (dirección IP) deberán estar en network byte order, osea habrá que usar htons(). sin_family no debe convertirse a network byte order porque es solo usado por el kernel y no es enviado por la red. sin_zero se utiliza para rellenar la estructura a la longitud de sockaddr, debe estar inicializada a cero con la función bzero(). Ver la página del manual

32 5 Ejemplo de aplicación Vamos a proceder a realizar un ejemplo del funcionamiento de la aplicación propiamente dicha. Ilustraremos dicho ejemplo mediante el uso de capturas de pantalla que facilitarán la comprensión del ejercicio. En este ejemplo un cliente pedirá al servidor principal un listado con los documentos que contiene el servidor secundario, y después realizara una petición al servidor secundario de uno de sus documentos. Paso1 Ejecutaremos los makefiles para compilar nuestros programas Makefile del cliente: Makefile del servidor primario:

33 Makefile del servidor secundario de documentos: Paso 2 Arrancamos el servidor primario Paso 3 Arrancamos el servidor secundario

34 Al arrancar el servidor secundario este generará un listado con todo lo que contiene y se lo mandará al servidor primario. Como podemos observar el servidor primario recibe el listado Paso 4 El cliente realiza una petición del listado al servidor primario Como podemos observar el servidor recibe la petición correctamente Además podemos ver como se a escrito el log del servidor

35 Paso 5 Una vez el cliente ve todo lo que contiene el servidor de documentos realiza una petición al mismo, pero como tenemos dudas de que parámetros insertar tan solo ejecutaremos el cliente sin parámetros, de forma que la aplicación nos informará de que parámetros son los q debemos insertar Una vez tenemos claros los parámetros de la petición la realizamos. Y como podemos observar se realiza correctamente en el servidor

36 6 Seguridad En la realización de esta practica se han tomado ciertas medidas de seguridad que son las siguientes: Se han puesto todos los archivos críticos como ocultos-> Gracias a esto nos aseguramos de que un cliente pernicioso no pueda realizar una petición del código fuente o del log. NOTA: el makefile por motivos de implementación no debe ser oculto. Solución del makefile: Como comentamos en el punto anterior el makefile no puede ser oculto asi que podemos realizar una petición sobre este, para asegurarnos de que esto no ocurra el programa tiene un sistema de autodefensa en el que siempre que siempre que un cliente mande una petición del makefile, se le mande un mensaje de error y además su aplicación cliente se borrará. Mensaje de Makefile.(Warning): Si estas leyendo este documento es que has intentado descargar el makefile asi que otra vez sera... Por cierto por el uso fraudulento de la aplicacion esta se a borrado... Saludos cordiales... 7 Bibliografia Programación de Soket Linux [Sean Waltson] Metodologia de la programación en C [Capitulo 7] Guía Beej de Programación en Redes- Uso de sockets de Internet [Brian "Beej" Hall] Wikipedia Emule