problème socket en c

Version imprimable

bonjour, je travaile sur un programme de socket qui réalise le transfert de fichier:
-L'utilisateur se conecte au serveur en mode non conecté pour choisir le mode de transfert s'il veut continuer en mode non conecté le transfert s'efectue sinon il se deconecte pour reconecter en mode conecter et puis reçevoir le fichier.
-Le serveur gère 5 utilisateurs a la fois avec la fonction fork.

en fait mon problème et comme suite:
dabord dans quand j'execute mon code et je choisie le mode conécté on me donne une erreur de conection,et quand je choisie le mode non conecté le transfert nesetermine jamais.et pourtant les deux programe conecté et non conécté s'exécute a la perfection quant ils sont isolé.:cry:
si quelqu'un pourais m'aider je serais très reconnaisante.
voici mon code:
serveur:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
//COD C SERVEUR DANS DOMAINE INTERNET
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include <sys/wait.h>
#include <stdlib.h>
void conecte(char**);
 
 //*****************variables globales:
 int sockfd,newsockfd,clilen,max=250; 
static struct sockaddr_in loc_addr, cli_addr;
char recvline[256]="",fichier[20],mode;
FILE *fich2;
 
 
 
 
main(int argc, char * argv[])
{//pid_t pid;
 
int i=1,etat,ret_fils,pid;
for(i=1;i<=5;i++)
{
pid=fork();
 
if(pid==0)
{  printf
	("\t\t\t\t********\n\t\t\t\t* FILS *	\n\t\t\t\t********\n");
 
   loc_addr.sin_family=AF_INET;
   loc_addr.sin_addr.s_addr=htonl(INADDR_ANY);
   loc_addr.sin_port=htons(atoi(argv[1]));//ou htons(NUMPORT)
 
   clilen=sizeof(cli_addr);
 //************************************
 
 
 
 
   //*********************mode non conecté
 
 {
if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
		printf("error socket\n");
	else{
		printf("le numéro de port est %s\n",argv[1]);
		unlink(sockfd);
 
		if(bind(sockfd,(struct sockaddr *)&loc_addr,sizeof(loc_addr))<0)
			perror("bind");
		else{
 
			clilen=sizeof(cli_addr);
 
 
 
   		      recvfrom(sockfd,&mode,1,0,(struct sockaddr *)&cli_addr,&clilen);
 
 
   		        //**************************si l'utilisateur souhaite rester en mode non conecté: 
                        if(mode!='g' && mode!='G')
                        {recvfrom(sockfd,&mode,1,0,(struct sockaddr *)&cli_addr,&clilen);
       			//*******************************************************
      			 recvfrom(sockfd,fichier,sizeof(fichier),0,(struct sockaddr *)&cli_addr,&clilen);
 	    		if(fich2=fopen(fichier,"r+"))printf("ouverture de fichier reussi\n");
    			else printf("erreur ouvertur fichier\n");
 
    			printf("debut de transfert de fichier ...\n"); 
       			//*******************************************************
       			//*****************fichier texte:
			if(mode=='t' || mode=='T')
			{
				do{      
 
					fgets(recvline,256,fich2);
					sendto(sockfd,recvline,sizeof(recvline),0,(struct sockaddr *)&cli_addr,clilen);
 
				}while(!feof(fich2));// && !ferror(fich2));
 
				sendto(sockfd,"FIN",sizeof("FIN"),0,(struct sockaddr *)&cli_addr,clilen);
				printf("fin de transfert\n");
			}
    			 //******************fichier binaire
			else 
			{
				do{     	        
					fread(recvline,256,1,fich2);
					sendto(sockfd,recvline,sizeof(recvline),0,(struct sockaddr *)&cli_addr,clilen);
 
				}while(!feof(fich2) && !ferror(fich2));
 
				sendto(sockfd,"FIN",sizeof("FIN"),0,(struct sockaddr *)&cli_addr,clilen);
				printf("fin de transfert\n");
			}
		        //************fin fichier binaire
		        fclose(fich2);
		        close(newsockfd);
                }
 
        }
	}
  if(mode=='s' || mode=='S')
  conecte(argv);
}
 
i++;}
else if(pid==-1){printf ("Le fork a echoue");
      exit(2);}
}
printf("********\n* PERE *\n********\n"); 
      ret_fils = wait (&etat);
 
}
 
 
 
 
//***********************si l'utilisateur souhaite le mode conecté:
void conecte(char **argv)
{	
        loc_addr.sin_family=AF_INET;
        loc_addr.sin_addr.s_addr=htonl(INADDR_ANY);
        loc_addr.sin_port=htons(3333);//ou htons(atoi(argv[1]));
 
clilen=sizeof(cli_addr);
 //************************************
 close(sockfd);//fermeture du mode non conecté
 
        //***********création de socket
	if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
		printf("error socket\n");
          unlink(sockfd);
 
 
 
 
 
	if(bind(sockfd,(struct sockaddr *)&loc_addr,sizeof(loc_addr))<0)
		perror("bind");
 
 
	else{
		listen(sockfd,5);
 
 
 
		newsockfd=accept(sockfd,(struct sockaddr *)&cli_addr,&clilen);
		if (newsockfd<0) {printf("accept error\n");}
		else{
			   printf("connection acceptee\n");
 
 
 
       			//*******************************************************
      			read(newsockfd,fichier,20); 
			    if(fich2=fopen(fichier,"r+"))printf("ouverture de fichier reussi\n");
                            else printf("erreur ouvertur fichier\n");      
    				printf("debut de transfert de fichier ...\n");
		       //*******************************************************
		       //*****************fichier texte:
			if(mode=='t' || mode=='T')
			{
 
				do{      
 
					fgets(recvline,256,fich2);
					write(newsockfd,recvline,sizeof(recvline));
 
				}while(!feof(fich2));
				write(newsockfd,"FIN",sizeof("FIN"));
				fclose(fich2);
			}
		    //******************fichier binaire:
			else
			{
				do{      
 
					fread(recvline,256,1,fich2);
					write(newsockfd,recvline,sizeof(recvline));
 
				}while(!feof(fich2) && !ferror(fich2));
 
				write(newsockfd,"FIN",sizeof("FIN"));
                                printf("fin de transfert\n");
			}
                        fclose(fich2);
		        close(newsockfd);
		}
	}
    }

client:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
//COD C CLIENT DANS DOMAINE INTERNET
 
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include<stdio.h>
#include<string.h>
void conecte(char**);
 
//************************variable globales:
int sockfd,servlen,b=1;
FILE *fich1;
struct sockaddr_in serv_addr;
char sendline[256]="",fichier[20],fichier1[20],c,mode;
//****************************************
 
 
 
 
main(int argc,char** argv)
{
 
 
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=inet_addr(argv[2]);//ou inet_addr(" 127.0.0.1")
serv_addr.sin_port=htons(atoi(argv[1]));
 
 
 
 //*********************mode non conecté:
 
if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
printf("erreur creation de socket\n");
 
else{
      servlen=sizeof(serv_addr);
 
 
      do{printf("si vous voulez transferer en mode conecté taper \"s\";si non taper \"g\":");
                 scanf("%c",&mode);
                 }while(mode!='S' && mode!='s' && mode!='G' && mode!='g');
                 write(sockfd,mode,sizeof(mode));
        sendto(sockfd,&mode,sizeof(mode),0,(struct sockaddr *)&serv_addr,servlen); 
        //**************************si l'utilisateur souhaite rester en mode non conecté: 
        if(mode=='g' || mode=='G')	
       {do{printf("si c'est un fichier texte taper \"t\";si non taper \"b\":");//choix du type de fichier à reçevoir
                 scanf("%c",&mode);
        }while(mode!='t' && mode!='T' && mode!='b' && mode!='B');
        sendto(sockfd,&mode,sizeof(mode),0,(struct sockaddr *)&serv_addr,servlen);//l'envois du type au serveur
        //*******************************************************
        printf("entrer le nom du fichier pour ecriture:");
        scanf("%s",fichier1);
	if(fich1=fopen(fichier1,"a+"))printf("ouverture de fichier reussi\n");
    	else printf("erreur ouvertur fichier\n");
 
        printf("entrer le nom du fichier a recharger:");
        scanf("%s",fichier);
        sendto(sockfd,fichier,sizeof(fichier),0,(struct sockaddr *)&serv_addr,servlen);
 
    	printf("debut de reception de fichier ...\n");      
       //*******************************************************
       //*****************fichier texte:
	if(mode=='t' || mode=='T')
	{       recvfrom(sockfd,sendline,sizeof(sendline),0,(struct sockaddr *)&serv_addr,&servlen);
		while(strcmp(sendline,"FIN")){	
                              fputs(sendline,fich1);
                              recvfrom(sockfd,sendline,sizeof(sendline),0,(struct sockaddr *)&serv_addr,&servlen);
		}
	}
	//******************fichier binaire:
	else
	{        recvfrom(sockfd,sendline,256,0,(struct sockaddr *)&serv_addr,&servlen);   
		 while(strcmp(sendline,"FIN")){
 
				fwrite(sendline,256,1,fich1);
				recvfrom(sockfd,sendline,sizeof(sendline),0,(struct sockaddr *)&serv_addr,&servlen);
		}
	}
 
    fclose(fich1); 
    printf("fin de reception\n");
  }
 
 close(sockfd); 
 
 } 
 if(mode=='s' || mode=='S') conecte(argv);
close(sockfd);
//else printf("option inconue!");
}
 
 
 
 
//***********************si l'utilisateur souhaite le mode conecté:
 
void conecte(char **argv)
{
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=inet_addr(argv[2]);//ou inet_addr(" 127.0.0.1")
serv_addr.sin_port=htons(3333);//htons(atoi(argv[1]));
 
 close(sockfd);//fermeture du mode non conecté
 
//**************reconection en mode conecté:
 
if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
printf("erreur creation de socket\n");
else{
	if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr))<0)
		printf("error connexion\n");
 
 
	else{  do{printf("si c'est un fichier texte taper \"t\";si non taper \"b\":");
                 scanf("%c",&mode);
              }while(mode!='b' && mode!='t' && mode!='T' && mode!='B');     
                 write(sockfd,mode,sizeof(mode));
             //*******************************************************
             printf("entrer le nom du fichier pour ecriture:");
             scanf("%s",fichier1);
             printf("entrer le nom du fichier a recharger:");
             scanf("%s",fichier);
             write(sockfd,fichier,sizeof(fichier));
 if(fich1=fopen(fichier1,"a+"))printf("ouverture de fichier reussi\n");
    else printf("erreur ouvertur fichier\n");
    printf("debut de reception de fichier ...\n");      
       //*******************************************************
       //*****************fichier texte:
if(mode=='t' || mode=='T')
{
                read(sockfd,sendline,sizeof(sendline));
		while(strcmp("FIN",sendline)!=0){
				fputs(sendline,fich1);
                                read(sockfd,sendline,sizeof(sendline));
 
		 }
 
}
	//******************fichier binaire:
else
{                       read(sockfd,sendline,sizeof(sendline));
			while(strcmp(sendline,"FIN")){
					fwrite(sendline,sizeof(sendline),1,fich1);
                                        read(sockfd,sendline,sizeof(sendline));
		              }
 
}
fclose(fich1);
printf("fin de reception\n");
}
 
}
close(sockfd);
}

:!: note:le programme est sous linux
et merci d'avance :D

Citation:

Envoyé par sarlissa

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
//COD C SERVEUR DANS DOMAINE INTERNET
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include <sys/wait.h>
#include <stdlib.h>
void conecte(char**);
 
 //*****************variables globales:
 int sockfd,newsockfd,clilen,max=250; 
static struct sockaddr_in loc_addr, cli_addr;
char recvline[256]="",fichier[20],mode;
FILE *fich2;
 
 
 
 
main(int argc, char * argv[])
{//pid_t pid;
 
int i=1,etat,ret_fils,pid;
for(i=1;i<=5;i++)
{
pid=fork();
 
if(pid==0)
{  printf
	("\t\t\t\t********\n\t\t\t\t* FILS *	\n\t\t\t\t********\n");
 
   loc_addr.sin_family=AF_INET;
   loc_addr.sin_addr.s_addr=htonl(INADDR_ANY);
   loc_addr.sin_port=htons(atoi(argv[1]));//ou htons(NUMPORT)
 
   clilen=sizeof(cli_addr);
 //************************************
 
 
 
 
   //*********************mode non conecté
 
 {
if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
		printf("error socket\n");
	else{
		printf("le numéro de port est %s\n",argv[1]);
		unlink(sockfd);
 
		if(bind(sockfd,(struct sockaddr *)&loc_addr,sizeof(loc_addr))<0)
			perror("bind");
		else{
 
			clilen=sizeof(cli_addr);
 
 
 
   		      recvfrom(sockfd,&mode,1,0,(struct sockaddr *)&cli_addr,&clilen);
 
 
   		        //**************************si l'utilisateur souhaite rester en mode non conecté: 
                        if(mode!='g' && mode!='G')
                        {recvfrom(sockfd,&mode,1,0,(struct sockaddr *)&cli_addr,&clilen);
       			//*******************************************************
      			 recvfrom(sockfd,fichier,sizeof(fichier),0,(struct sockaddr *)&cli_addr,&clilen);
 	    		if(fich2=fopen(fichier,"r+"))printf("ouverture de fichier reussi\n");
    			else printf("erreur ouvertur fichier\n");
 
    			printf("debut de transfert de fichier ...\n"); 
       			//*******************************************************
       			//*****************fichier texte:
			if(mode=='t' || mode=='T')
			{
				do{      
 
					fgets(recvline,256,fich2);
					sendto(sockfd,recvline,sizeof(recvline),0,(struct sockaddr *)&cli_addr,clilen);
 
				}while(!feof(fich2));// && !ferror(fich2));
 
				sendto(sockfd,"FIN",sizeof("FIN"),0,(struct sockaddr *)&cli_addr,clilen);
				printf("fin de transfert\n");
			}
    			 //******************fichier binaire
			else 
			{
				do{     	        
					fread(recvline,256,1,fich2);
					sendto(sockfd,recvline,sizeof(recvline),0,(struct sockaddr *)&cli_addr,clilen);
 
				}while(!feof(fich2) && !ferror(fich2));
 
				sendto(sockfd,"FIN",sizeof("FIN"),0,(struct sockaddr *)&cli_addr,clilen);
				printf("fin de transfert\n");
			}
		        //************fin fichier binaire
		        fclose(fich2);
		        close(newsockfd);
                }
 
        }
	}
  if(mode=='s' || mode=='S')
  conecte(argv);
}
 
i++;}
else if(pid==-1){printf ("Le fork a echoue");
      exit(2);}
}
printf("********\n* PERE *\n********\n"); 
      ret_fils = wait (&etat);
 
}
 
 
 
 
//***********************si l'utilisateur souhaite le mode conecté:
void conecte(char **argv)
{	
        loc_addr.sin_family=AF_INET;
        loc_addr.sin_addr.s_addr=htonl(INADDR_ANY);
        loc_addr.sin_port=htons(3333);//ou htons(atoi(argv[1]));
 
clilen=sizeof(cli_addr);
 //************************************
 close(sockfd);//fermeture du mode non conecté
 
        //***********création de socket
	if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
		printf("error socket\n");
          unlink(sockfd);
 
 
 
 
 
	if(bind(sockfd,(struct sockaddr *)&loc_addr,sizeof(loc_addr))<0)
		perror("bind");
 
 
	else{
		listen(sockfd,5);
 
 
 
		newsockfd=accept(sockfd,(struct sockaddr *)&cli_addr,&clilen);
		if (newsockfd<0) {printf("accept error\n");}
		else{
			   printf("connection acceptee\n");
 
 
 
       			//*******************************************************
      			read(newsockfd,fichier,20); 
			    if(fich2=fopen(fichier,"r+"))printf("ouverture de fichier reussi\n");
                            else printf("erreur ouvertur fichier\n");      
    				printf("debut de transfert de fichier ...\n");
		       //*******************************************************
		       //*****************fichier texte:
			if(mode=='t' || mode=='T')
			{
 
				do{      
 
					fgets(recvline,256,fich2);
					write(newsockfd,recvline,sizeof(recvline));
 
				}while(!feof(fich2));
				write(newsockfd,"FIN",sizeof("FIN"));
				fclose(fich2);
			}
		    //******************fichier binaire:
			else
			{
				do{      
 
					fread(recvline,256,1,fich2);
					write(newsockfd,recvline,sizeof(recvline));
 
				}while(!feof(fich2) && !ferror(fich2));
 
				write(newsockfd,"FIN",sizeof("FIN"));
                                printf("fin de transfert\n");
			}
                        fclose(fich2);
		        close(newsockfd);
		}
	}
    }

client:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
//COD C CLIENT DANS DOMAINE INTERNET
 
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include<stdio.h>
#include<string.h>
void conecte(char**);
 
//************************variable globales:
int sockfd,servlen,b=1;
FILE *fich1;
struct sockaddr_in serv_addr;
char sendline[256]="",fichier[20],fichier1[20],c,mode;
//****************************************
 
 
 
 
main(int argc,char** argv)
{
 
 
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=inet_addr(argv[2]);//ou inet_addr(" 127.0.0.1")
serv_addr.sin_port=htons(atoi(argv[1]));
 
 
 
 //*********************mode non conecté:
 
if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
printf("erreur creation de socket\n");
 
else{
      servlen=sizeof(serv_addr);
 
 
      do{printf("si vous voulez transferer en mode conecté taper \"s\";si non taper \"g\":");
                 scanf("%c",&mode);
                 }while(mode!='S' && mode!='s' && mode!='G' && mode!='g');
                 write(sockfd,mode,sizeof(mode));
        sendto(sockfd,&mode,sizeof(mode),0,(struct sockaddr *)&serv_addr,servlen); 
        //**************************si l'utilisateur souhaite rester en mode non conecté: 
        if(mode=='g' || mode=='G')	
       {do{printf("si c'est un fichier texte taper \"t\";si non taper \"b\":");//choix du type de fichier à reçevoir
                 scanf("%c",&mode);
        }while(mode!='t' && mode!='T' && mode!='b' && mode!='B');
        sendto(sockfd,&mode,sizeof(mode),0,(struct sockaddr *)&serv_addr,servlen);//l'envois du type au serveur
        //*******************************************************
        printf("entrer le nom du fichier pour ecriture:");
        scanf("%s",fichier1);
	if(fich1=fopen(fichier1,"a+"))printf("ouverture de fichier reussi\n");
    	else printf("erreur ouvertur fichier\n");
 
        printf("entrer le nom du fichier a recharger:");
        scanf("%s",fichier);
        sendto(sockfd,fichier,sizeof(fichier),0,(struct sockaddr *)&serv_addr,servlen);
 
    	printf("debut de reception de fichier ...\n");      
       //*******************************************************
       //*****************fichier texte:
	if(mode=='t' || mode=='T')
	{       recvfrom(sockfd,sendline,sizeof(sendline),0,(struct sockaddr *)&serv_addr,&servlen);
		while(strcmp(sendline,"FIN")){	
                              fputs(sendline,fich1);
                              recvfrom(sockfd,sendline,sizeof(sendline),0,(struct sockaddr *)&serv_addr,&servlen);
		}
	}
	//******************fichier binaire:
	else
	{        recvfrom(sockfd,sendline,256,0,(struct sockaddr *)&serv_addr,&servlen);   
		 while(strcmp(sendline,"FIN")){
 
				fwrite(sendline,256,1,fich1);
				recvfrom(sockfd,sendline,sizeof(sendline),0,(struct sockaddr *)&serv_addr,&servlen);
		}
	}
 
    fclose(fich1); 
    printf("fin de reception\n");
  }
 
 close(sockfd); 
 
 } 
 if(mode=='s' || mode=='S') conecte(argv);
close(sockfd);
//else printf("option inconue!");
}
 
 
 
 
//***********************si l'utilisateur souhaite le mode conecté:
 
void conecte(char **argv)
{
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=inet_addr(argv[2]);//ou inet_addr(" 127.0.0.1")
serv_addr.sin_port=htons(3333);//htons(atoi(argv[1]));
 
 close(sockfd);//fermeture du mode non conecté
 
//**************reconection en mode conecté:
 
if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
printf("erreur creation de socket\n");
else{
	if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr))<0)
		printf("error connexion\n");
 
 
	else{  do{printf("si c'est un fichier texte taper \"t\";si non taper \"b\":");
                 scanf("%c",&mode);
              }while(mode!='b' && mode!='t' && mode!='T' && mode!='B');     
                 write(sockfd,mode,sizeof(mode));
             //*******************************************************
             printf("entrer le nom du fichier pour ecriture:");
             scanf("%s",fichier1);
             printf("entrer le nom du fichier a recharger:");
             scanf("%s",fichier);
             write(sockfd,fichier,sizeof(fichier));
 if(fich1=fopen(fichier1,"a+"))printf("ouverture de fichier reussi\n");
    else printf("erreur ouvertur fichier\n");
    printf("debut de reception de fichier ...\n");      
       //*******************************************************
       //*****************fichier texte:
if(mode=='t' || mode=='T')
{
                read(sockfd,sendline,sizeof(sendline));
		while(strcmp("FIN",sendline)!=0){
				fputs(sendline,fich1);
                                read(sockfd,sendline,sizeof(sendline));
 
		 }
 
}
	//******************fichier binaire:
else
{                       read(sockfd,sendline,sizeof(sendline));
			while(strcmp(sendline,"FIN")){
					fwrite(sendline,sizeof(sendline),1,fich1);
                                        read(sockfd,sendline,sizeof(sendline));
		              }
 
}
fclose(fich1);
printf("fin de reception\n");
}
 
}
close(sockfd);
}

:!: note:le programme est sous linux
et merci d'avance :D

Juste une brève remarque: on ne détecte jamais une fin de fichier par feof(). Cette fonction ne fait pas ce que tu crois.
On détecte une fin de fichier en regardant le retour de la fonction qui sert à le lire (NULL pour fgets(), EOF pour fgetc()).
feof() sert juste à indiquer si la lecture s'est arrêtée à cause d'une fin de fichier ou pas. Donc corrige ton code dans ce sens et vois si ça marche.

Accessoirement, tu fais une distinction entre "fichier texte" et "fichier binaire" mais il n'y a aucune différence dans ton code. Apparemment tu ne sais pas pourquoi on fait cette différenciation dans les protocoles déjà établis (style ftp) et t'as voulu faire pareil sans comprendre vraiment. Ben travailler sans comprendre c'est pas la meilleure des choses à faire. Alors on fait cette différence tout simplement parce qu'un fichier texte est différent entre Windows et Linux. Sous Windows, chaque ligne se termine par \t (retour en début de ligne) puis \n (passage à la ligne suivante) comme pour une machine à écrire alors que sous Unix/Linux, il se termine par \n faisant les deux à la fois. Et donc si on transfère un fichier texte, et si le transfert se fait en environnements hétérogènes, alors il faut spécifier la caractéristique texte pour que le protocole se charge de faire la conversion.
En revanche, si on reste dans le même environnement (Unix<->Unix, Windows<->Windows), la spécification est inutile car même transféré en mode binaire (c.a.d. sans conversion), un fichier texte reste intègre une fois de l'autre coté.
Apparemment ton serveur n'est pas sensé tourner en environnements hétérogènes, tu peux éviter la spécificité texte/binaire. Et s'il est fait pour tourner en environnements hétérogènes, alors il te faut assurer la conversion...

merci Sve@r pour ta reponse, au sujet de la distinction du fichier texte du fichier binaire c'est notre prof qui nous a demandé de faire ainsi;sinon tu ma bien éclairci les choses mais il me reste encore des problème dans le programme cela fait deux jour que j'essai de les résoudre sans succès alors j’espère que je trouverai plus d'aide dans ce forum, pour le programme serveur il doit gérer plusieurs clients et je ne sais pas comment faire.
voici les nouveau codes:
code client:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
//COD C CLIENT DANS DOMAINE INTERNET
 
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include<stdio.h>
#include<string.h>
void conecte(char**);
 
//************************variable globales:
int sockfd,servlen,b=1;
FILE *fich1;
struct sockaddr_in serv_addr;
char sendline[256]="",fichier[20],fichier1[20],c,mode;
//****************************************
 
 
 
 
main(int argc,char** argv)
{
 
 
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=inet_addr(argv[2]);//ou inet_addr(" 127.0.0.1")
serv_addr.sin_port=htons(atoi(argv[1]));
 
 
 
 //*********************mode non conecté:
 
if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
printf("erreur creation de socket\n");
 
 
else{bzero(&serv_addr,sizeof(serv_addr));
      servlen=sizeof(serv_addr);
 
 
      do{printf("si vous voulez transferer en mode conecté taper \"s\";si non taper \"g\":");
                 scanf("%c",&mode);
                 }while(mode!='S' && mode!='s' && mode!='G' && mode!='g');
                 //write(sockfd,mode,sizeof(mode));
        sendto(sockfd,&mode,sizeof(mode),0,(struct sockaddr *)&serv_addr,servlen); 
        //**************************si l'utilisateur souhaite rester en mode non conecté: 
        if(mode=='g' || mode=='G')	
       {do{printf("si c'est un fichier texte taper \"t\";si non taper \"b\":");//choix du type de fichier à reçevoir
                 while( (mode=getchar())!='\n' && mode!=EOF );
                 scanf("%c",&mode);
        }while(mode!='t' && mode!='T' && mode!='b' && mode!='B');
        sendto(sockfd,&mode,sizeof(mode),0,(struct sockaddr *)&serv_addr,servlen);//l'envois du type au serveur
        //*******************************************************
        printf("entrer le nom du fichier pour ecriture:");
        scanf("%s",fichier1);
	if(fich1=fopen(fichier1,"a+"))printf("ouverture de fichier reussi\n");
    	else printf("erreur ouvertur fichier\n");
 
        printf("entrer le nom du fichier a recharger:");
        scanf("%s",fichier);
        sendto(sockfd,fichier,sizeof(fichier),0,(struct sockaddr *)&serv_addr,servlen);
 
    	printf("debut de reception de fichier ...\n");      
       //*******************************************************
       //*****************fichier texte:
	if(mode=='t' || mode=='T')
	{       recvfrom(sockfd,sendline,sizeof(sendline),0,(struct sockaddr *)&serv_addr,&servlen);
		while(strcmp(sendline,"FIN")){	
                              fputs(sendline,fich1);
                              recvfrom(sockfd,sendline,sizeof(sendline),0,(struct sockaddr *)&serv_addr,&servlen);
		}
	}
	//******************fichier binaire:
	else
	{        recvfrom(sockfd,sendline,256,0,(struct sockaddr *)&serv_addr,&servlen);   
		 while(strcmp(sendline,"FIN")){
 
				fwrite(sendline,256,1,fich1);
				recvfrom(sockfd,sendline,sizeof(sendline),0,(struct sockaddr *)&serv_addr,&servlen);
		}
	}
 
    fclose(fich1); 
    printf("fin de reception\n");
  }
 
 close(sockfd); 
 
 } 
 if(mode=='s' || mode=='S') conecte(argv);
close(sockfd);
//else printf("option inconue!");
}
 
 
 
 
//***********************si l'utilisateur souhaite le mode conecté:
 
void conecte(char **argv)
{
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=inet_addr(argv[2]);//ou inet_addr(" 127.0.0.1")
serv_addr.sin_port=htons(3333);//htons(atoi(argv[1]));
 
 close(sockfd);//fermeture du mode non conecté
 
 
//**************reconection en mode conecté:
 
if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
printf("erreur creation de socket\n");
else{   bzero(&serv_addr,sizeof(serv_addr));
	if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr))<0)
		printf("error connexion\n");
 
 
	else{     
                 do{printf("si c'est un fichier texte taper \"t\";si non taper \"b\":");
                 while( (mode=getchar())!='\n' && mode!=EOF );
                 mode=getchar();
                 printf("%c\n",mode);
                 }while(mode!='b' && mode!='t' && mode!='T' && mode!='B');     
                 write(sockfd,&mode,sizeof(mode));
             //*******************************************************
             printf("entrer le nom du fichier pour ecriture:");
             scanf("%s",fichier1);
             printf("entrer le nom du fichier a recharger:");
             scanf("%s",fichier);
             write(sockfd,fichier,sizeof(fichier));
 if(fich1=fopen(fichier1,"a+"))printf("ouverture de fichier reussi\n");
    else printf("erreur ouvertur fichier\n");
    printf("debut de reception de fichier ...\n");      
       //*******************************************************
       //*****************fichier texte:
if(mode=='t' || mode=='T')
{
                read(sockfd,sendline,sizeof(sendline));
		while(strcmp("FIN",sendline)!=0){
				fputs(sendline,fich1);
                                read(sockfd,sendline,sizeof(sendline));
 
		 }
 
}
	//******************fichier binaire:
else
{                       read(sockfd,sendline,sizeof(sendline));
			while(strcmp(sendline,"FIN")){
					fwrite(sendline,sizeof(sendline),1,fich1);
                                        read(sockfd,sendline,sizeof(sendline));
		              }
 
}
fclose(fich1);
printf("fin de reception\n");
}
 
}
close(sockfd);
}

programme serveur:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
//COD C SERVEUR DANS DOMAINE INTERNET
#include<stdio.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
void conecte(char**);
 
 //*****************variables globales:
 int sockfd,newsockfd,clilen,max=250; 
static struct sockaddr_in loc_addr, cli_addr;
char recvline[256]="",fichier[20],mode;
FILE *fich2;
 
 
 
 
main(int argc, char * argv[])
{//pid_t pid;
 
int i=1,etat,ret_fils;
 
 
 
 
   loc_addr.sin_family=AF_INET;
   loc_addr.sin_addr.s_addr=htonl(INADDR_ANY);
   loc_addr.sin_port=htons(atoi(argv[1]));//ou htons(NUMPORT)
 
   clilen=sizeof(cli_addr);
 //************************************
 
 
 
 
   //*********************mode non conecté
 
 {
if((sockfd=socket(AF_INET,SOCK_DGRAM,0))<0)
		printf("error socket\n");
	else{
		printf("le numéro de port est %s\n",argv[1]);
		//unlink(loc_addr.sin_port);
                bzero(&loc_addr,sizeof(loc_addr));
 
 
		if(bind(sockfd,(struct sockaddr *)&loc_addr,sizeof(loc_addr))<0)
			perror("bind");
		else{
 
			clilen=sizeof(cli_addr);
 
 
 
   		      recvfrom(sockfd,mode,sizeof(mode),0,(struct sockaddr *)&cli_addr,&clilen);
   		       printf("%c\n",mode);
 
   		        //**************************si l'utilisateur souhaite rester en mode non conecté: 
                        if(mode=='g' || mode=='G')
                        {
                         printf("tarsfere en mode non conecte\n");
                         recvfrom(sockfd,&mode,1,0,(struct sockaddr *)&cli_addr,&clilen);
       			//*******************************************************
                           printf("1\n");
      			 recvfrom(sockfd,fichier,sizeof(fichier),0,(struct sockaddr *)&cli_addr,&clilen);
 	    		if(fich2=fopen(fichier,"r+"))printf("ouverture de fichier reussi\n");
    			else printf("erreur ouvertur fichier\n");
 
    			printf("debut de transfert de fichier ...\n"); 
       			//*******************************************************
       			//*****************fichier texte:
			if(mode=='t' || mode=='T')
			{       printf("tarsfere de fichier texte\n");
				while(fgets(recvline,256,fich2)!=NULL)
                               {      
 
 
					sendto(sockfd,recvline,sizeof(recvline),0,(struct sockaddr *)&cli_addr,clilen);
 
				}
				sendto(sockfd,"FIN",sizeof("FIN"),0,(struct sockaddr *)&cli_addr,clilen);
				printf("fin de transfert\n");
			}
    			 //******************fichier binaire
			else 
			{       printf("tarsfere de fichier binaire\n");
				while(fread(&recvline,256,1,fich2)!=0){      
 
 
 
 
 
					sendto(sockfd,recvline,sizeof(recvline),0,(struct sockaddr *)&cli_addr,clilen);
 
				}
 
				sendto(sockfd,"FIN",sizeof("FIN"),0,(struct sockaddr *)&cli_addr,clilen);
				printf("fin de transfert\n");
			}
		        //************fin fichier binaire
		        fclose(fich2);
		        close(newsockfd);
                }
 
        }
	}
  if(mode=='s' || mode=='S')
  {printf("tarsfere en mode conecte\n");
   conecte(argv);}
}
 
 
 
}
 
 
 
 
//***********************si l'utilisateur souhaite le mode conecté:
void conecte(char **argv)
{int pid,i;	
        loc_addr.sin_family=AF_INET;
        loc_addr.sin_addr.s_addr=htonl(INADDR_ANY);
        loc_addr.sin_port=htons(3333);//ou htons(atoi(argv[1]));
 
clilen=sizeof(cli_addr);
 //************************************
 close(sockfd);//fermeture du mode non conecté
 
         //***********création de socket
	if((sockfd=socket(AF_INET,SOCK_STREAM,0))<0)
		printf("error socket\n");
          //if(unlink(loc_addr.sin_port)<0) printf("error unlink\n");
 
            bzero(&loc_addr,sizeof(loc_addr));
 
 
	if(bind(sockfd,(struct sockaddr *)&loc_addr,sizeof(loc_addr))<0)
		perror("bind");
 
 
	else{
		listen(sockfd,5);
 
 
                for(i=0;i<5;i++){
		newsockfd=accept(sockfd,(struct sockaddr *)&cli_addr,&clilen);
		if (newsockfd<0) {printf("accept error\n");}
		else{      pid=fork();
                           if(pid==0)
			   {printf("connection acceptee\n");
 
                         read(newsockfd,&mode,sizeof(mode));
 
       			//*******************************************************
      			read(newsockfd,fichier,20); 
			    if(fich2=fopen(fichier,"r+"))printf("ouverture de fichier reussi\n");
                            else printf("erreur ouvertur fichier\n");      
    				printf("debut de transfert de fichier ...\n");
		       //*******************************************************
		       //*****************fichier texte:
			if(mode=='t' || mode=='T')
			{ 
                                printf("tarsfere fichier texte\n");
				while(fgets(recvline,256,fich2)!=NULL){      
 
 
					write(newsockfd,recvline,sizeof(recvline));
 
				}
				write(newsockfd,"FIN",sizeof("FIN"));
				printf("fin de transfert du fichier texte\n");
			}
		    //******************fichier binaire:
			else
			{       printf("tarsfere fichier binaire\n");
				while(fread(recvline,256,1,fich2)!=0){      
 
 
					write(newsockfd,recvline,sizeof(recvline));
 
				}
 
				write(newsockfd,"FIN",sizeof("FIN"));
                                printf("fin de transfert du fichier binaire\n");
			}
                        fclose(fich2);}
		        close(newsockfd);}
		}
	}
    }

05/12/2010, 15h09
Sve@r

Très sincèrement ton code est à reprendre depuis le tout début. Il y a des variables globales, le découpage est fait n'importe comment. On retrouve des morceaux de codes entier dupliqués dans le main et dans les autres fonctions (par exemple la partie transfert). Et donc en lisant ton code on peut pas voir l'erreur sans faire une recherche approfondie à base de printf() pour voir si toutes les variables ont la bonne valeur au bon moment. Bref imbitable. D'ailleurs tellement imbitable que tu sais même plus où ça pêche et que tu viens poster ton code sur le forum en espérant que ça nous sautera aux yeux. J'ai l'impression que t'es partie bille en tête et allez, le main() et c'est parti.

Ben non. Il aurait peut-être fallu commencer par réfléchir au découpage. Oui, cette partie n'est pas marrante, oui on a l'impression de perdre du temps mais oui, une fois bien établie on va ensuite 1000x plus vite.
Moi j'aurais bien vu une fonction dédiée au transfert. On lui passe la socket, le nom du fichier et elle se charge de récupérer le contenu et l'écrire. Une autre se chargerait d'envoyer le fichier dans la socket. Une petite particularité dans les paramètres permettrait de dire si on est en mode connecté (appel de send) ou en mode non connecté (appel de sendto). Une autre fonction se chargeant d'ouvrir la socket et la connecter. Une autre se chargeant de ... bref ça permet
1) de tester les fonctions en individuel
2) de mieux pouvoir cibler les erreurs
et donc de faire un meilleur travail

Voici mes conseils valables non seulement pour ce projet mais pour tous les autres projets futurs. Mais bon, peut-être qu'un autre intervenant plus patient aura le courage de copier/coller ton code sur son système et de se charger du debug...

PS: évite le scanf() car c'est source de nombreux problèmes. Surtout un scanf qui n'est pas au format "%s" (exemple scanf("%c") car quand tu tapes ta lettre (exemple b), tu tapes 'b' + <enter>. Et le scanf récupère le b et laisse le <enter> dans le buffer clavier. Et à la saisie suivante, crash

Solution de base pour une saisie sécurisée
1) tu crées une variable de taille suffisante pour la majorité des cas (style char ligne[1024])
2) tu fais un fgets(ligne, 1024, stdin) => ça te remplit la variable de tout ce qui est tapé jusqu'au <enter> => le buffer clavier est alors propre et clean. Eventuellement en cas de projet vraiment critique, tu peux rajouter un while (fgetc(stdin) != EOF) pour être sûr que le clavier soit vraiment vidé (le fgets ayant bloqué la saisie à 1023 caractères pour éviter le débordement)
3) tu traites la variable à base de sscanf() => sscanf(ligne, "%c", &lettre)
Ca te récupère l'élément que tu veux et, en plus, ça t'indique le nombre d'éléments correctement récupérés => permet donc de détecter les saisies incorrectes

Ceci peut déjà peut-être faire l'objet d'une première fonction de travail...