Application de transfert de fichiers socket client serveur unix c

Commenter

Contenu du snippet

Cette application permet de télécharger des fichiers txt depuis un serveur distant .. on peut télécharger d'autre formats en mais nous avons préféré afficher que les fichiers texte si le fichier téléchargé existe déjà on peut soit écraser l'ancien soit changer le path soit le renommer d'autre part le serveur crée un fichier d'historique pour garder mes traces des clients qui se sont connéctés ... le fork sert a gerer la connexion ed plusieurs clients a la fois ... é plein d'autres options .. Tous cela c sous UNIXProgrammé Par Younes BOUANAN et Yassine CHERKAOUI de l'école MOHAMMEDIA D'INGENIEURS RABAT/MAROC

Source / Exemple : 


/////////////////////////////////////////////////////////////
//Serveur
//Programmed by Younes BOUANAN and Yassine CHERKAOUI
//////////////////////////////////////////////////////////////
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <signal.h>
#include <netdb.h> 
#include <string.h>
#include <time.h>
#include <fcntl.h>
#include <unistd.h>
#include <dirent.h>
void gererClient(int ,int ,char *);
void verifierResultat(int , int , char *,char *); //verifier s'il y a eu une erreur ou une deconnexion pour un client
void superopen(void);
void superwrite(FILE *,char []);
void superclose(FILE *);
void supread(FILE *,char []);
void gererIO(char *);
void gererIO2(char *);
typedef struct{
		int size;
		int exist;
}head;

int main()
{	printf("Initialisation du serveur \n");
	superopen();
	int sock, nouv_sock, activer = 1,pid;
	struct sockaddr_in adresse_client;
	struct sockaddr_in adresse_serveur;
	char tt[30];
	socklen_t socklen;
	
	bzero(&adresse_serveur, sizeof(struct sockaddr));

	adresse_serveur.sin_family = AF_INET;
	adresse_serveur.sin_addr.s_addr = INADDR_ANY;
	adresse_serveur.sin_port = htons(9999);

	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (bind(sock, &adresse_serveur, sizeof(struct sockaddr)) == -1)
		{perror("bind error:");exit(1);}
	if (listen(sock, 5) == -1)
		perror("listen error:");
	printf("---------------------------------------------\n");
	printf("*******Serveur de transfert de fichier*******\n");
	printf("_____________________________________________\n");
	while(1){
			if ((nouv_sock = accept(sock, &adresse_client, &socklen)) == -1)
				perror("Accept");
			else{
				switch(fork()){
				case -1:
					perror("Fork");
					break;
				
				case 0:
					close(sock);
					pid=getpid();
					printf("Connection de %s",inet_ntoa(adresse_client));
					strcpy(tt,inet_ntoa(adresse_client));
					//puts(tt);
					gererIO(tt);
					gererClient(nouv_sock,pid,tt);
					
					break;
				
				default:
					close(nouv_sock);
				}
			}
		}
}
void verifierResultat(int n, int sock, char *fonct,char * tt ){
	if (n < 0) { //La fonction a rencontré une 
		printf("socket %d ", sock);
		perror("fonct");
		exit(0);
	} else 
		if (n == 0) { //Il y a eu une déconnexion
			printf("Déconnexion de %d\n", sock);
			gererIO2(tt);
			exit(0);
		}
}
int nbchar(char NOM[]){
	FILE *fichier;
	int compteur=0;
	fichier=fopen (NOM,"r");
 	while (getc(fichier)!=EOF)compteur++;
 	fclose(fichier);
	return(compteur);
}
int exist(char *NOM){
	char *rep;
	struct dirent* entree;
	rep = opendir(".");
	while((entree=readdir(rep)) != NULL){
		if (strcmp(entree->d_name,NOM)==0){
			return 1;}
	}
	return 0;
}
void gererClient(int sock,int p , char * tt ){
	int n,i,taille,ex=0,m=0;
	char buffer[255],NOM[30];
	FILE *P_FICHIER;
	head entete;
	printf("\nConnexion de %d\n", p);
	for (;;){
		fflush(stdin);m=0;
		n = recv(sock, buffer, 255, 0);
		verifierResultat(n, sock, "recv",tt); //verifier la valeur de retour de recv
		strcpy(NOM,buffer);
		NOM[n-1]='\0';
		ex=exist(NOM);
		if (ex==1){
			buffer[n-1]=0; //Il se peut qu'on reçoit une chaine non terminée par un caractere nul, cela peut entrainer une erreur
			taille=nbchar(NOM);
			printf("\n%d :Requette de téléchargement du fichier :%s de taille :%d octets\n*************************************************************************\n", p,buffer,taille);
			printf("Envoi du fichier :%s au client : %d \n*************************************************************************\n",NOM,p);
			//envoi
			entete.size=taille;
			entete.exist=1;
			send(sock,&entete,sizeof(head),0);
			verifierResultat(n,sock,"send",tt);
			P_FICHIER=fopen(NOM,"r");
			while(!feof(P_FICHIER)&&m<taille){
						fgets(buffer,255,P_FICHIER);
//printf("la valuer du buffer  : --[%s]--\n",buffer);
						n = send(sock, buffer, strlen(buffer), 0);
						verifierResultat(n,sock,"send",tt); //verifier la valeur de retour de s
//printf("la valeur de n :%d\n",n);
						m=n+m;	}
			printf("FIN DE L'ENVOI DE %s\n*************************************************************************\n",NOM);
		
			if (strcmp(buffer, "stop\n") == 0) {
				shutdown(sock, SHUT_RDWR);
				close(sock);
				exit(0);
				}
		
			}
		else{
			printf("\nle fichier : %s demandé par %d n'existe pas.\n",NOM,p);
			printf("*************************************************************************\n");
			entete.size=0;
			entete.exist=0;
			send(sock,&entete,sizeof(head),0);
			verifierResultat(n,sock,"send",tt);	
			}
	}
}
void superopen(void)//ouvre un fichier et verifie s'il exite et ecrit les fichiers existants dans le serveur ds un fichier
{//init.txt
       FILE * monfil;int p;
       char top[100];
       char tip[100];
       struct dirent *lecture;
       DIR *rep;
       rep = opendir(".");
       if(rep!=0){
       monfil=fopen("init.txt","w");
       if(monfil==NULL)                       {
                                              printf("Erreur lors de l'ouverture\n");
                                              exit(1);
                                              }
       else                                   {
                                              //printf("ouveture reussie\n");
                                              }
       while ((lecture = readdir(rep)))
       {
	p=strlen(lecture->d_name);
        if(lecture->d_name[0]!='.'&&lecture->d_name[p-1]=='t'&&lecture->d_name[p-2]=='x'&&lecture->d_name[p-3]=='t')
		{//printf("\nla valeur :%s\n",lecture->d_name);
			if(strcmp(lecture->d_name,"init.txt")!=0){//printf("\nla valeur :%s",lecture->d_name);
		superwrite(monfil,lecture->d_name);}}
		
       }
      superclose(monfil);	
	}
      else
      printf("impossible d'initialiser");
      closedir(rep);
}

void superwrite(FILE * monfil,char top[])//permet l'ecriture d'un fichier
     {
       if(fwrite(top,1,strlen(top),monfil)<strlen(top))
                                                {
                                                printf("Proleme lors ecriture\n");                                                exit(1);
                                                }
       else                                     {
                                                //printf("ecriture bien derouler\n"); 
}
  if(fwrite("\n",1,1,monfil)<1)
                                                {
                                                printf("Proleme lors ecriture\n");
                                                exit(1);
                                                }
       else                                     {
                                                //printf("ecriture bien derouler\n");
                                                }
}

void superclose(FILE * monfil)//fermeture de fichier avec traitement d'erreur
     {
     if(fclose(monfil)==EOF){
                               printf("Erreur lors de la fermeture\n");                         
                               exit(1);
                               }
       else                    {
                               //printf("fermeture bien derouler\n");                               
                               }
}

void supread(FILE * monfil,char tip[])//lecture d'un fichier avec traitement des erreurs
     {
       if(fread(tip,1,100,monfil)==0)
                                              {
                                              printf("Probleme d'ecriture");                                              
                                              exit(1);
                                              }
       else
                                              {
                                              //printf("lecture bien derouler\nle texte est :\n\t");
						//puts(tip);
                                              }
}
void gererIO(char * tt ){//ecriture de date et d'IP du connécté lors de sa connection 
	FILE * monfil;
	time_t t;
	time(&t);
	char top[100];
	monfil=fopen("historique.log","a");
	strcpy(top,ctime(&t));
	superwrite(monfil,"----------------");
	superwrite(monfil,"Connection de :");
	superwrite(monfil,tt);
	superwrite(monfil,top);	
	superwrite(monfil,"----------------");
	superclose(monfil);
}
void gererIO2(char * tt ){//ecriture de date et d'IP du connécté lors de sa déconnection 
	FILE * monfil;
	time_t t;
	time(&t);
	char top[100];
	monfil=fopen("historique.log","a");
	strcpy(top,ctime(&t));
	superwrite(monfil,"----------------");
	superwrite(monfil,"Déconnection de :");
	superwrite(monfil,tt);
	superwrite(monfil,top);	
	superwrite(monfil,"----------------");
	superclose(monfil);
}
/////////////////////////////////////////////////
/////////////////////////////////////////////////
////////////////////////////////////////////////
///////CLIENT Programmed by Yassine CHERKAOUI and Younes BOUANAN
//////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <signal.h>
#include <netdb.h> 
#include<string.h>
#include <fcntl.h>
#include <unistd.h>
#include <dirent.h>
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Prototypes
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//verifier si le fichier exist ou pas
int exist(char *);
int existrep(char *);
//affiche si le repertoire exist ou pas
void verifierResultat(int n, char *fonct);
//afficher le message d'erreur et termine le programme
void erreur(char *s);
//Remplir les champs de la structure
void preparerAdresse(int argc, char *argv[], struct sockaddr *adresse_serveur);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////structure de l'entete du fichier 
typedef struct{
		int size;//// La taille du fichier s'il exist///
		int exist;//// egale a 0 si le fichier n'est pas disponible ou a 1 si le fichier exist //////
}head;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int main(int argc, char *argv[]){

	struct sockaddr adresse_serveur;
	int sock,n,taille,g,cd,t,e=0;
	char buffer[255],NOM_FICHIER[30], buf[255],bf[255], buff[255],tb[3],tib[3];
	FILE *P_FICHIER;strcpy(tb,"no");strcpy(tib,"no");
	head entete;

	bzero(&adresse_serveur, sizeof(struct sockaddr));	
	//Remplir la structure d'adresse du serveur avec les arguments 
	preparerAdresse(argc, argv, &adresse_serveur);

	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
		erreur("Socket");

	if (connect(sock, &adresse_serveur, sizeof(struct sockaddr)) == -1){
			erreur("Connect");
			}
	printf("\n--------------------------------------\n");
	printf("Client pour telechargement de fichiers\n");
	printf("--------------------------------------\n");
		do{
			cd=0;g=0;t=0;
			do{
				printf("voulez vous voir les fichiers serveur: yes/no  :");
				if(e==0)scanf("%s",&bf);fflush(stdout);
				if(e>0){//printf("la valeur %s",bf);
					scanf("%s",&tib);}
			}while((strcmp(bf,"yes")!=0)&&(strcmp(bf,"no")!=0)&&(strcmp(tib,"yes")!=0)&&(strcmp(tib,"no")!=0));
			//printf("operation tictic");
			//puts(tib);
			if((strcmp(bf,"yes")!=0)&&(strcmp(tib,"no")==0)){
				printf("\nEntrer le nom du fichier a telecharger:");
				if(e==0||(strcmp(tib,"no")==0)){fgets(buffer, 255, stdin);fgets(buffer, 255, stdin);}
				else fgets(buffer, 255, stdin);
				fflush(stdin);}
			else {
				strcpy(buffer,"init.txt ");g=1;
			     }
			if(strcmp(buffer,"stop\n")==0)
				exit(0);
			n = send(sock, buffer, strlen(buffer), 0);
			verifierResultat(n, "send");
			buffer[n-1]='\0';
			n = recv(sock,&entete,sizeof(head),0);
			verifierResultat(n, "recv");
			if ((entete.exist)==1){
			printf("la taille du fichier demande :%d octets\n",entete.size);
///////////////////////////////////////////////
			////Reception du fichier
///////////////////////////////////////////////		
			while(exist(buffer)!=0&&t==0)
			{
			printf("Le fichier existe  !!!!\n");
			do{
			printf("   1-renommer\n   2-ECRASER\n   3-changer path\n    4-Quitter");
			printf("\nEntrer le num  :   ");
			scanf("%d",&cd);}while(cd!=1&&cd!=2&&cd!=3);
			switch(cd)
				{
					case 1:{
						printf("NB  :   n'oubliez pas l'exention\n");
						printf("Entrez le nouveau nom : ");
						scanf("%s",&buf);
						strcpy(buffer,buf);puts(buffer);
						break;}
					case 2:{
						t=1;
						break;}
					case 3:{printf("Entrez le path que vous voulez :");
						scanf("%s",&buff);
						if(existrep(buff)!=1)printf("repertoire inexistant ");
						else
						{strcat(buff,buffer);
						strcpy(buffer,buff);t=1;
						break;}
						}
					case 4:{
						close(sock);exit(0);
						break;}
				}
			}
			P_FICHIER=fopen(buffer,"w");
			////remplir le fichier
			fflush(stdin);bzero(buffer,256);
			taille=0;
			while(taille<entete.size){
			n = recv(sock, buffer,255, 0);
			verifierResultat(n, "recv"); //verifier la valeur de retour de recv
			fprintf(P_FICHIER,"%s",buffer);
			if(strcmp(bf,"yes")==0||strcmp(tib,"yes")==0)
				{
				//printf("\nListe des fichiers:\n");
				//printf("-------------------------");
				printf("%s",buffer);
				//printf("-------------------------\n");
				}
			taille=taille+n;
			bzero(buffer,256);
			fflush(stdin);
			}
///////////////////////////////////////////////
			fclose(P_FICHIER);if(g!=1)
			printf("transfert complet\n");
			else{
			system("rm init.txt");
			bzero(bf,256);}
			}
			else{
				printf("Le fichier demandé n'existe pas\n");
				}
			do{
			printf("Avez vous encore besoin de nos services yes/no  !!!  :  ");
			scanf("%s",&tb);fflush(stdin);}while((strcmp(tb,"yes")!=0)&&(strcmp(tb,"no")!=0));
			e++;bzero(bf,256);
		}
		while(strcmp(tb,"yes")==0);
printf("Deconnection,merci d'utiliser notre software\n");
close(sock);
}
void preparerAdresse(int argc, char *argv[], struct sockaddr *adresse_serveur){
	struct sockaddr_in *adresse = (struct sockaddr_in *) adresse_serveur;
	adresse->sin_family = AF_INET;

	if (argc <= 1) //on a la possibilté d'entrée un port et ip serveur spécifique
		adresse->sin_addr.s_addr = inet_addr("127.0.0.1");
	else {
		struct hostent *server;
		server = gethostbyname(argv[1]); //Résolution du nom de domaine
		if (server == NULL)
			erreur("DNS");
		bcopy(server->h_addr, &adresse->sin_addr.s_addr, server->h_length);
	}
	if (argc <= 2)
		adresse->sin_port = htons(9999); //PORT par défaut égale à 10240
	else
		adresse->sin_port = htons(atoi(argv[2]));
}
//verififer resultat de la fonction entrée en argument
void verifierResultat(int n, char *fonct){
	switch (n) {
		case -1://La fonction a rencontré une erreur
			erreur(fonct);
			exit(0);	
		case 0: //Il y a eu une déconnexion
			printf("Deconnexion\n");
			exit(0);
	}
}
//verifier erreur
void erreur(char *s){
	perror(s);
	exit(0);
}
//verifier si le fichier exist ou pas
int exist(char *NOM){
	char *rep;
	struct dirent* entree;
	rep = opendir(".");
	while((entree=readdir(rep)) != NULL){
		if (strcmp(entree->d_name,NOM)==0){
			return 1;}
	}
	return 0;
}
int existrep(char *buff){
	char *rep;
	struct dirent* entree;

	if(rep = opendir(buff)!=NULL)return(1);
	else return 0;
}

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (metalicien)