Bonjour , je voudrais envoyer un fichier d'un client à un serveur en utilisant la progrmmation socket par contre quand je fais le transfert le fichier recu est vide .

Voici mes fonctions que j'utilise pour cela coté client : 

void EnvoyerFichier()
{
	char Chemin[100];
	int i=0;
	/* Extraction du chemin */
	while(buffer[i]!=' ')
	{
		i++;
	}
	i++;
	int j=0;
	/* Copie du chemin */

	buffer[strlen(buffer)-1]='\0';
	while(buffer[i]!='\0' && buffer[i]!=' ')
	{
		Chemin[j]=buffer[i];
		j++;
		i++;
	}
	Chemin[j]='\0';
	struct stat st;


	if(stat(Chemin,&st)==-1)
	{
		printf("ERREUR :fichier Inexistant\n");
		strcpy(buffer,"Erreur D'envoie");
	}
	else
	{
		FILE *fp;
		int words=0;
		char c;
		fp=fopen(Chemin,"r");
		while((c=getc(fp)!=EOF))
		{
			fscanf(fp,"%s",buffer);
			if(isspace(c) || c=='\t')
			{
				words++;
			}
		}
		write(sockfd,&words,sizeof(int));
		rewind(fp);
		char ch;
		while(ch !=EOF)
		{
			fscanf(fp,"%s",buffer);
			write(sockfd,buffer,255);
			ch=fgetc(fp);
		}
		printf("FICHIER ENVOYER ! \n");
	}

} 

void Chat()
{
	while(1)
	{
		bzero(buffer,256);
		fgets(buffer,255,stdin);
		if(strncmp(buffer,"/SEND",5)==0)
		{
			n=write(sockfd,buffer,strlen(buffer));
			EnvoyerFichier();
		}
		n=write(sockfd,buffer,strlen(buffer));
		if(n<0)
		{
			error("ERROR writing to socket");
		}
		bzero(buffer,256);
		n=read(sockfd,buffer,255);
		if(n<0)
		{
			error("ERROR reading from socket");
		}
		printf("Server : %s\n",buffer);
		int i=strncmp("Bye",buffer,3);
		if(i==0)
		{
			break;
		}
	}
}

Et voici les fonctions que j'utilise pour le transfert coté serveur : 

void RecevoirFichier(int n,int newsockfd,char* buffer)
{
	FILE *fp;
	int ch=0;
	fp=fopen("/home/adil/Bureau/Projet/Serveur/recu.txt","ab+");
	int words;
	read(newsockfd,&words,sizeof(int));
				printf("%d\n",words);
	while(ch != words)
	{
		read(newsockfd,buffer,255);

		fprintf(fp,"%s",buffer);
		ch++;
	}
	printf("FICHIER RECU\n");
}
void Chat(int n,int newsockfd,char* buffer)
{
	while(1)
	{
		bzero(buffer,256);
		n=read(newsockfd,buffer,255);
		if(n<0)
		{
			error("ERROR reading from socket");
		}



		if(strncmp(buffer,"/SEND",5)==0)
		{
			RecevoirFichier(n,newsockfd,buffer);
		}

		printf("Client : %s\n",buffer);
		bzero(buffer,256);
		fgets(buffer,255,stdin);
		n=write(newsockfd,buffer,strlen(buffer));
		if(n<0)
		{
			error("ERROR writing to socket");
		}
		int i=strncmp("Bye",buffer,3);
		if(i==0)
		{
			break;
		}
	}
	close(newsockfd);
	close(sockfd);
}

Merci D'avance

-
Edité par StarChadi 15 décembre 2018 à 23:27:41

Bonjour

Les fonctions font plein de choses différentes dans le plus grand désordre.

Il faudrait que tu commences par mieux découper le code pour qu'on puisse y voir clair.

Hello,

Je crois que tu te compliques la vie en comptant le nombre de mots (le while() ligne 36 n'est d'ailleurs pas correct).

À moins d'avoir une bonne raison pour envoyer le fichier mot par mot (et je n'en vois pas), on envoie le fichier au complet et le receveur le maltraitera ensuite comme il le souhaite. Ça permet également d'envoyer des fichiers de tous types: image, musique etc....

Il est convenu que l'expéditeur envoie toujours N octets, sauf lors du dernier envoi. En simplifiant, ça donne quelque chose dans ce gout-là

Expédition
----------
faire
	lu=lire N octets du fichier
	envoyer lu octets
tant que lu == N


Réception
---------
faire
	reçu=recevoir octets
	écrire reçu octets dans le fichier
tant que reçu == N

Évidemment, on fait ici joujou avec fread() et fwrite(), plus avec getc() et fscanf() / fprintf()

-
Edité par edgarjacobs 16 décembre 2018 à 14:25:36

@edgarjacobs

Je viens d'éditer mon code pour avoir le resultat suivant :

Server :

void RecevoirFichier(int n,int newsockfd,char* buffer)
{
	FILE* fp;
	fp=fopen("fichier_recu.txt","ab+");
	n=read(newsockfd,buffer,255);
	printf("%s\n",buffer);
	fprintf(fp,buffer);
}

Client : 

void EnvoyerFichier()
{
        FILE* fp;
	fp=fopen("fichier.txt","ab+")
        while(fgets(buffer,255,fp))
        {
	      n=write(sockfd,buffer,255);
              printf("%s\n",buffer);
        }
}

Cela marche quand j'execute ces deux fonctions seules (j'ai pas mis de boucle dans la fonction recevoir pour tester) par contre des que je rajoute la fonction Chat() cela semble plus marcher

-
Edité par StarChadi 16 décembre 2018 à 15:31:05

Hello,

Teste convenablement, avec les bonnes fonctions:

// client

#define BUFSIZE		16	// déconseillé comme taille, juste pour tester

void receiveFile(int newsockfd) {
	int receive_bytes;
	char buffer[BUFSIZE];
    FILE *fp;
    
	fp=fopen("fichier_recu.txt","wb");		// todo: check fp!=NULL
	do {
		receive_bytes=read(newsockfd,buffer,sizeof(buffer));
		fwrite(buffer,receive_bytes,1,fp);
	} while(receive_bytes==sizeof(buffer));
	fclose(fp);
}

/*-----------------------------------------------------------------------*/

// server

#define BUFSIZE		16	// déconseillé comme taille, juste pour tester

void sendFile(int sockfd) {
	int read_bytes;
	char buffer[BUFSIZE];
	FILE *fp;
	
	fp=fopen("fichier.txt","rb");			// todo: check fp!=NULL
	do {
		read_bytes=fread(buffer,sizeof(buffer),1,fp);
		write(sockfd,buffer,read_bytes);
	} while(read_bytes==sizeof(buffer));
	fclose(fp);
}

-
Edité par edgarjacobs 16 décembre 2018 à 17:08:40

sa marche toujours pas chez moi voici le code complet :  ( pour executer : le server prend le port comme param et le client ladresse ip puis le port)

Server

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>



void error(const char *msg)
{
	perror(msg);
	exit(1);
}

void ReceiveFile(int sockfd)
{
	int receive_bytes;
	char buffer[16];
	FILE *fp;
	fp=fopen("fichier_recu.txt","wb");
	do{
		receive_bytes=read(sockfd,buffer,sizeof(buffer));
		fwrite(buffer,receive_bytes,1,fp);
	}while(receive_bytes==sizeof(buffer));
	fclose(fp);
}

void EnvoyerMessage(int n,int newsockfd,char *buffer)
{
	fgets(buffer,255,stdin);
	n=write(newsockfd,buffer,strlen(buffer));
	if(n<0)
	{
		error("ERROR writing to socket");
	}
	int i=strncmp("Bye",buffer,3);
}

void Chat(int n,int newsockfd,int sockfd,char *buffer)
{
	while(1)
	{
		bzero(buffer,256);
		n=read(newsockfd,buffer,255);
		if(n<0)
		{
			error("ERROR reading from socket");
		}

		if(strncmp(buffer,"/SEND",5)==0)
		{
			ReceiveFile(newsockfd);
		}
		printf("Client : %s\n",buffer);
		EnvoyerMessage(n,newsockfd,buffer);

	}
	close(newsockfd);
	close(sockfd);
}

void Serveur(char **argv)
{
	
	int sockfd,n,newsockfd;
	char buffer[255];
	int portno;
	socklen_t clilen;
	struct sockaddr_in serv_addr,cli_addr;
	sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(sockfd<0)
	{
		error("ERROR opening socket");
	}
	bzero((char *) &serv_addr,sizeof(serv_addr));
	portno=atoi(argv[1]);
	serv_addr.sin_family=AF_INET;
	serv_addr.sin_addr.s_addr=INADDR_ANY;
	serv_addr.sin_port=htons(portno);
	if(bind(sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) <0)
	{
		error("ERROR on binding");
	}
	listen(sockfd,5);
	clilen=sizeof(cli_addr);
	newsockfd=accept(sockfd,(struct sockaddr *) &cli_addr,&clilen);
	if(newsockfd < 0)
	{
		error("ERROR on accept");
	}

	if(n<0)
	{
		error("ERROR reading from socket");
	}
	Chat(n,newsockfd,sockfd,buffer);
}

int main(int argc,char *argv[])
{
	if(argc<2)
	{
		fprintf(stderr,"ERROR, no port provided\n");
		exit(1);
	}
	Serveur(argv);
}

CLIENT :

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/stat.h>



void error(const char *msg)
{
	perror(msg);
	exit(0);
}

void sendFile(int sockfd)
{
	int read_bytes;
	char buffer[16];
	FILE* fp;
	fp=fopen("fichier.txt","rb");
	do	
	{
		read_bytes=fread(buffer,sizeof(buffer),1,fp);
		write(sockfd,buffer,read_bytes);
	}while(read_bytes==sizeof(buffer));
	
}
void RecevoirMessage(int n,int sockfd,char* buffer)
{
	bzero(buffer,256);
	n=read(sockfd,buffer,255);
	if(n<0)
	{
		error("ERROR reading from socket");
	}
	printf("Server : %s\n",buffer);
	int i=strncmp("Bye",buffer,3);
}
void Chat(int n,int sockfd,char* buffer)
{
	while(1)
	{
		bzero(buffer,256);
		fgets(buffer,255,stdin);
		if(strncmp(buffer,"/SEND",5)==0)
		{
			n=write(sockfd,buffer,strlen(buffer));
			sendFile(sockfd);
		}
		n=write(sockfd,buffer,strlen(buffer));
		if(n<0)
		{
			error("ERROR writing to socket");
		}
		RecevoirMessage(n,sockfd,buffer);
	}
}

int ConnexionServeur(char *argv[])
{
	int sockfd,n;
	char buffer[256];
	int portno;
	struct sockaddr_in serv_addr;
	struct hostent *server;
	portno=atoi(argv[2]);
	sockfd=socket(AF_INET, SOCK_STREAM, 0);
	if(sockfd < 0)
	{
		error("ERROR opening socket");
	}
	server = gethostbyname(argv[1]);
	if(server==NULL)
	{
		fprintf(stderr,"ERROR ,no such host\n");
		exit(0);
	}
	bzero((char *) &serv_addr,sizeof(serv_addr));
	serv_addr.sin_family=AF_INET;
	bcopy((char *)server->h_addr,(char*)&serv_addr.sin_addr.s_addr,server->h_length);
	serv_addr.sin_port=htons(portno);
	if(connect(sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0)
	{
		error("ERROR connecting");
	}
	Chat(n,sockfd,buffer);
}




int main(int argc,char **argv)
{
	if(argc < 3)
	{
		fprintf(stderr,"usage %s hostname port\n", argv[0]);
		exit(0);
	}ConnexionServeur(argv);
}

-
Edité par StarChadi 16 décembre 2018 à 18:01:52

Il y a beaucoup trop de code pour un simple test.

Oublie ton chat et compagnie. Fais un programme de base pour tester si oui on non tu es capable de transférer un fichier d'une machine à l'autre: le serveur attend une connexion, dès que le client se connecte, le serveur envoie un fichier puis termine la connexion. Rien que ça, tout simplement (et oui, développer en C prend du temps).

edgarjacobs a écrit:

Il y a beaucoup trop de code pour un simple test.

Oublie ton chat et compagnie. Fais un programme de base pour tester si oui on non tu es capable de transférer un fichier d'une machine à l'autre: le serveur attend une connexion, dès que le client se connecte, le serveur envoie un fichier puis termine la connexion. Rien que ça, tout simplement (et oui, développer en C prend du temps).

Justement c'est que j'arrive bien à transferer un fichier mais des que je rajoute la fonction pour le chat(). L'envoie du fichier ne marche pas le fichier se crée mais il est vide.