coger numeros archivo socket

[tommylej]

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:

312;243;344;
625;166;577;88;4;
634;99;111;
 

servidor:

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>
#include<ctype.h>
#define MYPORT 3490    // Puerto al que conectarán los usuarios
#define MAXBUFLEN 200  // Maximo de caracteres para el buffer
#define BACKLOG 10     // Conexiones pendientes en cola
#define MAX 100
 
int longitud;//LONGITUD DE LA CADENA ENTRADA
char salida[MAX];//SALIDA YA CONVERTIDA A LETRAS
char actual[MAX];//VALOR DEL NUMERO ACTUAL
char actualposterior[MAX];//VALOR DEL NUMERO POSTERIOR
char revisada[MAX]; //LA ENTRADA UNA VEZ REVISADA PARA Q EL USUARIO NO ENTRE LETRAS
void num_letra(char revisada[]); //FUNCION Q "TRADUCE" AL CASTELLANO
 
int sockfd; // El servidor escuchara por sockfd
int newfd; // las transferencias de datos se realizar mediante newfd
char buf[MAXBUFLEN];// buffer para recivir o enviar datos
struct sockaddr_in my_addr; // contendra la direccion IP y el numero de puerto local
struct sockaddr_in their_addr;//Contendra la direccion IP y numero de puerto del cliente
socklen_t sin_size;//Contendra el tamaño de la escructura sockaddr_in
 
char *token = NULL;
char vector [MAX];
int cont,loop,a;
 
void crear_socket();
void atributos();
void socket_name();
void escuchar();
void aceptar();
void recibir();
void enviar(char cadena[]);
void crear_socket()//se crea el medio por el cual se va a realizar la comunicación:
{
  //AF_INET = Dominio donde se realiza la conexión.( unidos mediante una red TCP/IP).
  //SOCK_STREAM = Uso del protocolo TCP
  //0 = selecciona el protocolo más apropiado
 
  if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)//Crea el socket y verifica si hubo algun error
  {
    perror("socket");
    exit(1);
  }
}
void atributos() // Asignamos valores a la estructura my_addr para luego poder llamar a la funcion bind()
{
  my_addr.sin_family = AF_INET; //Se sa un servidor Stream (Protocolo TCP)
 
  my_addr.sin_port = htons(MYPORT); //se asigna el puerto por el que se va a escuchar (3490)
 
  my_addr.sin_addr.s_addr = INADDR_ANY; // se usa la IP local
 
  bzero(&(my_addr.sin_zero), 8); // rellena con ceros el resto de la estructura 
}
 
void socket_name()//Le asignamos un nombre al socket, para recivir conexiones
{
  if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1)
  {
    perror("bind");
    exit(1);
  }
}
void escuchar()// Habilitamos el socket para recibir conexiones, con una cola de 10 conexiones en espera como maximo (BACKLOG)
{
  if (listen(sockfd, BACKLOG) == -1)
  {
    perror("listen");
    exit(1);
  }  
}
void aceptar()//accept = Se utiliza en el servidor, con un socket habilitado para recibir conexiones
{
  sin_size = sizeof(struct sockaddr_in);
   if ((newfd = accept(sockfd, (struct sockaddr *)&their_addr,&sin_size)) == -1)
  {
    perror("accept");
    exit(1); // Si se produce un error se finaliza el programa
  }
  printf("server: conexion desde: %s\n", inet_ntoa(their_addr.sin_addr));  
}
void recibir()
{
  if ((recv(newfd, buf, MAXBUFLEN, 0)) == -1)// buf = tipo de funcion a realizar
  {
    perror("recv");
    exit(1);
  }
}
void enviar(char cadena[])
{
  if (send(newfd, cadena, MAXBUFLEN, 0) == -1)//envia el resultado de la conversion de numero a letras
  perror("send");
  exit(1);
}
int main()//metodo principal
{ 
  crear_socket();
    atributos();
    socket_name();
  escuchar();
 
  while(1) // ciclo para llamar accept
  {
    cont=0;
    // Llamamos a fork() para crear un proceso hijo que atendera a la conexion recien establecida
    aceptar();
    if (!fork())
    { 
      //comienza el proceso hijo y enviamos los datos mediante newfd
      
      recibir();
      int a;
      if (strcmp (buf,"1") == 0)//1 = InitCap
      {
    cont=0;//cuenta las lineas que va recibiendo el servidor
    send(newfd, "", 1, 0);//+++++++++
    recibir();// se recibe la cantidad de lineas que tiene el archivo que abrió el cliente
    printf("lineas a procesar: %s\n",buf);
    loop = atoi(buf);//loop tiene la cantidad de lineas que tiene el archivo que abrió el cliente
    send(newfd, "", 1, 0);//+++++++++
    while(cont < loop)//el ciclo se repite el numero de lineas que tenga el archivo enviado por el cliente
    {
      cont++;//aumenta el contador de lineas
      recibir();//se reciben las lineas
      
      [B]/* AQUI NECESITO COGER LOS NUMEROS PASARLOS A UN VECTOR
      CUANDO HAYA PASADO TODAS LAS LINEAS Y TENGA TODOS LOS NUMEROS ORDENAR EL VECTOR*/[/B]
      
      }
       /*ESTO ORDENA EL VECTOR*/
    int temp;
    int j;
    for(i=0; i<(a-1); i++) {
     for (j=i+1; j<a; j++) {
        if(vector[j]<vector[i]) {
            temp=vector[j];
            vector[j]=vector[i];
            vector[i]=temp;
        }
     }
    }
      [B]/* AQUI DEBO ENVIAR EL VECTOR AL CLIENTE SEPARANDO LOS NUMEROS POR ;*/[/B]
    
    printf("Listo!!!\n\n");
      
      close(newfd);
      exit(0);
    }
    close(newfd);
  }
}
 

[tommylej]

cliente:

Código C:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <iostream>
#define PORT 3490 // puerto al que vamos a conectar 
#define MAXBUFLEN 100  // Maximo de caracteres para el buffer
#define MAX 100
using namespace std;
    
char num[10],opcn[1];
int sockfd, numbytes;  
char buf[MAXBUFLEN];
struct hostent *he;
struct sockaddr_in their_addr; // información de la dirección de destino 
size_t len;
FILE *archivo;
FILE *archivo2;
char name[MAX],name2[MAX];;
char linea[MAX];
int cont_line;
char loop[100];
 
void crear_socket();
void menu();
void conectar();
void atributos();
void host_name(char *argv[]);
void enviar_opcion();
void enviar(char cadena[]);
void recibir();
void enviar_lineas();
void enviar_lineas()//enviar lineas del archivo, para que el servidor las procese
{
  cont_line=-1;//contador de lineas del archivo
  while(!feof(archivo))//recorro el archivo, hasta llegar al final de este
  {
    fgets(linea,1000,archivo);//agarro cada linea del archivo
    cont_line++;//contador de lineas del archivo
  }
  
  sprintf(loop,"%d",cont_line);//paso el valor entero de cont_line a loop, que es de tipo char[10]
  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
  recibir();//++++++++++
    archivo=fopen(name,"r");//vuelvo a abrir el archivo pq el puntero quedó al final de este
   archivo2=fopen(name2,"w+");//abro el archivo donde voy a guardar el resultado
 
  while(!feof(archivo))//recorre todo el contenido del archivo
  {
    fgets(linea,1000,archivo);//agarra toda una linea del txt con un maximo de 1000 caracteres
    if(!feof(archivo))
    {
      enviar(linea);//envio las lineas al servidor
      recibir();//recibo las lineas ya modificadas por el servidor
      fprintf(archivo2,"%s",buf);//guardo en el archivo2 las lineas modificadas
    }
  }
  //se cierran los archivos
  fclose(archivo);
  fclose(archivo2);
}
  void menu()
{
  int opc;
    printf("* 1. Archivos *\n");
  printf("* 2. Salir    *\n");
    scanf("%d",&opc);
  switch(opc)
  {
    case 1://archivos
      
    printf ("\n Escriba el nombre del archivo que desea abrir: ");
    scanf("%s", &name);//se guarda en name el nombre del archivo de texto
    strcpy(name2,name);
    strcat(name2,"2");
    strcat(name,".txt");//se añade ".txt" en la última línea de name, para establecer la extensión
    strcat(name2,".txt");//se añade ".txt" en la última línea de name, para establecer la extensión
    archivo=fopen(name,"r");//se abre el archivo con el modo "r"(solo lectura y debe existir previamente)
    recibir();//+++++++++++
    enviar_lineas();
       
    case 2://salir
      exit(1);
    break;
  }
}
 
void host_name(char *argv[])//Se utiliza para convertir un nombre de un host a su dirección IP
{
  if ((he=gethostbyname(argv[1])) == NULL)
  {  
    perror("gethostbyname");
    exit(1);
  }
}
 
void crear_socket()//se crea el socket para comunicarse con el servidor
{
  if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) 
  {
    perror("socket");
    exit(1);
  } 
}
 
void conectar()// nos conectamos con el servidor
{
  if (connect(sockfd, (struct sockaddr *)&their_addr,sizeof(struct sockaddr)) == -1) 
  {
    perror("connect");
    exit(1);
  }
}
 
void atributos()//definimos el tipo de transferencia,puerto y la ip con la que nos vamos a comunicar
{
  len = sizeof(struct sockaddr_in);
  their_addr.sin_family = AF_INET;    // Ordenación de bytes de la máquina 
  their_addr.sin_port = htons(PORT);  // short, Ordenación de bytes de la red 
  their_addr.sin_addr = *((struct in_addr *)he->h_addr);// se pasa la direccion ip al socket 
  memset(&(their_addr.sin_zero), 8, len);  // poner a cero el resto de la estructura 
}
 
void enviar(char cadena[])//envio de datos
{
  if ((send(sockfd, cadena, strlen(cadena), 0)) == -1) 
  {
    perror("send");
    exit(1);
  }   
}
 
void recibir()//resibir datos
{
  if ((numbytes=recv(sockfd, buf, MAXBUFLEN, 0)) == -1)
  {
    perror("recv");
    exit(1);
  }
}
 
int main(int argc, char *argv[])//metodo principal del programa
{
  if (argc != 2) 
  {
    fprintf(stderr,"usaste solo: %d argumento, escribe también el nombre del servidor\n",argc);
    exit(1);
  }
    
  host_name(argv);
  crear_socket();
    atributos();
    conectar();
    menu();
  close(sockfd);
  return 0;
}
 

[sam90]

Hay cosas que no me cierran del codigo. Porque el cliente envia una parte y espera a recivir. No deberia mandar el archivo entero y despues recibir??

Por otro lado, yo no mandaria el archivo asi entero. Sino que leeria de a entero y lo vas mandando como un entero y no como una cadena de caracteres.

Para leer del archivo podrias usar
fscanf(archivo,"%d;",entero);

Por cada entero que lees lo vas almacenando en un array y luego mandas el array:

send(sockfd, vector,sizeof(int) * cant_elemento , 0);

[tommylej]

el codigo tendra muchos errores porque es la primera vez que trabajo con sockets, entonces cualquier cosa que me digais para mejorarlo o que veais que esta mal me gustaria que me lo dijeran, para cambiarlo y probarlo,
muchas gracias