Application de transfert de fichiers socket client serveur unix c

Soyez le premier à donner votre avis sur cette source.

Snippet vu 23 696 fois - Téléchargée 21 fois

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

Ajouter un commentaire

Commentaires

jerome357
Messages postés
2
Date d'inscription
mardi 30 décembre 2008
Statut
Membre
Dernière intervention
14 janvier 2009
-
Merci a vous pour cette source .
J'ai juste un problème pour trouver <fcnt1.h>,Pourriez vous m'aider s'il vous plait ?
bibarus
Messages postés
1
Date d'inscription
jeudi 25 mars 2010
Statut
Membre
Dernière intervention
28 mars 2010
-
merci pour votre code source,
publiée déjà il y a trois ans, mais il est tjrs utile.

<>
ayoubad
Messages postés
3
Date d'inscription
lundi 16 mars 2009
Statut
Membre
Dernière intervention
14 juin 2010
-
bonjour
merci pour le code
est ce que je peux avoir le client qui envoi aux serveur?
faddou84
Messages postés
3
Date d'inscription
lundi 7 mars 2011
Statut
Membre
Dernière intervention
29 avril 2011
-
bonjour,
Bonjour,

Je souhaite faire un réception et un transfert des fichiers (donnes) entre le serveur UNIX et un autre pc sous UNIX.
je veux faire une connexion téléphonique entre le serveur et l'autre pc avec login:root et la connexion par le numéro de téléphone et je veux une code bien déterminé avec des commandes unix pour que je puisse faire une réception des fichiers compressés et au niveau de mon serveur et je les décompresse et je fait les distrubué localement.
2) la deuxieme tache est concerne une code sources par des commandes unix pour faire le transfert des donnes de mon serveur aux autre pc a distances.

urgent svp
Merci d'avance pour ceux qui me répondent.

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.