[C] trasfermento file Client/Server

[Vincenzoflaminio]

Come da titolo non riesco ad effettuare in modo corretto un trasferimento di un file in particolare il file che si copia dal client al server ha una serie di NUL character (/0) che sembrano tra l'altro apparire in modo random e che non sono presenti nel file di origine.
Aggiungo che devo usare Read e Write e non sendfile.

Codice Client

void Trasferisci(int DescrittoreSocket) {
    
    int  fd_sorg,nread;
    struct timeval tv;
	long int tempoTrasferimento;
	char buff[2048];
    DIR *dir;  // puntatore alla directory su cui lavorare
    struct dirent *file_dir; // struttura rappresentate i file della directory
    struct stat info_file; // struttura contenente info sul file
    char *nome_file; // stringa contenente il nome del file

	   gettimeofday(&tv, 0);
	   tempoTrasferimento = tv.tv_sec * 1000000 + tv.tv_usec;

       printf("Client: invio file\n");

		printf("Client: file inviato\n");
		gettimeofday(&tv, 0);
		tempoTrasferimento = (tv.tv_sec * 1000000 + tv.tv_usec)
				- tempoTrasferimento;

		printf("Trasferimento terminato, tempo di trasferimento microsec. %ld, \n",
				tempoTrasferimento);

    // mi sposto nella directory locale dello studente
    chdir(directory);  
    
    // apro la directory specificata passata
    if ((dir = opendir(directory)) == NULL)
        {
            perror("Errore apertura directory!!!");
            exit(-2);
        }

    // scorre la directory appena aperta
    while ((file_dir = readdir(dir)) != NULL) { 
    
        // recupero info sul file specificato da path
        if ((stat(file_dir->d_name, &info_file)) < 0)
              {
                perror("Errore stat!!!");
                exit(-3);
              }
        nome_file = file_dir->d_name; 
        int len =strlen(nome_file);
        nome_file[len]='\0';
 	    
	    // Apro il file per il trasferimento
		if ((fd_sorg = open(nome_file, O_RDONLY)) < 0)
		{
			perror("open file sorgente");
		}
		
		// trasferisco il file
		while ((nread = read(fd_sorg, buff, sizeof(buff)) > 0))
		{
			write(DescrittoreSocket, &buff, nread);
		}
              
    }
    
    // chiude il file
    close(fd_sorg);
        
    // chiude la directory appena utilizzata 
        closedir(dir);

return;
}

Codice Server

int CopiaFile(int connfd,char path[]) {
   
   char info[2048];
   int fd_dest;
   DIR *dir;  // puntatore alla directory su cui lavorare
   char nome_file[80]; // Stringa contenente il nome file inviato dal client
   
   memset((char *) &nome_file, 0, sizeof(nome_file));
   memset((char *) &info, 0, sizeof(info)); 
   
   //leggo il nome del file
   read(connfd,&nome_file,sizeof(nome_file)); 
   int len=strlen(nome_file);
   nome_file[len] ='\0';
   printf("Il nome del file da trasferire e' %s di lunghezza %d\n",nome_file,len);

   // mi sposto nella directory remota
   chdir(path); 
  
   // apro la directory dello studente
   if ((dir = opendir(path)) == NULL)
   {
       perror("Errore apertura directory!!!");
       exit(-1);
   }
   fd_dest = open(nome_file,O_WRONLY|O_CREAT|O_APPEND,0777);//O_CREAT || O_TRUNC || O_WRONLY);
   if (fd_dest< 0) {
			perror("open file sorgente");
			exit(-1);
      }

   int letti,scritti;

//   while ((letti = read(connfd, &info, sizeof(info)) > 0) ) */
   while (1)
   			{
				
				if((letti=read(connfd, &info, sizeof(info))==0)) {
				     break;
				}     
				printf("info %s\n" , info);    
				printf("info %d\n" , letti);  
				scritti=write(fd_dest, &info, sizeof(info));
				printf("scritti =%d \n",scritti);
				break;
			}
 
  close(fd_dest);

  // chiude la directory appena utilizzata 
  closedir(dir);
 
return 0;

}

[lishi]

Cosi su due piedi.

1) Manca da qualche parte la spedizione della lunghezza del file.
Ovvero

Prima del file devi spedire la lunghezza(lunghezza in byte fissa, 4 byte per un int dovrebbero bastare). A questo punto leggi i primi quattro byte dal socket e la condizione di stop del while sarà la lettura di un numero di byte pari alla lunghezza spedita. La condizione di leggere 0 byte non basta in quando per motivi di rete potresti leggere 0 byte anche se ci sono ancora dati da leggere.

Questo è un consiglio generale, non penso che possa dare il comportamento che tu vedi.

Per cui

2)
Leggi sempre la documentazione delle funzioni, in particolare se ti danno problemi.
read() può anche tornare un numero negativo, che indica un errore.
Se succedo questo il tuo programma suppone che i dati letti siano validi quando in realtà non lo sono.

[Vincenzoflaminio]

Originariamente inviato da lishi

Cosi su due piedi.

1) Manca da qualche parte la spedizione della lunghezza del file.
Ovvero

Prima del file devi spedire la lunghezza(lunghezza in byte fissa, 4 byte per un int dovrebbero bastare). A questo punto leggi i primi quattro byte dal socket e la condizione di stop del while sarà la lettura di un numero di byte pari alla lunghezza spedita. La condizione di leggere 0 byte non basta in quando per motivi di rete potresti leggere 0 byte anche se ci sono ancora dati da leggere.

Questo è un consiglio generale, non penso che possa dare il comportamento che tu vedi.

Per cui

2)
Leggi sempre la documentazione delle funzioni, in particolare se ti danno problemi.
read() può anche tornare un numero negativo, che indica un errore.
Se succedo questo il tuo programma suppone che i dati letti siano validi quando in realtà non lo sono.

Sono uno studente quindi un principiante, ti ringrazio per la dritta ma non so come attuarla , come faccio a dire alla funzione quanti byte spedire?
La Read e la Write leggono COUNT byte dal Buffer(void * buf) è qui che sbaglio?

[Oceans11]

$ man 2 read
DESCRIPTION
       read()  attempts to read up to count bytes from file descriptor fd into
       the buffer starting at buf. [...]
RETURN VALUE
       On success, the number of bytes read is returned (zero indicates end of
       file), and the file position is advanced by this number.  It is not  an
       error  if  this  number  is smaller than the number of bytes requested;  
       this may happen for example because fewer bytes are actually  available
       right  now. [...]

Significa che devi sempre controllare se hai letto quanti byte hai richiesto di leggere e, in caso negativo, rileggere nuovamente.

Inoltre, per spedire un intero su socket devi stare attento alle dimensioni dell'intero (in byte, che sono machine e compiler dependent) e endianess.
(man ntohl e man htonl)