Bonjour,
Dans le cadre d'un projet étudiant, nous devons concevoir un routeur logique afin de manager les flux de données entre les différents modules d'un réseau étoile. Voilà pour ce qui est du contexte.
Rentrant maintenant plus dans ce qui nous embête : notre routeur fonctionne, mais seulement en local, en utilisant l'adresse réservée 127.0.0.1 ! Pour faire simple, je vais vous demander de l'aide pour le programme de test de ce routeur, car il contient à peu de chose près le code du module gérant la com de notre routeur.

Il s'agit d'un terminal permettant d'envoyer et de recevoir des chaines de caractères, il utilise l'API socket et fonctionne en mode non connecté (udp). Tout comme le routeur, il marche à merveille avec l'adresse 127.0.0.1 mais pas en réseau, nous pensons que tous les deux ont le même soucis.
Nous avons inspecté le code, ras. Nous avons fait des dumps un peu partout, ras. Le message d'erreur correspond à un renvoit de -1 de sendto.
Il faut également noté que notre réseau est bien configuré : on peut pinger tous les pc, et on arrive à communiquer deux à deux en udp avec NetCat.

Est-ce que cela peut être du à une quelconque protection au niveau du pc (on utilise Linux opensuse 10.3) ? On a désactivé Novel AppArmor (l'antivirus) et le firewall.
Est-ce le code qui est bugué (alors ds ce cas pourquoi ça fonctionne en local) ?

Merci d'avance pour votre aide, je vous joins une partie du code : il s'agit de l'ensemble des fonctions utilisant l'API socket. Le programme coince au niveau de la l'avant-dernière fonction : Network_send. Mais comme les arguments de celle-ci dépendent des autres fonctions du .c...

Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
/* Antonio-Carlos Pasinelli */
 
 
[...]
 
/* FUNCTIONS */
 
int Network_createip
(
	char *string,
	Network_ip_t *ip_ptr
)
{
	Network_ip_t ip;
 
	if(inet_aton(string, &ip))
	{
		*ip_ptr = ip;
 
		return 0;
	}
	else
	{
		return 1;
	}
}
 
int Network_createport
(
	int number,
	Network_port_t *port_ptr
)
{
	*port_ptr = htons(number);
 
	return 0;
}
 
int Network_createinternetlocation
(
	Network_ip_t ip,
	Network_port_t port,
	Network_location_t *location_ptr
)
{
	Network_location_t location;
 
	location = malloc(sizeof (struct Network_locationinformation_t));
 
	if(location != NULL)
	{
		struct sockaddr_in *internetaddress_ptr;
 
		internetaddress_ptr = malloc(sizeof (struct sockaddr_in));
 
		if(internetaddress_ptr != NULL)
		{
			union Network_address_ptr_t address_ptr;
 
			(*internetaddress_ptr).sin_family = AF_INET;
 
			(*internetaddress_ptr).sin_addr = ip;
 
			(*internetaddress_ptr).sin_port = port;
 
			location->Network_namespace = Network_internet;
 
			address_ptr.Network_internetaddress_ptr = internetaddress_ptr;
 
			location->Network_address_ptr = address_ptr;
 
			location->Network_length = sizeof (struct sockaddr_in);
 
			*location_ptr = location;
 
			return 0;
		}
		else
		{
			free(location);
 
			return 1;
		}
	}
	else
	{
		return 1;
	}
}
 
int Network_createhostinternetlocation
(
	Network_port_t port,
	Network_location_t *location_ptr
)
{
	Network_ip_t ip;
 
	ip.s_addr = htonl(INADDR_LOOPBACK);
 
	return Network_createinternetlocation(ip, port, location_ptr);
}
 
int Network_createlocallocation
(
	char *path,
	Network_location_t *location_ptr
)
{
	Network_location_t location;
 
	location = malloc(sizeof (struct Network_locationinformation_t));
 
	if(location != NULL)
	{
		struct sockaddr_un *localaddress_ptr;
 
		localaddress_ptr = malloc(sizeof (struct sockaddr_un));
 
		if(localaddress_ptr != NULL)
		{
			size_t pathlength;
 
			pathlength = strlen(path);
 
			if(pathlength < (sizeof (*localaddress_ptr).sun_path) - 1)
			{
				union Network_address_ptr_t address_ptr;
 
				char *localaddresspath;
 
				(*localaddress_ptr).sun_family = AF_LOCAL;
 
				localaddresspath = (*localaddress_ptr).sun_path;
 
				(void)strcpy(localaddresspath, path);
 
				location->Network_namespace = Network_local;
 
				address_ptr.Network_localaddress_ptr = localaddress_ptr;
 
				location->Network_address_ptr = address_ptr;
 
				location->Network_length = ((char *)localaddresspath - (char *)localaddress_ptr) + pathlength;
 
				*location_ptr = location;
 
				return 0;
			}
			else
			{
				free(localaddress_ptr);
 
				free(location);
 
				return 1;
			}
		}
		else
		{
			free(location);
 
			return 1;
		}
	}
	else
	{
		return 1;
	}
}
 
int Network_createdescriptor
(
	Network_location_t location,
	Network_descriptor_t *descriptor_ptr
)
{
	union Network_address_ptr_t address_ptr;
 
	int domain;
 
	struct sockaddr *socketaddress_ptr;
 
	Network_descriptor_t descriptor;
 
	address_ptr = location->Network_address_ptr;
 
	switch(location->Network_namespace)
	{
		case Network_internet :
		{
			domain = PF_INET;
 
			socketaddress_ptr = (struct sockaddr *)address_ptr.Network_internetaddress_ptr;
 
			break;
		}
 
		case Network_local :
		{
			domain = PF_LOCAL;
 
			socketaddress_ptr = (struct sockaddr *)address_ptr.Network_localaddress_ptr;
 
			break;
		}
 
		default :
		{
			abort();
 
			break;
		}
	}
 
	descriptor = socket(domain, SOCK_DGRAM, 0);
 
	if(descriptor != -1)
	{
		if(!bind(descriptor, socketaddress_ptr, location->Network_length))
		{
			*descriptor_ptr = descriptor;
 
			return 0;
		}
		else
		{
			return 1;
		}
	}
	else
	{
		return 1;
	}
}
 
int Network_send
(
	Network_descriptor_t descriptor,
	Network_data_t data,
	size_t length,
	Network_location_t location,
	size_t *sentlength_ptr
)
{
	union Network_address_ptr_t address_ptr;
 
	struct sockaddr *socketaddress_ptr;
 
	size_t sentlength;
 
	address_ptr = location->Network_address_ptr;
 
	switch(location->Network_namespace)
	{
		case Network_internet :
		{
			socketaddress_ptr = (struct sockaddr *)address_ptr.Network_internetaddress_ptr;
 
			break;
		}
 
		case Network_local :
		{
			socketaddress_ptr = (struct sockaddr *)address_ptr.Network_localaddress_ptr;
 
			break;
		}
 
		default :
		{
			abort();
 
			break;
		}
	}
 
	sentlength = sendto(descriptor, data, length, 0, socketaddress_ptr, location->Network_length);
 
	if(sentlength != -1)
	{
		*sentlength_ptr = sentlength;
 
		return 0;
	}
	else
	{
		return 1;
	}
}
 
int Network_receive
(
	Network_descriptor_t descriptor,
	Network_data_t data,
	size_t length,
	size_t *receivedlength_ptr
)
{
	size_t receivedlength;
 
	receivedlength = recvfrom(descriptor, data, length, 0, NULL, 0);
 
	if(receivedlength != -1)
	{
		*receivedlength_ptr = receivedlength;
 
		return 0;
	}
	else
	{
		return 1;
	}
}
 
 
/* End of implementation file for the Network module */