Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 13
  1. #1

    [C] Client Server per Trasferimento File

    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

    codice:
    /*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

    codice:
    /* 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);	
    }

  2. #2
    1 - Regolamento sezione nº 6.
    2 - Visto il punto nº 1 non ho seguito moltissimo il codice, pero ti posso dire che:
    la accept non si richiama cosi:
    codice:
    //server.c line 70
    newsock=accept(sock,NULL,NULL);
    Infatti dall'output del server che rimane in ascolto:
    codice:
    accept: Bad file descriptor
    Comunque, chiedi di identarlo o fallo tu.
    EDIT: e correggi quel dettaglio.. I socket si creano nella maniera dovuta, non basta un semplice file descriptor. Seconda cosa, é mal strutturato secondo me...

  3. #3
    Grazie mille!!!

  4. #4
    ¿Quindi hai risolto?

  5. #5
    simo era un problema di comunicazione di processi era come se il client andasse piu veloce del server al momento della spedizione della stringa contenente il file di testo durante il passaggio. riguardo la accept nn so che dire il prof ci ha insegnato a inizializzarla solo così, come suggeriresti affinchè io possa far sparire quella fastidiosa notice di accept?

  6. #6
    come suggeriresti affinchè io possa far sparire quella fastidiosa notice di accept?
    codice:
    server.c
    
      int sock, newsock, err, pid, nread, clenght;
      struct sockaddr_in server, client;
      clenght = sizeof(client);
    
      ...
    
         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, (struct sockaddr *)&client, (socklen_t*)&clenght);
      
      ...
    Comunque il problema del file non é quello.

  7. #7
    Scusa
    Grazie mille!!!
    di niente . Non volevo essere sgarbato..

  8. #8
    Appena mi collego da linux provo a correggere secondo tue direttive e ti faccio sapere, il guaio è che su questi prototipi di funzione si trova poco sia sui libri che su internet ed ho seguito direttamente le slide del prof che inizializzavano tutto a null. Grazie ancora simo sei un grande

  9. #9
    Di niente figurati . Cmq ho visto che nel tuo sorgente non hai utilizzato la sendfile che é molto piú efficace di una implementazione di read & write.. Diciamo che é fatta a proposito
    Prova a cambiare un po il codice.. Se lo posti ricordati dei TAG CODE

  10. #10
    simo grazie! la sostituzione ha funzionato alla grande, l'errore non compare piu.
    io cmq vorrei postare tutto solo che non mi fa usare i tag, non me li rileva, e quindi sto postando e cancellando di continuo ma non si risolve.
    Cmq grazie davvero sei stato un grande!!!!

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.