[C] Trasferimento file client/server

[blackphoenix82]

Ciao ragazzi ho scritto questi 2 sorgenti per un Client e un Server che implementano download server-client e upload client-server di alcuni file di testo .doc
il problema è che mentre l'operazione Upload mi funziona correttamente (anche se copia il file in maniera un po' sporca e vorrei ripulirlo) quella Download invece non effettua nessuan copia file anche se ne crea uno nuovo vuoto.
ma non riesco a capire dove sbaglio, il codice mi sembra corretto,
PLEASE AIUTATEMI SONO DISPERATO E' PER UN ESAME!!!!
Allego sorgenti
GRAZIE A CHIUNQUE MI AIUTI

/*client.c*/

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h> /*sockaddr_in*/
#include <unistd.h> /*read,write,close*/
#include <errno.h>
#include <string.h>
#include <fcntl.h> /*gestione file*/


#define PORT 5000
#define SERVER_IP "127.0.0.1"
char sceltaOperazioneClient (int sock);
char *sceltaFileDownload(int sock);
void invioFileDownload(int sock, char *titoloFile);
char *sceltaFileUpload(int sock);
void ricezioneFileUpload(int sock, char *nomefile);
int main(){
	
	int sock,err, fd,nread;
	struct sockaddr_in server;
	char buffer[1024], opScelta,bufferlettura[1024],clear, *titoloFile;
	int scelta;
	char *titoloFileDownload, *titoloFileUpload, *nomeFileUpload,*nomefile, *nomefilescelto;

	
	/*indicazioni del server*/
	server.sin_family=AF_INET;
	/*IP da formato dotted a network*/
	inet_pton(AF_INET,SERVER_IP,&server.sin_addr);
	/*da short a big endian*/
	server.sin_port = htons(PORT);

	/*creazione di una socket*/
	sock=socket(AF_INET,SOCK_STREAM,0);
		if (sock<0){
		perror("socket");
		exit(1);
		} else { 
   			printf("Client: Socket creata\n");
			}

	/*richiesta di connessione*/
	err = connect(sock,(struct sockaddr*)&server,sizeof(server));
		if (err<0){
		perror("connect");
		exit(1);
	}
			
	opScelta=sceltaOperazioneClient(sock);
	switch(opScelta){
		case 'd':
	        titoloFileDownload=sceltaFileDownload(sock);
	        invioFileDownload(sock,titoloFileDownload);
		break;
		
		
		case 'u':
		
		titoloFileUpload=sceltaFileUpload(sock);
		ricezioneFileUpload(sock, titoloFileUpload);
		
		break;
		default:
		printf("Impossibile");
		break;
		
	
		}
	close(sock);
}


/****FUNZIONI DOWNLOAD *****/

char sceltaOperazioneClient (int sock)
{	
	char buffer[1024],scelta;

	memset(buffer, 0, sizeof(buffer)); /*puliamo il buffer*/
	/*leggiamo e stampiamo il buffer per la scelta tra download e upload*/
	read(sock,buffer,sizeof(buffer)); //legge messaggio di scelta up down
	printf("%s\n",buffer);
	/*alla richiesta del server digitiamo la nostra scelta
	e la inviamo al server*/
	scelta=fgetc(stdin);
	write(sock,&scelta,sizeof(scelta)); //invia scelta al server
	return scelta;
}

char *sceltaFileDownload(int sock)
{	
	char buffer[1024],scelta,clear, *titolo;
	read(sock,buffer,sizeof(buffer)); //legge elenco ricevuto da server
	printf("%s\n",buffer); //stampa elenco su client
	clear = '\n';
	scanf("%c",&clear);
	scelta=fgetc(stdin); //input da tastiera della scelta
	write(sock,&scelta,sizeof(scelta)); //invio scelta al server
	memset(buffer, 0, sizeof(buffer));
	printf("\n hai scelto di scaricare il seguente file: ");
	read(sock,buffer,sizeof(buffer)); //nome del file scelto, reinviato da server
	printf("%s \n\n\n",buffer); //stampa nome file scelto
	titolo=buffer;        
	return titolo;
}

void invioFileDownload(int sock, char *titoloFile) 
{
	char bufferlettura[1024],scelta,nread;
	int fd;
	/*creiamo un file con tutti i permessi con il nome contenuto nel buffer*/
	fd = open(titoloFile, O_CREAT | O_WRONLY,0700);
	if (fd < 0) {
		perror("open");
		exit(1);
	}else
	{
		printf("Ho creato il file: %s  \n\n",titoloFile);
	}
	while ((nread = read(sock, bufferlettura, sizeof(bufferlettura))) != 0) {
		// e li memorizza sul file 
		write(fd, bufferlettura, nread);
				memset(bufferlettura,0,sizeof(bufferlettura));
	}
	printf("\n download avvenuto con successo\n");
	close(fd);
}

/*******************FUNZIONI UPLOAD X CLIENT************************/

char *sceltaFileUpload(int sock)
{
	int scelta;
		char *nomefile, *elenco[4]={"catullo.doc","lorca.doc","nonloso.doc","bhooo.doc"};
	printf("\nElenco File su Client\n[1]catullo.doc\n[2]lorca.doc\n[3]nonloso.doc");
	scanf("%d",&scelta);
	scelta=scelta-1;		
	printf("\n\nscelta = %d\n\n",scelta);
	nomefile=elenco[scelta];
	printf("\n Si vuole caricare il file %s in Upload da Client a Server\n\n",nomefile);
	write(sock, nomefile,strlen(nomefile));
	sleep(10);
	return nomefile;
}



void ricezioneFileUpload(int sock, char *nomefile)
{
	int fileUp, nread;
	char buffer[1024];		
	fileUp = open(nomefile,  O_RDONLY);
	if (fileUp < 0) {
		perror("open");
		exit(1);
	}
	fflush(stdin);
	memset(buffer,0,sizeof(buffer));
	/* finchè il file non è finito,legge sizeof(buffer) byte e li bufferizza */
	fflush(stdin);
	while ((nread = read(fileUp, buffer, sizeof(buffer))) != 0) 
	{	
		//una volta bufferizzati, li inviamo al client
		write(sock, buffer, sizeof(buffer));
		memset(buffer,0,sizeof(buffer));
	}
	printf("\n upload avvenuto con successo\n");
	close(fileUp);
}

Lato Server

/* server.c */

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h> /*sockaddr_in*/
#include <unistd.h> /*read,write,close*/
#include <errno.h>
#include <string.h>
#include <fcntl.h> /*gestione file*/


#define PORT 5000
#define CONNMAX 10

char sceltaOperazioneClient(int sock);
int sceltaFileDownload(int sock);
char* ricercaFileDownload(int fscelto,int sock);
void invioFileDownload(char* nomefilescelto,int sock);
char *sceltaFileUpload(int sock);
void ricezioneFileUpload(int sock, char *titoloFile);

int main(){

	int sock,newsock,err,pid, nread;
	struct sockaddr_in server;
	int fscelto, fd;
	char *fileDownload,scelta;
	char buffer[1024], bufferlettura[1024];
	char *nomFile, *titoloFileUpload;
	
	/*creiamo la socket e memorizziamo in sock il descriptor*/
	/*AF_INET:ipv4*/
	sock=socket(AF_INET,SOCK_STREAM,0);
		if (sock<0){
		perror("socket");
		exit(1);
		} else { 
   			printf("Socket creata\n");
			}

	/*assegniamo indirizzo e porta*/
	server.sin_family=AF_INET;
	server.sin_addr.s_addr= INADDR_ANY;
	/*converte in big endian uno short*/
	server.sin_port = htons(PORT);
	
	/*assegna a sock i parametri del server*/
	err = bind(sock,(struct sockaddr*) &server,sizeof(server));
		if (err<0){
		perror("bind");
		exit(1);
	}
	
	/*la socket in ascolto*/
	err=listen(sock,CONNMAX);
		if (err<0){
		perror("listen");
		exit(1);
	} else {
		printf("socket in ascolto\n");
		}

/*********************************************************************************************/
	
	while(1){
	/*la socket accetta la richiesta di connessione dal Client*/
	/*il secondo e il terzo parametro identificano il client e possono essere NULL*/
	newsock=accept(sock,NULL,NULL);
		if (newsock<0){
		perror("accept");
		exit(1);
	} else { printf("Server: connessione accettata\n");
		}
	/*creiamo un processo figlio*/
	if((pid=fork())==0){
		close(sock); /*il processo figlio libera la sock e usa newsock*/
	scelta=sceltaOperazioneClient(newsock);

	switch (scelta) {
	case 'd':
		
	fscelto=sceltaFileDownload(newsock);
	fileDownload=ricercaFileDownload(fscelto,newsock);
	invioFileDownload(fileDownload,newsock);
	break; 	

	case 'u':
	
	titoloFileUpload=sceltaFileUpload(newsock);
	ricezioneFileUpload(newsock,titoloFileUpload);
	break;

	default:
	("!!! Impossibile effettuare Scelta dell'Operazione da Eseguire !!!\n\n");	
	break;
	}	
	}
	/*il processo padre chiude newsock*/
	close(newsock);
	}
/********************************END WHILE**************************************/
}

/*in ingresso la sock in uscita il numero del file scelto*/
int sceltaFileDownload(int sock){
	
	char scelta;
	int fscelto;
	char *buffer;
	
	buffer = "Elenco Poeti:\n[1]dante.doc\n[2]leopardi.doc\n[3]catullo.doc\n[4]d_annunzio.doc\ninserire il numero desiderato: ";
	/*inviamo l'elenco al client*/
	write(sock,buffer,strlen(buffer)+1); 
	/*leggiamo la scelta del client*/
	read(sock,&scelta,sizeof(scelta));
	/*essendo la scelta un char ne ricaviamo il numero corrispondente 
	sottraendo 48 che equivale a 0
	e sottraendo 1 per ricondurci agli indici dell'array*/
	fscelto = (scelta - 48)-1;
	return (fscelto);
}

/* in ingresso il numero del file scelto e la sock*/
char* ricercaFileDownload(int fscelto,int sock){
	int fd,nread;
	char *elenco[4]={"dante.doc","leopardi.doc","catullo.doc","d_annunzio.doc"};
	char buffer[1024],*nomefile;
	nomefile = elenco[fscelto];
	/*confermiamo al client il nome del file scelto*/
	printf("Il client sta provando a scaricare: %s\n",nomefile);
	write(sock,nomefile,strlen(nomefile));
	sleep(10);
	return nomefile;
}

void invioFileDownload(char* nomefilescelto,int sock){
	int fd,nread;
	
	char buffer[1024];
	printf("sto inviando il contenuto di : %s\n",nomefilescelto);
	/*apriamo il file in modalitÃ_ lettura*/
	
	fd = open(nomefilescelto,  O_RDONLY);
	if (fd < 0) {
		perror("open");
		exit(1);
	}fflush(stdin);
	memset(buffer,0,sizeof(buffer));
	/* finchè il file non è finito,legge sizeof(buffer) byte e li bufferizza */
	fflush(stdin);
	while ((nread = read(fd, buffer, sizeof(buffer))) != 0) 
	{	
		//una volta bufferizzati, li inviamo al client
		write(sock, buffer, sizeof(buffer));
		memset(buffer,0,sizeof(buffer));
	}
	close(fd);
}

char sceltaOperazioneClient(int sock){
	char scelta;
	int fscelto;
	char *buffer;
	
	buffer = "scegli (d) per scaricare un file oppure (u) per caricare un file ";
	/*inviamo l'elenco al client*/
	write(sock,buffer,strlen(buffer)+1);
	/*leggiamo la scelta del client*/
	read(sock,&scelta,sizeof(scelta));
	
	return (scelta);
}


/************************FUNZIONI UPLOAD X SERVER***************************************/

char *sceltaFileUpload(int sock)
{
	char *titoloFile, buffer[1024];
	read(sock,buffer,sizeof(buffer)); //nome del file scelto, reinviato da server
	titoloFile=buffer;
	printf("Stai tentando di caricare il file [ %s ] da Client a Server\n\n",titoloFile); //stampa nome file scelto
	/*creiamo un file con tutti i permessi con il nome contenuto nel buffer*/
	return titoloFile; 
}

	
void ricezioneFileUpload(int sock, char *titoloFile)
{
	char buffer[1024], bufferlettura[1024];
	int fileUp,nread;
	fileUp = open(titoloFile, O_CREAT | O_WRONLY,0700);
	if (fileUp < 0) {
		perror("open");
		exit(1);
	}else
	{
		printf("Ho creato il file: %s  \n\n",titoloFile);
	}fflush(stdin);
	memset(bufferlettura, 0, sizeof(bufferlettura));
	/* il buffer riceve i byte */
	fflush(stdin);
	while ((nread = read(sock, bufferlettura, sizeof(bufferlettura))) != 0) {
		// e li memorizza sul file 
		write(fileUp, bufferlettura, nread);
	memset(bufferlettura, 0, sizeof(bufferlettura));
	}
	printf("\n upload avvenuto con successo\n");
	close(fileUp);	
}