• Sábado 14 de Diciembre de 2024, 14:54
« anterior próximo »
Páginas: [1]

Autor Tema:  numeros archivo socket  (Leído 985 veces)

tomario

  • Nuevo Miembro
  • *
  • Mensajes: 17
    • Ver Perfil
numeros archivo socket
« en: Viernes 10 de Diciembre de 2010, 23:24 »
0
hola he hecho el siguiente codigo de socket, en el que el cliente envia un archivo al servidor con unos numeros y este se los devuelve ordenados en otro archivo.
he hecho la comuncicacion y el cliente le envia el archivo por lineas.

lo que no se hacer es como coger los numeros de las lineas que va enviando y pasarlas a un vector.
ordenarlos si que se,

y luego como se los devuelvo??

archivo a ordenar:
Código: C
  1.  
  2. 312;243;344;
  3. 625;166;577;88;4;
  4. 634;99;111;
  5.  
  6.  

servidor:
Código: C
  1.  
  2. /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- S E R V I D O R -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
  3.  
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <unistd.h>
  7. #include <errno.h>
  8. #include <string.h>
  9. #include <sys/types.h>
  10. #include <sys/socket.h>
  11. #include <netinet/in.h>
  12. #include <arpa/inet.h>
  13. #include <sys/wait.h>
  14. #include <signal.h>
  15. #include<ctype.h>
  16.  
  17. #define MYPORT 3490 // Puerto al que conectarán los usuarios
  18. #define MAXBUFLEN 200 // Maximo de caracteres para el buffer
  19. #define BACKLOG 10 // Conexiones pendientes en cola
  20.  
  21.  
  22. #define MAX 100
  23.  
  24. int longitud;//LONGITUD DE LA CADENA ENTRADA
  25. char salida[MAX];//SALIDA YA CONVERTIDA A LETRAS
  26. char actual[MAX];//VALOR DEL NUMERO ACTUAL
  27. char actualposterior[MAX];//VALOR DEL NUMERO POSTERIOR
  28. char revisada[MAX]; //LA ENTRADA UNA VEZ REVISADA PARA Q EL USUARIO NO ENTRE LETRAS
  29.  
  30. void num_letra(char revisada[]); //FUNCION Q "TRADUCE" AL CASTELLANO
  31.  
  32.  
  33. int sockfd; // El servidor escuchara por sockfd
  34. int newfd; // las transferencias de datos se realizar mediante newfd
  35. char buf[MAXBUFLEN];// buffer para recivir o enviar datos
  36. struct sockaddr_in my_addr; // contendra la direccion IP y el numero de puerto local
  37. struct sockaddr_in their_addr;//Contendra la direccion IP y numero de puerto del cliente
  38. socklen_t sin_size;//Contendra el tamaño de la escructura sockaddr_in
  39.  
  40. char *token = NULL;
  41. char vector [MAX];
  42. int cont,loop,a;
  43.  
  44. void crear_socket();
  45. void atributos();
  46. void socket_name();
  47. void escuchar();
  48. void aceptar();
  49. void recibir();
  50. void enviar(char cadena[]);
  51.  
  52. void crear_socket()//se crea el medio por el cual se va a realizar la comunicación:
  53. {
  54. //AF_INET = Dominio donde se realiza la conexión.( unidos mediante una red TCP/IP).
  55. //SOCK_STREAM = Uso del protocolo TCP
  56. //0 = selecciona el protocolo más apropiado
  57.  
  58. if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)//Crea el socket y verifica si hubo algun error
  59. {
  60. perror("socket");
  61. exit(1);
  62. }
  63. }
  64.  
  65. void atributos() // Asignamos valores a la estructura my_addr para luego poder llamar a la funcion bind()
  66. {
  67. my_addr.sin_family = AF_INET; //Se sa un servidor Stream (Protocolo TCP)
  68.  
  69. my_addr.sin_port = htons(MYPORT); //se asigna el puerto por el que se va a escuchar (3490)
  70.  
  71. my_addr.sin_addr.s_addr = INADDR_ANY; // se usa la IP local
  72.  
  73. bzero(&(my_addr.sin_zero), 8); // rellena con ceros el resto de la estructura
  74. }
  75.  
  76. void socket_name()//Le asignamos un nombre al socket, para recivir conexiones
  77. {
  78. if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1)
  79. {
  80. perror("bind");
  81. exit(1);
  82. }
  83. }
  84.  
  85. void escuchar()// Habilitamos el socket para recibir conexiones, con una cola de 10 conexiones en espera como maximo (BACKLOG)
  86. {
  87. if (listen(sockfd, BACKLOG) == -1)
  88. {
  89. perror("listen");
  90. exit(1);
  91. }
  92. }
  93.  
  94. void aceptar()//accept = Se utiliza en el servidor, con un socket habilitado para recibir conexiones
  95. {
  96. sin_size = sizeof(struct sockaddr_in);
  97.  
  98. //Se espera por conexiones
  99.  
  100. if ((newfd = accept(sockfd, (struct sockaddr *)&their_addr,&sin_size)) == -1)
  101. {
  102. perror("accept");
  103. exit(1); // Si se produce un error se finaliza el programa
  104. }
  105. printf("server: conexion desde: %sn", inet_ntoa(their_addr.sin_addr));
  106. }
  107.  
  108. void recibir()
  109. {
  110. if ((recv(newfd, buf, MAXBUFLEN, 0)) == -1)// buf = tipo de funcion a realizar
  111. {
  112. perror("recv");
  113. exit(1);
  114. }
  115. }
  116.  
  117. void enviar(char cadena[])
  118. {
  119. if (send(newfd, cadena, MAXBUFLEN, 0) == -1)//envia el resultado de la conversion de numero a letras
  120. perror("send");
  121. exit(1);
  122. }
  123.  
  124. int main()//metodo principal
  125. {
  126. crear_socket();
  127.  
  128. atributos();
  129.  
  130. socket_name();
  131.  
  132. escuchar();
  133.  
  134. while(1) // ciclo para llamar accept
  135. {
  136. cont=0;
  137. // Llamamos a fork() para crear un proceso hijo que atendera a la conexion recien establecida
  138. aceptar();
  139. if (!fork())
  140. {
  141. //comienza el proceso hijo y enviamos los datos mediante newfd
  142.  
  143. recibir();//el servidor recive que tipo de funcion tiene que realizar
  144.  
  145. int a;
  146. if (strcmp (buf,"1") == 0)//1 = InitCap
  147. {
  148. cont=0;//cuenta las lineas que va recibiendo el servidor
  149. send(newfd, "", 1, 0);//+++++++++
  150. recibir();// se recibe la cantidad de lineas que tiene el archivo que abrió el cliente
  151. printf("lineas a procesar: %sn",buf);
  152. loop = atoi(buf);//loop tiene la cantidad de lineas que tiene el archivo que abrió el cliente
  153. send(newfd, "", 1, 0);//+++++++++
  154. while(cont < loop)//el ciclo se repite el numero de lineas que tenga el archivo enviado por el cliente
  155. {
  156. cont++;//aumenta el contador de lineas
  157. recibir();//se reciben las lineas
  158.  
  159. /* AQUI NECESITO COGER LOS NUMEROS PASARLOS A UN VECTOR
  160. CUANDO HAYA PASADO TODAS LAS LINEAS Y TENGA TODOS LOS NUMEROS ORDENAR EL VECTOR*/
  161.  
  162. }
  163.  
  164. /*ESTO ORDENA EL VECTOR*/
  165. int temp;
  166. int j;
  167. for(i=0; i<(a-1); i++) {
  168. for (j=i+1; j<a; j++) {
  169. if(vector[j]<vector[i]) {
  170. temp=vector[j];
  171. vector[j]=vector[i];
  172. vector[i]=temp;
  173. }
  174. }
  175. }
  176. /* AQUI DEBO ENVIAR EL VECTOR AL CLIENTE SEPARANDO LOS NUMEROS POR ;*/
  177.  
  178. printf("Listo!!!nn");
  179.  
  180. close(newfd);
  181. exit(0);
  182. }
  183. close(newfd);
  184. }
  185. }
  186.  
  187.  

cliente:
Código: C
  1.  
  2. /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*- C L I E N T E -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
  3.  
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <unistd.h>
  7. #include <errno.h>
  8. #include <string.h>
  9. #include <netdb.h>
  10. #include <sys/types.h>
  11. #include <netinet/in.h>
  12. #include <sys/socket.h>
  13. #include <iostream>
  14.  
  15. #define PORT 3490 // puerto al que vamos a conectar
  16.  
  17. #define MAXBUFLEN 100 // Maximo de caracteres para el buffer
  18. #define MAX 100
  19.  
  20. using namespace std;
  21.  
  22. char num[10],opcn[1];
  23. int sockfd, numbytes;
  24. char buf[MAXBUFLEN];
  25. struct hostent *he;
  26. struct sockaddr_in their_addr; // información de la dirección de destino
  27. size_t len;
  28.  
  29. FILE *archivo;
  30. FILE *archivo2;
  31. char name[MAX],name2[MAX];;
  32. char linea[MAX];
  33. int cont_line;
  34. char loop[100];
  35.  
  36. void crear_socket();
  37. void menu();
  38. void conectar();
  39. void atributos();
  40. void host_name(char *argv[]);
  41. void enviar_opcion();
  42. void enviar(char cadena[]);
  43. void recibir();
  44. void enviar_lineas();
  45.  
  46. void enviar_lineas()//enviar lineas del archivo, para que el servidor las procese
  47. {
  48. cont_line=-1;//contador de lineas del archivo
  49. while(!feof(archivo))//recorro el archivo, hasta llegar al final de este
  50. {
  51. fgets(linea,1000,archivo);//agarro cada linea del archivo
  52. cont_line++;//contador de lineas del archivo
  53. }
  54.  
  55. sprintf(loop,"%d",cont_line);//paso el valor entero de cont_line a loop, que es de tipo char[10]
  56. enviar(loop);//envío la cantidad de lineas al servidor, osea: tamaño que va a durar la conversación entre el servidor y el cliente
  57. recibir();//++++++++++
  58.  
  59. archivo=fopen(name,"r");//vuelvo a abrir el archivo pq el puntero quedó al final de este
  60.  
  61. archivo2=fopen(name2,"w+");//abro el archivo donde voy a guardar el resultado
  62.  
  63. while(!feof(archivo))//recorre todo el contenido del archivo
  64. {
  65. fgets(linea,1000,archivo);//agarra toda una linea del txt con un maximo de 1000 caracteres
  66. if(!feof(archivo))
  67. {
  68. enviar(linea);//envio las lineas al servidor
  69. recibir();//recibo las lineas ya modificadas por el servidor
  70. fprintf(archivo2,"%s",buf);//guardo en el archivo2 las lineas modificadas
  71. }
  72. }
  73. //se cierran los archivos
  74. fclose(archivo);
  75. fclose(archivo2);
  76. }
  77.  
  78. void menu()
  79. {
  80. int opc;
  81.  
  82. printf("***************n");
  83. printf("* 1. Archivos *n");
  84. printf("* 2. Salir *n");
  85. printf("***************nn");
  86. scanf("%d",&opc);
  87. switch(opc)
  88. {
  89. case 1://archivos
  90.  
  91. printf ("n Escriba el nombre del archivo que desea abrir: ");
  92. scanf("%s", &name);//se guarda en name el nombre del archivo de texto
  93. strcpy(name2,name);
  94. strcat(name2,"2");
  95. strcat(name,".txt");//se añade ".txt" en la última línea de name, para establecer la extensión
  96. strcat(name2,".txt");//se añade ".txt" en la última línea de name, para establecer la extensión
  97. archivo=fopen(name,"r");//se abre el archivo con el modo "r"(solo lectura y debe existir previamente)
  98. recibir();//+++++++++++
  99. enviar_lineas();
  100.  
  101. case 2://salir
  102. exit(1);
  103. break;
  104. }
  105. }
  106.  
  107. void host_name(char *argv[])//Se utiliza para convertir un nombre de un host a su dirección IP
  108. {
  109. if ((he=gethostbyname(argv[1])) == NULL)
  110. {
  111. perror("gethostbyname");
  112. exit(1);
  113. }
  114. }
  115.  
  116. void crear_socket()//se crea el socket para comunicarse con el servidor
  117. {
  118. if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
  119. {
  120. perror("socket");
  121. exit(1);
  122. }
  123. }
  124.  
  125. void conectar()// nos conectamos con el servidor
  126. {
  127. if (connect(sockfd, (struct sockaddr *)&their_addr,sizeof(struct sockaddr)) == -1)
  128. {
  129. perror("connect");
  130. exit(1);
  131. }
  132. }
  133.  
  134. void atributos()//definimos el tipo de transferencia,puerto y la ip con la que nos vamos a comunicar
  135. {
  136. len = sizeof(struct sockaddr_in);
  137. their_addr.sin_family = AF_INET; // Ordenación de bytes de la máquina
  138. their_addr.sin_port = htons(PORT); // short, Ordenación de bytes de la red
  139. their_addr.sin_addr = *((struct in_addr *)he->h_addr);// se pasa la direccion ip al socket
  140. memset(&(their_addr.sin_zero), 8, len); // poner a cero el resto de la estructura
  141. }
  142.  
  143. void enviar(char cadena[])//envio de datos
  144. {
  145. if ((send(sockfd, cadena, strlen(cadena), 0)) == -1)
  146. {
  147. perror("send");
  148. exit(1);
  149. }
  150. }
  151.  
  152. void recibir()//resibir datos
  153. {
  154. if ((numbytes=recv(sockfd, buf, MAXBUFLEN, 0)) == -1)
  155. {
  156. perror("recv");
  157. exit(1);
  158. }
  159. }
  160.  
  161. int main(int argc, char *argv[])//metodo principal del programa
  162. {
  163. if (argc != 2)
  164. {
  165. fprintf(stderr,"usaste solo: %d argumento, escribe también el nombre del servidorn",argc);
  166. exit(1);
  167. }
  168.  
  169. host_name(argv);
  170.  
  171. crear_socket();
  172.  
  173. atributos();
  174.  
  175. conectar();
  176.  
  177. menu();
  178.  
  179. close(sockfd);
  180. return 0;
  181. }
  182.  
Páginas: [1]
« anterior próximo »