Problème de mémoire

Version imprimable

Problème de mémoire

bonjour,
quelqu'un aurait t'il connaissance de cete erreur bien embetante que j'obtiens en executant mon projet de c sous cygwin :

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
 
Exception: STATUS_ACCESS_VIOLATION at eip=610DEBB4
eax=00000030 ebx=0040319D ecx=0040319F edx=6116C421 esi=611021A0 edi=0040319F
ebp=0022CC18 esp=0022CC0C program=C:\cygwin\home\Marc\PR301\Projet\central.exe, pid 2656, thread main
cs=001B ds=0023 es=0023 fs=003B gs=0000 ss=0023
Stack trace:
Frame     Function  Args
0022CC18  610DEBB4  (0040319F, 6116C420, 00000000, 00000000)
0022CC38  610DEA65  (0040319D, 6116C420, 004031C8, 77DCC55A)
0022CCA8  0040157F  (00404030, 00000000, 00000001, 00401715)
0022CCE8  00401783  (00000004, 6116B7D8, 00660090, 0022CC70)
0022CD98  61006198  (00000000, 0022CDD0, 61005510, 0022CDD0)
61005510  61004416  (0000009C, A02404C7, E8611021, FFFFFF48)
     13 [main] central 2656 _cygtls::handle_exceptions: Error while dumping state (probably corrupted stack)
Exception: STATUS_ACCESS_VIOLATION at eip=610DEBB4
eax=00000030 ebx=0040319D ecx=0040319F edx=6116C421 esi=611021A0 edi=0040319F
ebp=0022CC18 esp=0022CC0C program=C:\cygwin\home\Marc\PR301\Projet\central.exe, pid 3768, thread main
cs=001B ds=0023 es=0023 fs=003B gs=0000 ss=0023
Stack trace:
Frame     Function  Args
0022CC18  610DEBB4  (0040319F, 6116C420, 00000000, 00000000)
0022CC38  610DEA65  (0040319D, 6116C420, 004031C8, 77DCC55A)
0022CCA8  0040157F  (00404030, 00000000, 00000001, 00401715)
0022CCE8  00401783  (00000004, 6116B7D8, 00660090, 0022CC70)
0022CD98  61006198  (00000000, 0022CDD0, 61005510, 0022CDD0)
61005510  61004416  (0000009C, A02404C7, E8611021, FFFFFF48)
    407 [main] central 3768 _cygtls::handle_exceptions: Error while dumping state (probably corrupted stack)

je l'ai mise en code pour ne pas qu'elle prenne trop de place. J'ai également l'apparition d'un fichier .exe.stackdump je pense que c'est lié.
Si quelqu'un peut m'aider je prend volontiers 8O

02/02/2008, 12h57
Melem

Il y a un Access Violation à EIP=610DEBB4, le problème vient de ta fonction main. Donc nous montrer ton code pourrait peut-être nous faire avancer ... Apparament tu as un de débordement de tampon.

OK bah voila le code de mon main de ma fonction qui semble planter et en dessous le code du telephone pa rlequel je recouvre le processus

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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <pthread.h>
#include <stdlib.h>
#include <semaphore.h>
#include "../chaine/message.h"
 
#define L 1
#define E 0
 
int central2igE,ig2centralL ;
char * num_central ;
sem_t test;
int NB_Tel = 2;
 
typedef struct Tablerout Tablerout ;
struct Tablerout
{
 char * num_tel ;
 int tel2centralL ;
 int central2telE ;
};
Tablerout rout[2] ;
 
 
int find_pipedesc(char * destinataire) ;
void creation_tel() ;
void * reception_from_ig() ;
void * reception_sms() ;
void routage(char * message) ;
 
 
 
 
/* fonction de traitement du message en fonction du numéro de téléphone*/
void routage(char * message)
{
 int desc ;
 char * sms;
 sms = message ;
 char * emeteur ;
 emeteur = (char *)malloc(10 * sizeof(char ));
 char * destinataire ;
 destinataire = (char * ) malloc(10* sizeof(char )) ;
 char * commande ;
 commande = (char *) malloc(6 * sizeof(char )) ;
 char * identifiant ;
 identifiant = (char *) malloc(4 * sizeof(char )) ;
 char * message1 ;
 message1 = (char *) malloc(225*sizeof(char )) ;
 
 printf(" ----------- routage du central -------------- \n" ) ;
 if(decoupe(sms,emeteur,destinataire,commande,identifiant,message1) != 0 )
 {
 printf(" Erreur de découpe du message \n" ) ;
 exit(1) ;
 }
 printf(" destinataire : %s\n", destinataire) ; 
 
  //si le destinataire appartient à cet opérateur on transmet au téléphone sinon on transmet au réseau intergalactique 
 
 if(destinataire[2] == num_central[0]  && destinataire[3] == num_central[1]) 
 {
  int indice = find_pipedesc(destinataire) ;
  desc = rout[indice].central2telE ;
 }
 else
{
 desc = central2igE ;
}
 
 write(desc , sms , strlen(sms)) ;
 printf(" sms transmis par le central \n" ) ;
 free(sms) ;
 free(emeteur) ;
 free(destinataire) ;
 free(commande) ;
 free(identifiant) ;
 free(message1) ;
 }    
 
/* fonction permettant de lire le pipe depuis un tel */
void * reception_sms()
{
 int i = 0 ;
     while(1)
{    
 
     int tel2central ;
     if((i %2) == 0) tel2central = rout[0].tel2centralL ;
     else tel2central = rout[1].tel2centralL ;
     sem_wait(&test) ;
     printf("-------------central from tel----------------\n") ;
     char * lu ;
     lu = (char * ) malloc(255 * sizeof(char )) ;
     read(tel2central,lu,255) ;
 
 
     printf(" message recu par le central %s  \n",lu) ;
     printf(" Etape de reception du sms par le central réussi \n") ;
     routage(lu) ;
     i ++ ;
     sem_post(&test) ;
}
     return NULL ;
}
 
 
void * reception_from_ig()
{
     while(1)
{    
     sem_wait(&test) ;
     printf("-------------central from ig----------------\n") ;
     char * lu ;
     lu = (char * ) malloc(255 * sizeof(char )) ;
     read(ig2centralL,lu,255) ;
     printf(" message recu par le central %s  \n",lu) ;
     printf(" Etape de reception du sms par le central réussi \n") ;
     routage(lu) ;
     sem_post(&test) ;
}
     return NULL ;
}
 
void creation_tel()
{
int central2tel[2] ;
int tel2central[2] ;
 
char * descE, * descL ;
 
 
char * desc1;
desc1 = (char *) malloc ( 2*sizeof(char));
sprintf(desc1, "%d", tel2central[E]);
 
char * desc2;
desc2 = (char *) malloc ( 2*sizeof(char));
sprintf(desc2, "%d", central2tel[L]);
 
int central2tel2[2] ;
int tel2central2[2] ;
 
char * desc3;
desc3 = (char *) malloc ( 2*sizeof(char));
sprintf(desc3, "%d", tel2central[L]);
 
char * desc4;
desc4 = (char *) malloc ( 2*sizeof(char));
sprintf(desc4, "%d", tel2central[E]);
 
if (pipe(central2tel) == -1) 
{
perror(" erreur de création du pipe") ;
exit(-1) ;
}
 
if (pipe(tel2central) == -1) 
{
perror(" erreur de création du pipe") ;
exit(-1) ;
}
if (pipe(central2tel2) == -1) 
{
perror(" erreur de création du pipe") ;
exit(-1) ;
}
 
if (pipe(tel2central2) == -1) 
{
perror(" erreur de création du pipe") ;
exit(-1) ;
}
 
char * test ;
test = strcat("06",num_central) ;
rout[0].num_tel = strcat(test,"0301") ;
rout[1].num_tel = strcat(test,"0302") ;
 
rout[0].tel2centralL = tel2central[L] ;
rout[0].central2telE = central2tel[E] ;
rout[1].tel2centralL = tel2central2[L] ;
rout[1].central2telE = central2tel2[E] ;
 
int i = 0 ;
for( i = 0 ; i < NB_Tel ; i++ )
{
 if(i == 0)
{
 descL = desc2 ;
 descE = desc1 ;
}
else
{
descE = desc4 ;
descL = desc3 ;
}
 
char * telnum ;
telnum = calloc(10, 10 *sizeof(char)) ;
switch (fork())
{
case -1 : perror("erreur de forkage \n") ;
	  exit(-1) ;
 
case 1 : //execlp("xterm","xterm","-e", "tel.exe",descE,descL,telnum,NULL);
	  execlp( "./tel.exe","./tel.exe",descE,descL,telnum,NULL);
default : break ;
}
}
}
 
int find_pipedesc(char * destinataire)
{
 int i = 0 ;
 for(i = 0; i<NB_Tel ; i++)
{
 if(strcmp(destinataire,rout[i].num_tel) == 0)
 return i ;
}
return 0 ;
}
 
 
 
int main(int argc, char ** argv)
{
 int desc1,desc2;
 pthread_t t1,t2 ;
 desc1 = atoi(argv[1]) ;
 desc2 = atoi(argv[2]) ; 
 num_central = argv[3] ; 
 printf(" le numero du central est %s \n",num_central) ;
 sem_init(&test,0,2);
 creation_tel() ;
 pthread_create(&t1, NULL, &reception_sms, NULL) ;
 pthread_create(&t2, NULL, &reception_from_ig, NULL) ;
 pthread_join(t1,NULL) ;
 pthread_join(t2,NULL) ;
 return 0;
}

et le téléphone

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
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>
#include <pthread.h>
#include "../creation_sms.h"
#include "../chaine/message.h"
char * num_tel ;
 
int descE ,descL ;
 
/* fonction d'envoi du sms au central via un pipe */
void envoi(char * sms) 
{
size_t longueur ;
longueur =  strlen(sms) ;
printf(" longueur : %d \n" ,longueur) ;
write(descE , sms, longueur+1) ;
printf(" fin de l'envoi du sms \n") ;
}
 
/* fonction de création d'un sms */
void * ecriture_sms()
{   
while(1) 
{
char * sms ;
printf("ecriture \n") ;
// sms =  malloc ( 255*sizeof( char ));  
sms = creation_sms(num_tel,1) ;
printf(" le message est : %s \n",sms) ;
envoi(sms) ;
sleep(30) ;
 
}
return NULL ;
}
 
 
 
/* fonction de reception d'un sms présent sur le central via un pipe */
void * reception_sms()
{ 
while(1)
{
 char * sms ;
 sms =  malloc(255 * sizeof(char) ) ;
 char * emeteur ;
 emeteur = (char *)malloc(10 * sizeof(char ));
 char * destinataire ;
 destinataire = (char * ) malloc(10* sizeof(char )) ;
 char * commande ;
 commande = (char *) malloc(6 * sizeof(char )) ;
 char * identifiant ;
 identifiant = (char *) malloc(4 * sizeof(char )) ;
 char * message1 ;
 message1 = (char *) malloc(225*sizeof(char )) ;
 
 char * accuse;
 accuse = malloc(255 * sizeof(char)) ;
 
 printf(" -------------------reception------------ \n") ;
 
 
 read(descL, sms, 255) ;
 printf( " nouveau message : %s \n" , sms) ;
 printf(" --------------------fin de la reception -------------\n") ; 
 
 if(decoupe(sms,emeteur,destinataire,commande,identifiant,message1) != 0 )
 {
 printf(" Erreur de découpe du message \n" ) ;
 exit(1) ;
 }
 if(strcmp(commande, "SMS") == 0)
 {
 accuse = creation_accuse(sms) ;
 envoi(accuse) ;
 }
 
 free(sms);
 free(emeteur) ;
 free(destinataire) ;
 free(commande) ;
 free(identifiant) ;
 free(message1) ;
} 
 return NULL ;
}
 
int main(int argc, char ** argv)
{
 pthread_t  t1,t2 ;
 descE = atoi(argv[1]) ;
 descL = atoi(argv[2]) ;
 num_tel = argv[3] ;
 
 pthread_create(&t1, NULL, &ecriture_sms,NULL) ;
 pthread_create(&t2, NULL, &reception_sms,NULL) ;
 pthread_join(t1,NULL) ;
 pthread_join(t2,NULL) ;
 
 return 0 ;
}

02/02/2008, 13h14
Melem

Donc t'as saisi tout ce code avant de faire un premier test? T'as pas fait des tests unitaires? Tu ne peux pas situer à partir de quel moment tu as rencontré ce problème?
02/02/2008, 13h18
Jonkile

Bah j'avais aucun problème d'exécution quand je ne créais qu'un telephone et un serveur central mais depuis que je fais ma boucle de fork il a pas l'air d'adorer. En même temps j'ai rajouté une autre grosse partie qui est (sensé) être un serveur de routage. Ce serveur appelé intergalactique par le prof ,ig dans mon code crées mes serveurs centraux à l'aide du même genre de boucle et il ne semble y avoir aucun problème je pense que mon erreur vient de la fonction creation_tel mais je n'arrive pas à toruver où ni même pourquoi. Petite précision supplémentaire mon code téléphone n'a pas évolué d'une ligne depuis la dernière execution concluante.
02/02/2008, 16h42
Jonkile

Le plus bizarre c'est qu'apparemment sous un linux de vmware ça passe nickel...je pige pas la
02/02/2008, 17h54
souviron34

erreur de mémoire => comportement aléatoire....
02/02/2008, 20h40
Emmanuel Delahaye

Citation:

Envoyé par Jonkile

OK bah voila le code de mon main de ma fonction qui semble planter et en dessous le code du telephone pa rlequel je recouvre le processus

Ce code est incomplet et ne compile pas. Il y a 2 applications ?
03/02/2008, 00h37
Jonkile

nan il est juste incomplet ya plein de fichiers mais le reste fonctionne sinon

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 /* fonction de création d'un sms */ void * ecriture_sms() { while(1) { char * sms ; printf("ecriture \n") ; // sms = malloc ( 255*sizeof( char )); sms = creation_sms(num_tel,1) ; printf(" le message est : %s \n",sms) ; envoi(sms) ; sleep(30) ; } return NULL ; }
*Si la fonction creation_sms (non présentée) alloue de la mémoire pour contenir le message, il faut la libérer après l'envoi.

*Si la fonction creation_sms n'alloue pas de la mémoire pour contenir le message, tu travailles avec un pointeur non initialisé.

Ce serait bien de prévoir une condition de sortie.

Il faudrait tester les retours des fonctions d'allocation et des write.

Si j'ai bien tout suivi, tu passes en argument d'un programme des pointeurs sur une zone mémoire d'un autre programme. C'est obligé que ça plante.
Pour partager de la mémoire entre plusieurs processus, il faut utiliser de la mémoire partagée.

Si tu veut un peu plus d'aide, poste l'intégralité du code.

Bonne continuation.

bon et bien alors voilà le code qu'il manque

creation_sms.c

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
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "chaine/alea.h"
#include "chaine/chaine.h"
#include "chaine/message.h"
 
 
/* fonction de lecture d'un numéro de tel au hasard dans un fichier inspiré d'une fonction créée par M Miroux */
char * creation_sms(char * emeteur,int pote)
{
 
/* Récuperation d'un numéro de téléphone au hasard */
	//on crée un nombre aléatoire compris entre 0 et 20
	aleainit() ;
	int aleatoire = alea(0,20) ;
	//printf("Nombre aleatoire : %d\n", aleatoire);
 
/* On ouvre le fichier texte et on récupère un numéro de téléphone */
 
	// ouverture du fichier ou se trouve les numéros de téléphone, en lecture seulement
	FILE * fd ;
	fd = fopen("numtel.txt", "r");
	if (fd == NULL) printf("Erreur d'ouverture du fichier ou fichier non existant \n");//erreur d'ouverture
        char * destinataire ;
	destinataire = (char * ) malloc(10 * sizeof(char)) ;
	int i = 1 ;
 	rewind(fd);
	while (i < (aleatoire*2))
	{
 
		// lecture du aléatoirième numéro de tel du fichier 
		fgets((destinataire) , 11, fd) ;
		i ++ ;
        }
     if (destinataire == NULL) printf(" une erreur de lecture est survenue \n") ;
 
/* création du SMS à envoyer */		
//on crée un message de taille aléatoire entre 0 et 160 caractères 
int lgr_message = alea(1,16) ; 
// printf(" la longueur du SMS est de : %d \n",lgr_message) ;
char * message1 = (char *) chaine(lgr_message) ; 
 
//affichage du message et du numéro de tél du destinataire
printf( " numéro du destinataire : %s \n", destinataire) ;
printf( " message : %s \n ", message1 ) ;
/* formatage du message pour envoi vers le serveur central */
char * identifiant = "1234" ; //(char*)alea(0 , 5000) ; 
char * type; 
if (pote == 1) type = "SMS" ;
else type = "ACCUSE" ;
char * sms1 = (char * ) message(emeteur , destinataire, type, identifiant, message1) ;	
// affichage du SMS
printf("%s \n", sms1) ;	
fclose(fd) ;
return sms1 ; 		
}
 
char * creation_accuse(char * message2)
{
 char * accuse ;
 
 
 char * emeteur ;
 emeteur = malloc(10 * sizeof(char)) ;
 
 char * destinataire ;
 destinataire = malloc(10 * sizeof(char)) ;
 
 char * type ;
 type = malloc(6*sizeof(char));
 
 char * id ;
 id = malloc(4* sizeof(char)) ;
 
 char * message1 ;
 message1 = malloc(160 * sizeof(char)) ;
 
 if(decoupe(message2,destinataire,emeteur,type,id,message1) != 0 )
 {
 printf(" Erreur de découpe du message \n" ) ;
 exit(1) ;
 }
 
 char * type2 = "ACCUSE" ;
 char * message3 = "RECU" ;
 
 accuse = message(emeteur, destinataire,type2,id,message3) ;
 
 free(emeteur) ;
 free(destinataire) ;
 free(type) ;
 free(id) ;
 free(message1) ;
 
 return accuse ;
 
}

creation_sms.h

Code:

1
2
char * creation_sms(char * emeteur,int pote);
char * creation_accuse(char * message2) ;

intergalactique.c

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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
/* reseau intergalactique */
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <semaphore.h>
#include <pthread.h>
#include <sys/types.h>
#include <stdlib.h>
#include "../chaine/message.h"
 
#define L 1
#define E 0
 
sem_t bloc ;
char * descbleu = "01" ;
char * descbeton = "02" ;
char * descelle = "03" ;
int descbleuL,descbleuE ;
int descbetonL,descbetonE ;
int descElleL, descElleE ;
 
void * lecture_bleu() ;
void * lecture_beton() ;
void * lecture_Elle() ;
void routage(char * sms) ;
void creation() ;
 
 
void * lecture_bleu()
{
 while(1)
{
 char * sms ;
 sms =  calloc(255,255 * sizeof(char) ) ;
 if(read(descbleuL,sms,255) !=0) 
{
 sem_wait(&bloc) ;
 routage(sms) ; 
 sem_post(&bloc) ;
}
} 
 return NULL ;
}
void * lecture_beton()
{
 while(1)
{
 char * sms ;
 sms =  calloc(255,255 * sizeof(char) ) ;
  if(read(descbleuL,sms,255) !=0) 
{
 sem_wait(&bloc) ;
 routage(sms) ; 
 sem_post(&bloc) ;
} 
}
 return NULL ;
}
void * lecture_Elle()
{
 while(1)
{
 char * sms ;
 sms =  calloc(255,255 * sizeof(char) ) ;
  if(read(descbleuL,sms,255) !=0) 
{
 sem_wait(&bloc) ;
 routage(sms) ; 
 sem_post(&bloc) ;
} 
}
 return NULL ;
}
 
/* fonction de routage des sms vers les serveurs centraux appropriés */
void routage(char * sms)
{
 char * emeteur ;
 emeteur = (char *)malloc(10 * sizeof(char ));
 
 char * destinataire ;
 destinataire = (char * ) malloc(10* sizeof(char )) ;
 
 char * commande ;
 commande = (char *) malloc(6 * sizeof(char )) ;
 
 char * identifiant ;
 identifiant = (char *) malloc(4 * sizeof(char )) ;
 
 char * message1 ;
 message1 = (char *) malloc(225*sizeof(char )) ;
 
 int desc ;
 
read(desc,sms,255) ;
 if(decoupe(sms,emeteur,destinataire,commande,identifiant,message1) != 0 )
 printf("Erreur de découpe du message \n" ) ;
 
 
// on route vers le serveur central correspondant au numéro du destinataire
 if( destinataire[2] == '0') 
{
 switch (destinataire[3])
 { 
 case '1' : desc = descbleuE ;
 case '2' : desc = descbetonE ;
 case '3' : desc = descElleE ;
 default : printf("le serveur de destination n'existe pas ! \n") ;  
 }
}
 else printf("le serveur de destination n'existe pas ! \n") ;
 
 write(desc , sms , strlen(sms)) ;
}
 
 
void creation()
{
int pid ;
int ig2beton[2] ;       
int ig2bleu[2] ;
int ig2Elle[2] ;
int beton2ig[2] ;
int Elle2ig[2] ;
int bleu2ig[2] ;
char *  descL, * descE ;
char * num_serv ;
 
// on teste qu'il n'y ait pas d'erreur à la création des pipes
if (pipe(ig2beton) == -1) 
{
perror(" erreur de création du pipe") ;
exit(-1) ;
}
if (pipe(ig2bleu) == -1) 
{
perror(" erreur de création du pipe") ;
exit(-1) ;
}
if (pipe(ig2Elle) == -1) 
{
perror(" erreur de création du pipe") ;
exit(-1) ;
}
if (pipe(beton2ig) == -1) 
{
perror(" erreur de création du pipe") ;
exit(-1) ;
}
if (pipe(Elle2ig) == -1) 
{
perror(" erreur de création du pipe") ;
exit(-1) ;
}
if (pipe(bleu2ig) == -1) 
{
perror(" erreur de création du pipe") ;
exit(-1) ;
}
 
descbleuL = bleu2ig[L] ;
descbetonL = beton2ig[L] ;
descElleL = Elle2ig[L] ;
descbleuE = ig2bleu[E] ;
descbetonE = ig2beton[E] ;
descElleE = ig2Elle[E] ;
 
char * desc1;
desc1 = (char *) malloc ( 2*sizeof(char));
sprintf(desc1, "%d", ig2bleu[L]);
 
char * desc2;
desc2 = (char *) malloc ( 2*sizeof(char));
sprintf(desc2, "%d", ig2beton[L]);
 
char * desc3;
desc3 = (char *) malloc ( 2*sizeof(char));
sprintf(desc3, "%d", ig2Elle[L]);
 
char * desc4;
desc4 = (char *) malloc ( 2*sizeof(char));
sprintf(desc4,"%d",bleu2ig[E]);
 
char * desc5;
desc5 = (char *) malloc ( 2*sizeof(char));
sprintf(desc5, "%d", beton2ig[E]);
 
char * desc6;
desc6 = (char *) malloc ( 2*sizeof(char));
sprintf(desc6, "%d", Elle2ig[E]);
 
int i = 0 ;
for(i = 0 ; i < 3 ; i++)
{
if (i ==0) 
{
num_serv = "01" ; //serveur bleu
descL = desc1 ;
descE = desc4 ;
}
else 
{
if(i == 1) 
{
num_serv = "02" ; //serveur beton
descL  = desc2 ;
descE =  desc5 ;
}
else
{
num_serv = "03" ;//serveur Elle
descL = desc3 ;
descE = desc6 ;
}
}
switch(pid = fork())
{
case -1: //le fork a échoué
perror("erreur de creation d'un processus fils");
exit(-1);
 
case 0: //code du fils	
//execlp("xterm","xterm","-e","central.exe",descL,descE,num_serv,NULL);
execlp("./central.exe","./central.exe",descL,descE,num_serv,NULL);
 
 
default://code du père	
 
break;
 
}	
}
}	
 
int main(int argc, char ** argv) 
{
 
 printf("----------------- reseau intergalactique -------- \n") ;
 sem_init(&bloc,0,1) ;
 creation() ;
 pthread_t t1,t2,t3 ;
 pthread_create(&t1,NULL,&lecture_bleu,NULL) ;
 pthread_create(&t2,NULL,&lecture_beton,NULL) ;
 pthread_create(&t3,NULL,&lecture_Elle,NULL) ;
 pthread_join(t1,NULL) ;
 pthread_join(t2,NULL) ;
 pthread_join(t3,NULL) ;
 
 return 1 ;
}

message.c

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
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
/**
 * Decoupe du message 
 * Retourne 0 si il n'y a pas eu de problème
 * Retourne 1 si il y a eu un problème
 * ATTENTION:
 *   Les variables emeteur, destinataire, commande, identifiant
 *   et sms doivent être allouées avant l'appel à decoupe
 */
int decoupe(char *message,      /* Source a découper */
	    char *emeteur,      /* Emeteur du message */
	    char *destinataire, /* Recepteur du message */
	    char *commande,     /* Commande du message */
	    char *identifiant,  /* Identifiant unique sur le telephone */
	    char *sms           /* Le sms lui-même */
	    )
{
  int nb=sscanf(message, "|%[^|]|%[^|]|%[^|]|%[^|]|%[^\n]\n", 
	 emeteur, destinataire, commande, identifiant, sms);
  if (nb == 5)
      return 0;
  else 
    return 1;
}
 
/** 
 * Construction du message
 * Retourne le message construit suivant le protocole
 * a partir des arguments
 * Le message est alloué dans la fonction
 */
char* message(char *emeteur, char *destinataire, char *commande, 
	      char * identifiant, char *sms)
{
  int longueur = strlen(emeteur) + strlen(destinataire) + strlen(commande) 
    + strlen(identifiant) + strlen(sms) + 1 + 5 + 1;
  char *mess = calloc(longueur,sizeof(char));
 
  if (mess == NULL)
    return NULL;
 
  sprintf(mess, "|%s|%s|%s|%s|%s\n", emeteur, destinataire, commande,identifiant, sms);
  return mess;
}

message.h

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
#ifndef _MESSAGEH_
#define _MESSAGEH_
 
/**
 * Decoupe du message 
 * Retourne 1 si il n'y a pas eu de problème
 * Retourne 0 si il y a eu un problème
 * ATTENTION:
 *   Les variables emeteur, destinataire, commande, identifiant
 *   et sms doivent être allouées avant l'appel à decoupe
 */
int decoupe(char *message,      /* Source a découper */
	    char *emeteur,      /* Emeteur du message */
	    char *destinataire, /* Recepteur du message */
	    char *commande,     /* Commande du message */
	    char * identifiant, /* Identifiant unique sur le telephone */
	    char *sms           /* Le sms lui-même */
	    );
 
/** 
 * Construction du message
 * Retourne le message construit suivant le protocole
 * a partir des arguments
 * Le message est alloué dans la fonction
 */
char* message(char *emeteur, char *destinataire, char *commande, 
	      char * identifiant, char *sms);
 
#endif // _MESSAGEH_

alea.c

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
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
 
#include "alea.h"
 
/**
 * Initialisation du générateur aléatoire
 */
void aleainit()
{
  srand( (unsigned)time( NULL ) + getpid() );
}
 
/**
 * Retourne un nombre aléatoire en min et max (bornes comprises)
 */
int alea(int min, int max)
{
  int lgr;
 
  lgr = max-min+1;
  return (int)((double)rand()/RAND_MAX*lgr+min);
}

alea.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef _ALEAH_
#define _ALEAH_
 
/**
 * Initialisation du générateur aléatoire
 */
void aleainit();
 
/**
 * Retourne un nombre aléatoire en min et max (bornes comprises)
 */
int alea(int min, int max);
 
#endif // _ALEAH_

chaine.c

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
#include <stdlib.h>
 
#include "alea.h"
#include "chaine.h"
 
/** 
 * Retourne une chaine aléatoire de longueur lgr
 * Note: la taille de la mémoire réservée est de lgr+1
 */
char* chaine(int lgr) 
{
  int i;
  char *chaine;
 
  chaine = calloc((lgr+1),sizeof(char));
  for (i=0; i<lgr; i++) {
    chaine[i] = (char)(alea('A', 'Z'));
  }
  chaine[lgr] ='\0';
 
  return chaine;
}
 
/** 
 * Retourne un nombre, i.e. une chaine de chiffres aléatoires de longueur lgr
 * Note: la taille de la mémoire réservée est de lgr+1
 */
char* nombre(int lgr) 
{
  int i;
  char *chaine;
 
  chaine = calloc((lgr+1),sizeof(char));
  for (i=0; i<lgr; i++) {
    chaine[i] = (char)(alea('0', '9'));
  }
  chaine[lgr] ='\0';
 
  return chaine;
}

et pour finir chaine.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#ifndef _CHAINEH_
#define _CHAINEH_
 
/** 
 * Retourne une chaine aléatoire de longueur lgr
 * Note: la taille de la mémoire réservée est de lgr+1
 */
char *chaine(int lgr);
 
/** 
 * Retourne un nombre, i.e. une chaine de chiffres aléatoires de longueur lgr
 * Note: la taille de la mémoire réservée est de lgr+1
 */
char *nombre(int lgr);
 
#endif // _CHAINEH_

Voila maintenant tout mon code est la, à savoir (ça se voit normalement) que ce n'est pas moi qui est codé chaine,message et alea .
Perso moi j'ai toujours pas toruvé mon problème....:s

intergalactique.c
Code:

1 2 3 int desc ; read(desc,sms,255) ;
? doit manquer une initialisation.
Code:

1 2 3 4 5 if(decoupe(sms,emeteur,destinataire,commande,identifiant,message1) != 0 ) printf("Erreur de découpe du message \n" ) ; // on route vers le serveur central correspondant au numéro du destinataire if( destinataire[2] == '0')
A plusieurs endroit dans le code, il y a des tests du style
Si erreur alors
printf("erreur");

et la fonction continue tranquillement.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 FILE * fd ; fd = fopen("numtel.txt", "r"); if (fd == NULL) printf("Erreur d'ouverture du fichier ou fichier non existant \n");//erreur d'ouverture char * destinataire ; destinataire = (char * ) malloc(10 * sizeof(char)) ; int i = 1 ; rewind(fd); while (i < (aleatoire*2)) { // lecture du aléatoirième numéro de tel du fichier fgets((destinataire) , 11, fd) ; i ++ ; }
Faut penser au zéro terminal des chaines de caractères lors du malloc().
Le fichier contient-il assez de lignes ?

plus généralement, dans ce code, toutes tes chaines ont des longueurs fixes les malloc() n'ont aucun intérêt.

Par simple curiosité, comment est censé marcher l'envoi d'un SMS ?.

Si ce code n'est pas de toi, il serait surement plus simple que tu reprennes tout du début. Sais-tu simplement envoyer un SMS composé d'une chaine constante sur un téléphone dont le numéro est aussi une constante ?.
Après tu pourras compliquer

Bon courage.