diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/nat | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/nat')
-rw-r--r-- | src/nat/gnunet-helper-nat-client.c | 314 | ||||
-rw-r--r-- | src/nat/gnunet-helper-nat-server.c | 560 | ||||
-rw-r--r-- | src/nat/gnunet-nat.c | 424 | ||||
-rw-r--r-- | src/nat/gnunet-service-nat.c | 2104 | ||||
-rw-r--r-- | src/nat/gnunet-service-nat_externalip.c | 168 | ||||
-rw-r--r-- | src/nat/gnunet-service-nat_externalip.h | 8 | ||||
-rw-r--r-- | src/nat/gnunet-service-nat_helper.c | 359 | ||||
-rw-r--r-- | src/nat/gnunet-service-nat_helper.h | 18 | ||||
-rw-r--r-- | src/nat/gnunet-service-nat_mini.c | 584 | ||||
-rw-r--r-- | src/nat/gnunet-service-nat_mini.h | 17 | ||||
-rw-r--r-- | src/nat/gnunet-service-nat_stun.c | 171 | ||||
-rw-r--r-- | src/nat/gnunet-service-nat_stun.h | 6 | ||||
-rw-r--r-- | src/nat/nat.h | 21 | ||||
-rw-r--r-- | src/nat/nat_api.c | 524 | ||||
-rw-r--r-- | src/nat/nat_api_stun.c | 156 | ||||
-rw-r--r-- | src/nat/nat_stun.h | 74 | ||||
-rw-r--r-- | src/nat/test_nat.c | 119 | ||||
-rw-r--r-- | src/nat/test_nat_mini.c | 78 | ||||
-rw-r--r-- | src/nat/test_nat_test.c | 105 | ||||
-rw-r--r-- | src/nat/test_stun.c | 266 |
20 files changed, 3069 insertions, 3007 deletions
diff --git a/src/nat/gnunet-helper-nat-client.c b/src/nat/gnunet-helper-nat-client.c index d5d774964..5d12092e7 100644 --- a/src/nat/gnunet-helper-nat-client.c +++ b/src/nat/gnunet-helper-nat-client.c | |||
@@ -75,7 +75,9 @@ | |||
75 | * @param src source of the copy, may be NULL if @a n is zero | 75 | * @param src source of the copy, may be NULL if @a n is zero |
76 | * @param n number of bytes to copy | 76 | * @param n number of bytes to copy |
77 | */ | 77 | */ |
78 | #define GNUNET_memcpy(dst, src, n) do { if (0 != n) { (void)memcpy(dst, src, n); } } while (0) | 78 | #define GNUNET_memcpy(dst, src, n) do { if (0 != n) { (void) memcpy (dst, src, \ |
79 | n); \ | ||
80 | } } while (0) | ||
79 | 81 | ||
80 | /** | 82 | /** |
81 | * Must match IP given in the server. | 83 | * Must match IP given in the server. |
@@ -92,7 +94,8 @@ | |||
92 | /** | 94 | /** |
93 | * IPv4 header. | 95 | * IPv4 header. |
94 | */ | 96 | */ |
95 | struct ip_header { | 97 | struct ip_header |
98 | { | ||
96 | /** | 99 | /** |
97 | * Version (4 bits) + Internet header length (4 bits) | 100 | * Version (4 bits) + Internet header length (4 bits) |
98 | */ | 101 | */ |
@@ -147,7 +150,8 @@ struct ip_header { | |||
147 | /** | 150 | /** |
148 | * Format of ICMP packet. | 151 | * Format of ICMP packet. |
149 | */ | 152 | */ |
150 | struct icmp_ttl_exceeded_header { | 153 | struct icmp_ttl_exceeded_header |
154 | { | ||
151 | uint8_t type; | 155 | uint8_t type; |
152 | 156 | ||
153 | uint8_t code; | 157 | uint8_t code; |
@@ -159,7 +163,8 @@ struct icmp_ttl_exceeded_header { | |||
159 | /* followed by original payload */ | 163 | /* followed by original payload */ |
160 | }; | 164 | }; |
161 | 165 | ||
162 | struct icmp_echo_header { | 166 | struct icmp_echo_header |
167 | { | ||
163 | uint8_t type; | 168 | uint8_t type; |
164 | 169 | ||
165 | uint8_t code; | 170 | uint8_t code; |
@@ -172,7 +177,8 @@ struct icmp_echo_header { | |||
172 | /** | 177 | /** |
173 | * Beginning of UDP packet. | 178 | * Beginning of UDP packet. |
174 | */ | 179 | */ |
175 | struct udp_header { | 180 | struct udp_header |
181 | { | ||
176 | uint16_t src_port; | 182 | uint16_t src_port; |
177 | 183 | ||
178 | uint16_t dst_port; | 184 | uint16_t dst_port; |
@@ -206,7 +212,7 @@ static uint16_t port; | |||
206 | * @return the CRC 16. | 212 | * @return the CRC 16. |
207 | */ | 213 | */ |
208 | static uint16_t | 214 | static uint16_t |
209 | calc_checksum(const uint16_t * data, unsigned int bytes) | 215 | calc_checksum (const uint16_t *data, unsigned int bytes) |
210 | { | 216 | { |
211 | uint32_t sum; | 217 | uint32_t sum; |
212 | unsigned int i; | 218 | unsigned int i; |
@@ -215,7 +221,7 @@ calc_checksum(const uint16_t * data, unsigned int bytes) | |||
215 | for (i = 0; i < bytes / 2; i++) | 221 | for (i = 0; i < bytes / 2; i++) |
216 | sum += data[i]; | 222 | sum += data[i]; |
217 | sum = (sum & 0xffff) + (sum >> 16); | 223 | sum = (sum & 0xffff) + (sum >> 16); |
218 | sum = htons(0xffff - sum); | 224 | sum = htons (0xffff - sum); |
219 | return sum; | 225 | return sum; |
220 | } | 226 | } |
221 | 227 | ||
@@ -227,11 +233,11 @@ calc_checksum(const uint16_t * data, unsigned int bytes) | |||
227 | * @param other target address | 233 | * @param other target address |
228 | */ | 234 | */ |
229 | static void | 235 | static void |
230 | send_icmp_udp(const struct in_addr *my_ip, const struct in_addr *other) | 236 | send_icmp_udp (const struct in_addr *my_ip, const struct in_addr *other) |
231 | { | 237 | { |
232 | char packet[sizeof(struct ip_header) * 2 + | 238 | char packet[sizeof(struct ip_header) * 2 |
233 | sizeof(struct icmp_ttl_exceeded_header) + | 239 | + sizeof(struct icmp_ttl_exceeded_header) |
234 | sizeof(struct udp_header)]; | 240 | + sizeof(struct udp_header)]; |
235 | struct ip_header ip_pkt; | 241 | struct ip_header ip_pkt; |
236 | struct icmp_ttl_exceeded_header icmp_pkt; | 242 | struct icmp_ttl_exceeded_header icmp_pkt; |
237 | struct udp_header udp_pkt; | 243 | struct udp_header udp_pkt; |
@@ -246,9 +252,9 @@ send_icmp_udp(const struct in_addr *my_ip, const struct in_addr *other) | |||
246 | #ifdef FREEBSD | 252 | #ifdef FREEBSD |
247 | ip_pkt.pkt_len = sizeof(packet); /* Workaround PR kern/21737 */ | 253 | ip_pkt.pkt_len = sizeof(packet); /* Workaround PR kern/21737 */ |
248 | #else | 254 | #else |
249 | ip_pkt.pkt_len = htons(sizeof(packet)); | 255 | ip_pkt.pkt_len = htons (sizeof(packet)); |
250 | #endif | 256 | #endif |
251 | ip_pkt.id = htons(PACKET_ID); | 257 | ip_pkt.id = htons (PACKET_ID); |
252 | ip_pkt.flags_frag_offset = 0; | 258 | ip_pkt.flags_frag_offset = 0; |
253 | ip_pkt.ttl = 128; | 259 | ip_pkt.ttl = 128; |
254 | ip_pkt.proto = IPPROTO_ICMP; | 260 | ip_pkt.proto = IPPROTO_ICMP; |
@@ -256,27 +262,27 @@ send_icmp_udp(const struct in_addr *my_ip, const struct in_addr *other) | |||
256 | ip_pkt.src_ip = my_ip->s_addr; | 262 | ip_pkt.src_ip = my_ip->s_addr; |
257 | ip_pkt.dst_ip = other->s_addr; | 263 | ip_pkt.dst_ip = other->s_addr; |
258 | ip_pkt.checksum = | 264 | ip_pkt.checksum = |
259 | htons(calc_checksum((uint16_t *)&ip_pkt, sizeof(struct ip_header))); | 265 | htons (calc_checksum ((uint16_t *) &ip_pkt, sizeof(struct ip_header))); |
260 | GNUNET_memcpy(&packet[off], | 266 | GNUNET_memcpy (&packet[off], |
261 | &ip_pkt, | 267 | &ip_pkt, |
262 | sizeof(struct ip_header)); | 268 | sizeof(struct ip_header)); |
263 | off += sizeof(struct ip_header); | 269 | off += sizeof(struct ip_header); |
264 | 270 | ||
265 | icmp_pkt.type = ICMP_TIME_EXCEEDED; | 271 | icmp_pkt.type = ICMP_TIME_EXCEEDED; |
266 | icmp_pkt.code = 0; | 272 | icmp_pkt.code = 0; |
267 | icmp_pkt.checksum = 0; | 273 | icmp_pkt.checksum = 0; |
268 | icmp_pkt.unused = 0; | 274 | icmp_pkt.unused = 0; |
269 | GNUNET_memcpy(&packet[off], | 275 | GNUNET_memcpy (&packet[off], |
270 | &icmp_pkt, | 276 | &icmp_pkt, |
271 | sizeof(struct icmp_ttl_exceeded_header)); | 277 | sizeof(struct icmp_ttl_exceeded_header)); |
272 | off += sizeof(struct icmp_ttl_exceeded_header); | 278 | off += sizeof(struct icmp_ttl_exceeded_header); |
273 | 279 | ||
274 | /* ip header of the presumably 'lost' udp packet */ | 280 | /* ip header of the presumably 'lost' udp packet */ |
275 | ip_pkt.vers_ihl = 0x45; | 281 | ip_pkt.vers_ihl = 0x45; |
276 | ip_pkt.tos = 0; | 282 | ip_pkt.tos = 0; |
277 | ip_pkt.pkt_len = | 283 | ip_pkt.pkt_len = |
278 | htons(sizeof(struct ip_header) + sizeof(struct udp_header)); | 284 | htons (sizeof(struct ip_header) + sizeof(struct udp_header)); |
279 | ip_pkt.id = htons(0); | 285 | ip_pkt.id = htons (0); |
280 | ip_pkt.flags_frag_offset = 0; | 286 | ip_pkt.flags_frag_offset = 0; |
281 | ip_pkt.ttl = 128; | 287 | ip_pkt.ttl = 128; |
282 | ip_pkt.proto = IPPROTO_UDP; | 288 | ip_pkt.proto = IPPROTO_UDP; |
@@ -284,49 +290,50 @@ send_icmp_udp(const struct in_addr *my_ip, const struct in_addr *other) | |||
284 | ip_pkt.src_ip = other->s_addr; | 290 | ip_pkt.src_ip = other->s_addr; |
285 | ip_pkt.dst_ip = dummy.s_addr; | 291 | ip_pkt.dst_ip = dummy.s_addr; |
286 | ip_pkt.checksum = | 292 | ip_pkt.checksum = |
287 | htons(calc_checksum((uint16_t *)&ip_pkt, sizeof(struct ip_header))); | 293 | htons (calc_checksum ((uint16_t *) &ip_pkt, sizeof(struct ip_header))); |
288 | GNUNET_memcpy(&packet[off], | 294 | GNUNET_memcpy (&packet[off], |
289 | &ip_pkt, | 295 | &ip_pkt, |
290 | sizeof(struct ip_header)); | 296 | sizeof(struct ip_header)); |
291 | off += sizeof(struct ip_header); | 297 | off += sizeof(struct ip_header); |
292 | 298 | ||
293 | /* build UDP header */ | 299 | /* build UDP header */ |
294 | udp_pkt.src_port = htons(NAT_TRAV_PORT); | 300 | udp_pkt.src_port = htons (NAT_TRAV_PORT); |
295 | udp_pkt.dst_port = htons(NAT_TRAV_PORT); | 301 | udp_pkt.dst_port = htons (NAT_TRAV_PORT); |
296 | udp_pkt.length = htons(port); | 302 | udp_pkt.length = htons (port); |
297 | udp_pkt.crc = 0; | 303 | udp_pkt.crc = 0; |
298 | GNUNET_memcpy(&packet[off], | 304 | GNUNET_memcpy (&packet[off], |
299 | &udp_pkt, | 305 | &udp_pkt, |
300 | sizeof(struct udp_header)); | 306 | sizeof(struct udp_header)); |
301 | off += sizeof(struct udp_header); | 307 | off += sizeof(struct udp_header); |
302 | 308 | ||
303 | /* set ICMP checksum */ | 309 | /* set ICMP checksum */ |
304 | icmp_pkt.checksum = | 310 | icmp_pkt.checksum = |
305 | htons(calc_checksum | 311 | htons (calc_checksum |
306 | ((uint16_t *)&packet[sizeof(struct ip_header)], | 312 | ((uint16_t *) &packet[sizeof(struct ip_header)], |
307 | sizeof(struct icmp_ttl_exceeded_header) + | 313 | sizeof(struct icmp_ttl_exceeded_header) |
308 | sizeof(struct ip_header) + sizeof(struct udp_header))); | 314 | + sizeof(struct ip_header) + sizeof(struct udp_header))); |
309 | GNUNET_memcpy(&packet[sizeof(struct ip_header)], | 315 | GNUNET_memcpy (&packet[sizeof(struct ip_header)], |
310 | &icmp_pkt, | 316 | &icmp_pkt, |
311 | sizeof(struct icmp_ttl_exceeded_header)); | 317 | sizeof(struct icmp_ttl_exceeded_header)); |
312 | 318 | ||
313 | memset(&dst, 0, sizeof(dst)); | 319 | memset (&dst, 0, sizeof(dst)); |
314 | dst.sin_family = AF_INET; | 320 | dst.sin_family = AF_INET; |
315 | #if HAVE_SOCKADDR_IN_SIN_LEN | 321 | #if HAVE_SOCKADDR_IN_SIN_LEN |
316 | dst.sin_len = sizeof(struct sockaddr_in); | 322 | dst.sin_len = sizeof(struct sockaddr_in); |
317 | #endif | 323 | #endif |
318 | dst.sin_addr = *other; | 324 | dst.sin_addr = *other; |
319 | err = | 325 | err = |
320 | sendto(rawsock, packet, sizeof(packet), 0, (struct sockaddr *)&dst, | 326 | sendto (rawsock, packet, sizeof(packet), 0, (struct sockaddr *) &dst, |
321 | sizeof(dst)); | 327 | sizeof(dst)); |
322 | if (err < 0) | 328 | if (err < 0) |
323 | { | 329 | { |
324 | fprintf(stderr, "sendto failed: %s\n", strerror(errno)); | 330 | fprintf (stderr, "sendto failed: %s\n", strerror (errno)); |
325 | } | 331 | } |
326 | else if (sizeof(packet) != (size_t)err) | 332 | else if (sizeof(packet) != (size_t) err) |
327 | { | 333 | { |
328 | fprintf(stderr, "Error: partial send of ICMP message with size %lu\n", (unsigned long)off); | 334 | fprintf (stderr, "Error: partial send of ICMP message with size %lu\n", |
329 | } | 335 | (unsigned long) off); |
336 | } | ||
330 | } | 337 | } |
331 | 338 | ||
332 | 339 | ||
@@ -337,15 +344,15 @@ send_icmp_udp(const struct in_addr *my_ip, const struct in_addr *other) | |||
337 | * @param other target address | 344 | * @param other target address |
338 | */ | 345 | */ |
339 | static void | 346 | static void |
340 | send_icmp(const struct in_addr *my_ip, const struct in_addr *other) | 347 | send_icmp (const struct in_addr *my_ip, const struct in_addr *other) |
341 | { | 348 | { |
342 | struct ip_header ip_pkt; | 349 | struct ip_header ip_pkt; |
343 | struct icmp_ttl_exceeded_header icmp_ttl; | 350 | struct icmp_ttl_exceeded_header icmp_ttl; |
344 | struct icmp_echo_header icmp_echo; | 351 | struct icmp_echo_header icmp_echo; |
345 | struct sockaddr_in dst; | 352 | struct sockaddr_in dst; |
346 | char packet[sizeof(struct ip_header) * 2 + | 353 | char packet[sizeof(struct ip_header) * 2 |
347 | sizeof(struct icmp_ttl_exceeded_header) + | 354 | + sizeof(struct icmp_ttl_exceeded_header) |
348 | sizeof(struct icmp_echo_header)]; | 355 | + sizeof(struct icmp_echo_header)]; |
349 | size_t off; | 356 | size_t off; |
350 | int err; | 357 | int err; |
351 | 358 | ||
@@ -356,9 +363,9 @@ send_icmp(const struct in_addr *my_ip, const struct in_addr *other) | |||
356 | #ifdef FREEBSD | 363 | #ifdef FREEBSD |
357 | ip_pkt.pkt_len = sizeof(packet); /* Workaround PR kern/21737 */ | 364 | ip_pkt.pkt_len = sizeof(packet); /* Workaround PR kern/21737 */ |
358 | #else | 365 | #else |
359 | ip_pkt.pkt_len = htons(sizeof(packet)); | 366 | ip_pkt.pkt_len = htons (sizeof(packet)); |
360 | #endif | 367 | #endif |
361 | ip_pkt.id = htons(PACKET_ID); | 368 | ip_pkt.id = htons (PACKET_ID); |
362 | ip_pkt.flags_frag_offset = 0; | 369 | ip_pkt.flags_frag_offset = 0; |
363 | ip_pkt.ttl = IPDEFTTL; | 370 | ip_pkt.ttl = IPDEFTTL; |
364 | ip_pkt.proto = IPPROTO_ICMP; | 371 | ip_pkt.proto = IPPROTO_ICMP; |
@@ -366,10 +373,10 @@ send_icmp(const struct in_addr *my_ip, const struct in_addr *other) | |||
366 | ip_pkt.src_ip = my_ip->s_addr; | 373 | ip_pkt.src_ip = my_ip->s_addr; |
367 | ip_pkt.dst_ip = other->s_addr; | 374 | ip_pkt.dst_ip = other->s_addr; |
368 | ip_pkt.checksum = | 375 | ip_pkt.checksum = |
369 | htons(calc_checksum((uint16_t *)&ip_pkt, sizeof(struct ip_header))); | 376 | htons (calc_checksum ((uint16_t *) &ip_pkt, sizeof(struct ip_header))); |
370 | GNUNET_memcpy(&packet[off], | 377 | GNUNET_memcpy (&packet[off], |
371 | &ip_pkt, | 378 | &ip_pkt, |
372 | sizeof(struct ip_header)); | 379 | sizeof(struct ip_header)); |
373 | off = sizeof(ip_pkt); | 380 | off = sizeof(ip_pkt); |
374 | 381 | ||
375 | /* icmp reply: time exceeded */ | 382 | /* icmp reply: time exceeded */ |
@@ -377,17 +384,17 @@ send_icmp(const struct in_addr *my_ip, const struct in_addr *other) | |||
377 | icmp_ttl.code = 0; | 384 | icmp_ttl.code = 0; |
378 | icmp_ttl.checksum = 0; | 385 | icmp_ttl.checksum = 0; |
379 | icmp_ttl.unused = 0; | 386 | icmp_ttl.unused = 0; |
380 | GNUNET_memcpy(&packet[off], | 387 | GNUNET_memcpy (&packet[off], |
381 | &icmp_ttl, | 388 | &icmp_ttl, |
382 | sizeof(struct icmp_ttl_exceeded_header)); | 389 | sizeof(struct icmp_ttl_exceeded_header)); |
383 | off += sizeof(struct icmp_ttl_exceeded_header); | 390 | off += sizeof(struct icmp_ttl_exceeded_header); |
384 | 391 | ||
385 | /* ip header of the presumably 'lost' udp packet */ | 392 | /* ip header of the presumably 'lost' udp packet */ |
386 | ip_pkt.vers_ihl = 0x45; | 393 | ip_pkt.vers_ihl = 0x45; |
387 | ip_pkt.tos = 0; | 394 | ip_pkt.tos = 0; |
388 | ip_pkt.pkt_len = | 395 | ip_pkt.pkt_len = |
389 | htons(sizeof(struct ip_header) + sizeof(struct icmp_echo_header)); | 396 | htons (sizeof(struct ip_header) + sizeof(struct icmp_echo_header)); |
390 | ip_pkt.id = htons(PACKET_ID); | 397 | ip_pkt.id = htons (PACKET_ID); |
391 | ip_pkt.flags_frag_offset = 0; | 398 | ip_pkt.flags_frag_offset = 0; |
392 | ip_pkt.ttl = 1; /* real TTL would be 1 on a time exceeded packet */ | 399 | ip_pkt.ttl = 1; /* real TTL would be 1 on a time exceeded packet */ |
393 | ip_pkt.proto = IPPROTO_ICMP; | 400 | ip_pkt.proto = IPPROTO_ICMP; |
@@ -395,57 +402,57 @@ send_icmp(const struct in_addr *my_ip, const struct in_addr *other) | |||
395 | ip_pkt.dst_ip = dummy.s_addr; | 402 | ip_pkt.dst_ip = dummy.s_addr; |
396 | ip_pkt.checksum = 0; | 403 | ip_pkt.checksum = 0; |
397 | ip_pkt.checksum = | 404 | ip_pkt.checksum = |
398 | htons(calc_checksum((uint16_t *)&ip_pkt, sizeof(struct ip_header))); | 405 | htons (calc_checksum ((uint16_t *) &ip_pkt, sizeof(struct ip_header))); |
399 | GNUNET_memcpy(&packet[off], | 406 | GNUNET_memcpy (&packet[off], |
400 | &ip_pkt, | 407 | &ip_pkt, |
401 | sizeof(struct ip_header)); | 408 | sizeof(struct ip_header)); |
402 | off += sizeof(struct ip_header); | 409 | off += sizeof(struct ip_header); |
403 | 410 | ||
404 | icmp_echo.type = ICMP_ECHO; | 411 | icmp_echo.type = ICMP_ECHO; |
405 | icmp_echo.code = 0; | 412 | icmp_echo.code = 0; |
406 | icmp_echo.reserved = htonl(port); | 413 | icmp_echo.reserved = htonl (port); |
407 | icmp_echo.checksum = 0; | 414 | icmp_echo.checksum = 0; |
408 | icmp_echo.checksum = | 415 | icmp_echo.checksum = |
409 | htons(calc_checksum | 416 | htons (calc_checksum |
410 | ((uint16_t *)&icmp_echo, sizeof(struct icmp_echo_header))); | 417 | ((uint16_t *) &icmp_echo, sizeof(struct icmp_echo_header))); |
411 | GNUNET_memcpy(&packet[off], | 418 | GNUNET_memcpy (&packet[off], |
412 | &icmp_echo, | 419 | &icmp_echo, |
413 | sizeof(struct icmp_echo_header)); | 420 | sizeof(struct icmp_echo_header)); |
414 | 421 | ||
415 | /* no go back to calculate ICMP packet checksum */ | 422 | /* no go back to calculate ICMP packet checksum */ |
416 | off = sizeof(struct ip_header); | 423 | off = sizeof(struct ip_header); |
417 | icmp_ttl.checksum = | 424 | icmp_ttl.checksum = |
418 | htons(calc_checksum | 425 | htons (calc_checksum |
419 | ((uint16_t *)&packet[off], | 426 | ((uint16_t *) &packet[off], |
420 | sizeof(struct icmp_ttl_exceeded_header) + | 427 | sizeof(struct icmp_ttl_exceeded_header) |
421 | sizeof(struct ip_header) + sizeof(struct icmp_echo_header))); | 428 | + sizeof(struct ip_header) + sizeof(struct icmp_echo_header))); |
422 | GNUNET_memcpy(&packet[off], | 429 | GNUNET_memcpy (&packet[off], |
423 | &icmp_ttl, | 430 | &icmp_ttl, |
424 | sizeof(struct icmp_ttl_exceeded_header)); | 431 | sizeof(struct icmp_ttl_exceeded_header)); |
425 | 432 | ||
426 | /* prepare for transmission */ | 433 | /* prepare for transmission */ |
427 | memset(&dst, 0, sizeof(dst)); | 434 | memset (&dst, 0, sizeof(dst)); |
428 | dst.sin_family = AF_INET; | 435 | dst.sin_family = AF_INET; |
429 | #if HAVE_SOCKADDR_IN_SIN_LEN | 436 | #if HAVE_SOCKADDR_IN_SIN_LEN |
430 | dst.sin_len = sizeof(struct sockaddr_in); | 437 | dst.sin_len = sizeof(struct sockaddr_in); |
431 | #endif | 438 | #endif |
432 | dst.sin_addr = *other; | 439 | dst.sin_addr = *other; |
433 | err = | 440 | err = |
434 | sendto(rawsock, packet, sizeof(packet), 0, (struct sockaddr *)&dst, | 441 | sendto (rawsock, packet, sizeof(packet), 0, (struct sockaddr *) &dst, |
435 | sizeof(dst)); | 442 | sizeof(dst)); |
436 | if (err < 0) | 443 | if (err < 0) |
437 | { | 444 | { |
438 | fprintf(stderr, "sendto failed: %s\n", strerror(errno)); | 445 | fprintf (stderr, "sendto failed: %s\n", strerror (errno)); |
439 | } | 446 | } |
440 | else if (sizeof(packet) != (size_t)err) | 447 | else if (sizeof(packet) != (size_t) err) |
441 | { | 448 | { |
442 | fprintf(stderr, "Error: partial send of ICMP message\n"); | 449 | fprintf (stderr, "Error: partial send of ICMP message\n"); |
443 | } | 450 | } |
444 | } | 451 | } |
445 | 452 | ||
446 | 453 | ||
447 | int | 454 | int |
448 | main(int argc, char *const *argv) | 455 | main (int argc, char *const *argv) |
449 | { | 456 | { |
450 | const int one = 1; | 457 | const int one = 1; |
451 | struct in_addr external; | 458 | struct in_addr external; |
@@ -456,80 +463,81 @@ main(int argc, char *const *argv) | |||
456 | int global_ret; | 463 | int global_ret; |
457 | 464 | ||
458 | /* Create an ICMP raw socket for writing (only operation that requires root) */ | 465 | /* Create an ICMP raw socket for writing (only operation that requires root) */ |
459 | rawsock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW); | 466 | rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_RAW); |
460 | raw_eno = errno; /* for later error checking */ | 467 | raw_eno = errno; /* for later error checking */ |
461 | 468 | ||
462 | /* now drop root privileges */ | 469 | /* now drop root privileges */ |
463 | uid = getuid(); | 470 | uid = getuid (); |
464 | #ifdef HAVE_SETRESUID | 471 | #ifdef HAVE_SETRESUID |
465 | if (0 != setresuid(uid, uid, uid)) | 472 | if (0 != setresuid (uid, uid, uid)) |
466 | { | 473 | { |
467 | fprintf(stderr, "Failed to setresuid: %s\n", strerror(errno)); | 474 | fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno)); |
468 | global_ret = 1; | 475 | global_ret = 1; |
469 | goto cleanup; | 476 | goto cleanup; |
470 | } | 477 | } |
471 | #else | 478 | #else |
472 | if (0 != (setuid(uid) | seteuid(uid))) | 479 | if (0 != (setuid (uid) | seteuid (uid))) |
473 | { | 480 | { |
474 | fprintf(stderr, "Failed to setuid: %s\n", strerror(errno)); | 481 | fprintf (stderr, "Failed to setuid: %s\n", strerror (errno)); |
475 | global_ret = 2; | 482 | global_ret = 2; |
476 | goto cleanup; | 483 | goto cleanup; |
477 | } | 484 | } |
478 | #endif | 485 | #endif |
479 | if (-1 == rawsock) | 486 | if (-1 == rawsock) |
480 | { | 487 | { |
481 | fprintf(stderr, "Error opening RAW socket: %s\n", strerror(raw_eno)); | 488 | fprintf (stderr, "Error opening RAW socket: %s\n", strerror (raw_eno)); |
482 | global_ret = 3; | 489 | global_ret = 3; |
483 | goto cleanup; | 490 | goto cleanup; |
484 | } | 491 | } |
485 | if (0 != | 492 | if (0 != |
486 | setsockopt(rawsock, SOL_SOCKET, SO_BROADCAST, (char *)&one, sizeof(one))) | 493 | setsockopt (rawsock, SOL_SOCKET, SO_BROADCAST, (char *) &one, |
487 | { | 494 | sizeof(one))) |
488 | fprintf(stderr, "setsockopt failed: %s\n", strerror(errno)); | 495 | { |
489 | global_ret = 4; | 496 | fprintf (stderr, "setsockopt failed: %s\n", strerror (errno)); |
490 | goto cleanup; | 497 | global_ret = 4; |
491 | } | 498 | goto cleanup; |
499 | } | ||
492 | if (0 != | 500 | if (0 != |
493 | setsockopt(rawsock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one))) | 501 | setsockopt (rawsock, IPPROTO_IP, IP_HDRINCL, (char *) &one, sizeof(one))) |
494 | { | 502 | { |
495 | fprintf(stderr, "setsockopt failed: %s\n", strerror(errno)); | 503 | fprintf (stderr, "setsockopt failed: %s\n", strerror (errno)); |
496 | global_ret = 5; | 504 | global_ret = 5; |
497 | goto cleanup; | 505 | goto cleanup; |
498 | } | 506 | } |
499 | 507 | ||
500 | if (4 != argc) | 508 | if (4 != argc) |
501 | { | 509 | { |
502 | fprintf(stderr, | 510 | fprintf (stderr, |
503 | "This program must be started with our IP, the targets external IP, and our port as arguments.\n"); | 511 | "This program must be started with our IP, the targets external IP, and our port as arguments.\n"); |
504 | global_ret = 6; | 512 | global_ret = 6; |
505 | goto cleanup; | 513 | goto cleanup; |
506 | } | 514 | } |
507 | if ((1 != inet_pton(AF_INET, argv[1], &external)) || | 515 | if ((1 != inet_pton (AF_INET, argv[1], &external)) || |
508 | (1 != inet_pton(AF_INET, argv[2], &target))) | 516 | (1 != inet_pton (AF_INET, argv[2], &target))) |
509 | { | 517 | { |
510 | fprintf(stderr, "Error parsing IPv4 address: %s\n", strerror(errno)); | 518 | fprintf (stderr, "Error parsing IPv4 address: %s\n", strerror (errno)); |
511 | global_ret = 7; | 519 | global_ret = 7; |
512 | goto cleanup; | 520 | goto cleanup; |
513 | } | 521 | } |
514 | if ((1 != sscanf(argv[3], "%u", &p)) || (0 == p) || (0xFFFF < p)) | 522 | if ((1 != sscanf (argv[3], "%u", &p)) || (0 == p) || (0xFFFF < p)) |
515 | { | 523 | { |
516 | fprintf(stderr, "Error parsing port value `%s'\n", argv[3]); | 524 | fprintf (stderr, "Error parsing port value `%s'\n", argv[3]); |
517 | global_ret = 8; | 525 | global_ret = 8; |
518 | goto cleanup; | 526 | goto cleanup; |
519 | } | 527 | } |
520 | port = (uint16_t)p; | 528 | port = (uint16_t) p; |
521 | if (1 != inet_pton(AF_INET, DUMMY_IP, &dummy)) | 529 | if (1 != inet_pton (AF_INET, DUMMY_IP, &dummy)) |
522 | { | 530 | { |
523 | fprintf(stderr, "Internal error converting dummy IP to binary.\n"); | 531 | fprintf (stderr, "Internal error converting dummy IP to binary.\n"); |
524 | global_ret = 9; | 532 | global_ret = 9; |
525 | goto cleanup; | 533 | goto cleanup; |
526 | } | 534 | } |
527 | send_icmp(&external, &target); | 535 | send_icmp (&external, &target); |
528 | send_icmp_udp(&external, &target); | 536 | send_icmp_udp (&external, &target); |
529 | global_ret = 0; | 537 | global_ret = 0; |
530 | cleanup: | 538 | cleanup: |
531 | if (-1 != rawsock) | 539 | if (-1 != rawsock) |
532 | (void)close(rawsock); | 540 | (void) close (rawsock); |
533 | return global_ret; | 541 | return global_ret; |
534 | } | 542 | } |
535 | 543 | ||
diff --git a/src/nat/gnunet-helper-nat-server.c b/src/nat/gnunet-helper-nat-server.c index f087590c8..38d7d22c8 100644 --- a/src/nat/gnunet-helper-nat-server.c +++ b/src/nat/gnunet-helper-nat-server.c | |||
@@ -79,7 +79,9 @@ | |||
79 | * @param src source of the copy, may be NULL if @a n is zero | 79 | * @param src source of the copy, may be NULL if @a n is zero |
80 | * @param n number of bytes to copy | 80 | * @param n number of bytes to copy |
81 | */ | 81 | */ |
82 | #define GNUNET_memcpy(dst, src, n) do { if (0 != n) { (void)memcpy(dst, src, n); } } while (0) | 82 | #define GNUNET_memcpy(dst, src, n) do { if (0 != n) { (void) memcpy (dst, src, \ |
83 | n); \ | ||
84 | } } while (0) | ||
83 | 85 | ||
84 | /** | 86 | /** |
85 | * Should we print some debug output? | 87 | * Should we print some debug output? |
@@ -109,7 +111,8 @@ | |||
109 | /** | 111 | /** |
110 | * IPv4 header. | 112 | * IPv4 header. |
111 | */ | 113 | */ |
112 | struct ip_header { | 114 | struct ip_header |
115 | { | ||
113 | /** | 116 | /** |
114 | * Version (4 bits) + Internet header length (4 bits) | 117 | * Version (4 bits) + Internet header length (4 bits) |
115 | */ | 118 | */ |
@@ -164,7 +167,8 @@ struct ip_header { | |||
164 | /** | 167 | /** |
165 | * Format of ICMP packet. | 168 | * Format of ICMP packet. |
166 | */ | 169 | */ |
167 | struct icmp_ttl_exceeded_header { | 170 | struct icmp_ttl_exceeded_header |
171 | { | ||
168 | uint8_t type; | 172 | uint8_t type; |
169 | 173 | ||
170 | uint8_t code; | 174 | uint8_t code; |
@@ -176,7 +180,8 @@ struct icmp_ttl_exceeded_header { | |||
176 | /* followed by original payload */ | 180 | /* followed by original payload */ |
177 | }; | 181 | }; |
178 | 182 | ||
179 | struct icmp_echo_header { | 183 | struct icmp_echo_header |
184 | { | ||
180 | uint8_t type; | 185 | uint8_t type; |
181 | 186 | ||
182 | uint8_t code; | 187 | uint8_t code; |
@@ -190,7 +195,8 @@ struct icmp_echo_header { | |||
190 | /** | 195 | /** |
191 | * Beginning of UDP packet. | 196 | * Beginning of UDP packet. |
192 | */ | 197 | */ |
193 | struct udp_header { | 198 | struct udp_header |
199 | { | ||
194 | uint16_t src_port; | 200 | uint16_t src_port; |
195 | 201 | ||
196 | uint16_t dst_port; | 202 | uint16_t dst_port; |
@@ -229,7 +235,7 @@ static struct in_addr dummy; | |||
229 | * @return the CRC 16. | 235 | * @return the CRC 16. |
230 | */ | 236 | */ |
231 | static uint16_t | 237 | static uint16_t |
232 | calc_checksum(const uint16_t * data, unsigned int bytes) | 238 | calc_checksum (const uint16_t *data, unsigned int bytes) |
233 | { | 239 | { |
234 | uint32_t sum; | 240 | uint32_t sum; |
235 | unsigned int i; | 241 | unsigned int i; |
@@ -238,7 +244,7 @@ calc_checksum(const uint16_t * data, unsigned int bytes) | |||
238 | for (i = 0; i < bytes / 2; i++) | 244 | for (i = 0; i < bytes / 2; i++) |
239 | sum += data[i]; | 245 | sum += data[i]; |
240 | sum = (sum & 0xffff) + (sum >> 16); | 246 | sum = (sum & 0xffff) + (sum >> 16); |
241 | sum = htons(0xffff - sum); | 247 | sum = htons (0xffff - sum); |
242 | return sum; | 248 | return sum; |
243 | } | 249 | } |
244 | 250 | ||
@@ -249,7 +255,7 @@ calc_checksum(const uint16_t * data, unsigned int bytes) | |||
249 | * @param my_ip source address (our ip address) | 255 | * @param my_ip source address (our ip address) |
250 | */ | 256 | */ |
251 | static void | 257 | static void |
252 | send_icmp_echo(const struct in_addr *my_ip) | 258 | send_icmp_echo (const struct in_addr *my_ip) |
253 | { | 259 | { |
254 | char packet[sizeof(struct ip_header) + sizeof(struct icmp_echo_header)]; | 260 | char packet[sizeof(struct ip_header) + sizeof(struct icmp_echo_header)]; |
255 | struct icmp_echo_header icmp_echo; | 261 | struct icmp_echo_header icmp_echo; |
@@ -261,8 +267,8 @@ send_icmp_echo(const struct in_addr *my_ip) | |||
261 | off = 0; | 267 | off = 0; |
262 | ip_pkt.vers_ihl = 0x45; | 268 | ip_pkt.vers_ihl = 0x45; |
263 | ip_pkt.tos = 0; | 269 | ip_pkt.tos = 0; |
264 | ip_pkt.pkt_len = htons(sizeof(packet)); | 270 | ip_pkt.pkt_len = htons (sizeof(packet)); |
265 | ip_pkt.id = htons(PACKET_ID); | 271 | ip_pkt.id = htons (PACKET_ID); |
266 | ip_pkt.flags_frag_offset = 0; | 272 | ip_pkt.flags_frag_offset = 0; |
267 | ip_pkt.ttl = IPDEFTTL; | 273 | ip_pkt.ttl = IPDEFTTL; |
268 | ip_pkt.proto = IPPROTO_ICMP; | 274 | ip_pkt.proto = IPPROTO_ICMP; |
@@ -270,11 +276,11 @@ send_icmp_echo(const struct in_addr *my_ip) | |||
270 | ip_pkt.src_ip = my_ip->s_addr; | 276 | ip_pkt.src_ip = my_ip->s_addr; |
271 | ip_pkt.dst_ip = dummy.s_addr; | 277 | ip_pkt.dst_ip = dummy.s_addr; |
272 | ip_pkt.checksum = | 278 | ip_pkt.checksum = |
273 | htons(calc_checksum((uint16_t *)&ip_pkt, | 279 | htons (calc_checksum ((uint16_t *) &ip_pkt, |
274 | sizeof(struct ip_header))); | 280 | sizeof(struct ip_header))); |
275 | GNUNET_memcpy(&packet[off], | 281 | GNUNET_memcpy (&packet[off], |
276 | &ip_pkt, | 282 | &ip_pkt, |
277 | sizeof(struct ip_header)); | 283 | sizeof(struct ip_header)); |
278 | off += sizeof(struct ip_header); | 284 | off += sizeof(struct ip_header); |
279 | 285 | ||
280 | icmp_echo.type = ICMP_ECHO; | 286 | icmp_echo.type = ICMP_ECHO; |
@@ -282,39 +288,39 @@ send_icmp_echo(const struct in_addr *my_ip) | |||
282 | icmp_echo.checksum = 0; | 288 | icmp_echo.checksum = 0; |
283 | icmp_echo.reserved = 0; | 289 | icmp_echo.reserved = 0; |
284 | icmp_echo.checksum = | 290 | icmp_echo.checksum = |
285 | htons(calc_checksum | 291 | htons (calc_checksum |
286 | ((uint16_t *)&icmp_echo, | 292 | ((uint16_t *) &icmp_echo, |
287 | sizeof(struct icmp_echo_header))); | 293 | sizeof(struct icmp_echo_header))); |
288 | GNUNET_memcpy(&packet[off], | 294 | GNUNET_memcpy (&packet[off], |
289 | &icmp_echo, | 295 | &icmp_echo, |
290 | sizeof(struct icmp_echo_header)); | 296 | sizeof(struct icmp_echo_header)); |
291 | off += sizeof(struct icmp_echo_header); | 297 | off += sizeof(struct icmp_echo_header); |
292 | 298 | ||
293 | memset(&dst, 0, sizeof(dst)); | 299 | memset (&dst, 0, sizeof(dst)); |
294 | dst.sin_family = AF_INET; | 300 | dst.sin_family = AF_INET; |
295 | #if HAVE_SOCKADDR_IN_SIN_LEN | 301 | #if HAVE_SOCKADDR_IN_SIN_LEN |
296 | dst.sin_len = sizeof(struct sockaddr_in); | 302 | dst.sin_len = sizeof(struct sockaddr_in); |
297 | #endif | 303 | #endif |
298 | dst.sin_addr = dummy; | 304 | dst.sin_addr = dummy; |
299 | err = sendto(rawsock, | 305 | err = sendto (rawsock, |
300 | packet, | 306 | packet, |
301 | off, | 307 | off, |
302 | 0, | 308 | 0, |
303 | (struct sockaddr *)&dst, | 309 | (struct sockaddr *) &dst, |
304 | sizeof(dst)); | 310 | sizeof(dst)); |
305 | if (err < 0) | 311 | if (err < 0) |
306 | { | 312 | { |
307 | #if VERBOSE | 313 | #if VERBOSE |
308 | fprintf(stderr, | 314 | fprintf (stderr, |
309 | "sendto failed: %s\n", | 315 | "sendto failed: %s\n", |
310 | strerror(errno)); | 316 | strerror (errno)); |
311 | #endif | 317 | #endif |
312 | } | 318 | } |
313 | else if (sizeof(packet) != err) | 319 | else if (sizeof(packet) != err) |
314 | { | 320 | { |
315 | fprintf(stderr, | 321 | fprintf (stderr, |
316 | "Error: partial send of ICMP message\n"); | 322 | "Error: partial send of ICMP message\n"); |
317 | } | 323 | } |
318 | } | 324 | } |
319 | 325 | ||
320 | 326 | ||
@@ -322,37 +328,37 @@ send_icmp_echo(const struct in_addr *my_ip) | |||
322 | * Send a UDP message to the dummy IP. | 328 | * Send a UDP message to the dummy IP. |
323 | */ | 329 | */ |
324 | static void | 330 | static void |
325 | send_udp() | 331 | send_udp () |
326 | { | 332 | { |
327 | struct sockaddr_in dst; | 333 | struct sockaddr_in dst; |
328 | ssize_t err; | 334 | ssize_t err; |
329 | 335 | ||
330 | memset(&dst, 0, sizeof(dst)); | 336 | memset (&dst, 0, sizeof(dst)); |
331 | dst.sin_family = AF_INET; | 337 | dst.sin_family = AF_INET; |
332 | #if HAVE_SOCKADDR_IN_SIN_LEN | 338 | #if HAVE_SOCKADDR_IN_SIN_LEN |
333 | dst.sin_len = sizeof(struct sockaddr_in); | 339 | dst.sin_len = sizeof(struct sockaddr_in); |
334 | #endif | 340 | #endif |
335 | dst.sin_addr = dummy; | 341 | dst.sin_addr = dummy; |
336 | dst.sin_port = htons(NAT_TRAV_PORT); | 342 | dst.sin_port = htons (NAT_TRAV_PORT); |
337 | err = sendto(udpsock, | 343 | err = sendto (udpsock, |
338 | NULL, | 344 | NULL, |
339 | 0, | 345 | 0, |
340 | 0, | 346 | 0, |
341 | (struct sockaddr *)&dst, | 347 | (struct sockaddr *) &dst, |
342 | sizeof(dst)); | 348 | sizeof(dst)); |
343 | if (err < 0) | 349 | if (err < 0) |
344 | { | 350 | { |
345 | #if VERBOSE | 351 | #if VERBOSE |
346 | fprintf(stderr, | 352 | fprintf (stderr, |
347 | "sendto failed: %s\n", | 353 | "sendto failed: %s\n", |
348 | strerror(errno)); | 354 | strerror (errno)); |
349 | #endif | 355 | #endif |
350 | } | 356 | } |
351 | else if (0 != err) | 357 | else if (0 != err) |
352 | { | 358 | { |
353 | fprintf(stderr, | 359 | fprintf (stderr, |
354 | "Error: partial send of ICMP message\n"); | 360 | "Error: partial send of ICMP message\n"); |
355 | } | 361 | } |
356 | } | 362 | } |
357 | 363 | ||
358 | 364 | ||
@@ -360,7 +366,7 @@ send_udp() | |||
360 | * We've received an ICMP response. Process it. | 366 | * We've received an ICMP response. Process it. |
361 | */ | 367 | */ |
362 | static void | 368 | static void |
363 | process_icmp_response() | 369 | process_icmp_response () |
364 | { | 370 | { |
365 | char buf[65536]; | 371 | char buf[65536]; |
366 | ssize_t have; | 372 | ssize_t have; |
@@ -372,96 +378,96 @@ process_icmp_response() | |||
372 | size_t off; | 378 | size_t off; |
373 | uint16_t port; | 379 | uint16_t port; |
374 | 380 | ||
375 | have = read(icmpsock, buf, sizeof(buf)); | 381 | have = read (icmpsock, buf, sizeof(buf)); |
376 | if (-1 == have) | 382 | if (-1 == have) |
377 | { | 383 | { |
378 | fprintf(stderr, | 384 | fprintf (stderr, |
379 | "Error reading raw socket: %s\n", | 385 | "Error reading raw socket: %s\n", |
380 | strerror(errno)); | 386 | strerror (errno)); |
381 | return; | 387 | return; |
382 | } | 388 | } |
383 | #if VERBOSE | 389 | #if VERBOSE |
384 | fprintf(stderr, | 390 | fprintf (stderr, |
385 | "Received message of %u bytes\n", | 391 | "Received message of %u bytes\n", |
386 | (unsigned int)have); | 392 | (unsigned int) have); |
387 | #endif | 393 | #endif |
388 | if (have < | 394 | if (have < |
389 | (ssize_t)(sizeof(struct ip_header) + | 395 | (ssize_t) (sizeof(struct ip_header) |
390 | sizeof(struct icmp_ttl_exceeded_header) + | 396 | + sizeof(struct icmp_ttl_exceeded_header) |
391 | sizeof(struct ip_header))) | 397 | + sizeof(struct ip_header))) |
392 | { | 398 | { |
393 | /* malformed */ | 399 | /* malformed */ |
394 | return; | 400 | return; |
395 | } | 401 | } |
396 | off = 0; | 402 | off = 0; |
397 | GNUNET_memcpy(&ip_pkt, | 403 | GNUNET_memcpy (&ip_pkt, |
398 | &buf[off], | 404 | &buf[off], |
399 | sizeof(struct ip_header)); | 405 | sizeof(struct ip_header)); |
400 | off += sizeof(struct ip_header); | 406 | off += sizeof(struct ip_header); |
401 | GNUNET_memcpy(&icmp_ttl, | 407 | GNUNET_memcpy (&icmp_ttl, |
402 | &buf[off], | 408 | &buf[off], |
403 | sizeof(struct icmp_ttl_exceeded_header)); | 409 | sizeof(struct icmp_ttl_exceeded_header)); |
404 | off += sizeof(struct icmp_ttl_exceeded_header); | 410 | off += sizeof(struct icmp_ttl_exceeded_header); |
405 | if ((ICMP_TIME_EXCEEDED != icmp_ttl.type) || (0 != icmp_ttl.code)) | 411 | if ((ICMP_TIME_EXCEEDED != icmp_ttl.type) || (0 != icmp_ttl.code)) |
406 | { | 412 | { |
407 | /* different type than what we want */ | 413 | /* different type than what we want */ |
408 | return; | 414 | return; |
409 | } | 415 | } |
410 | /* grab source IP of 1st IP header */ | 416 | /* grab source IP of 1st IP header */ |
411 | source_ip.s_addr = ip_pkt.src_ip; | 417 | source_ip.s_addr = ip_pkt.src_ip; |
412 | 418 | ||
413 | /* skip 2nd IP header */ | 419 | /* skip 2nd IP header */ |
414 | GNUNET_memcpy(&ip_pkt, | 420 | GNUNET_memcpy (&ip_pkt, |
415 | &buf[off], | 421 | &buf[off], |
416 | sizeof(struct ip_header)); | 422 | sizeof(struct ip_header)); |
417 | off += sizeof(struct ip_header); | 423 | off += sizeof(struct ip_header); |
418 | 424 | ||
419 | switch (ip_pkt.proto) | 425 | switch (ip_pkt.proto) |
426 | { | ||
427 | case IPPROTO_ICMP: | ||
428 | if (have != | ||
429 | (sizeof(struct ip_header) * 2 | ||
430 | + sizeof(struct icmp_ttl_exceeded_header) | ||
431 | + sizeof(struct icmp_echo_header))) | ||
420 | { | 432 | { |
421 | case IPPROTO_ICMP: | 433 | /* malformed */ |
422 | if (have != | 434 | return; |
423 | (sizeof(struct ip_header) * 2 + | 435 | } |
424 | sizeof(struct icmp_ttl_exceeded_header) + | 436 | /* grab ICMP ECHO content */ |
425 | sizeof(struct icmp_echo_header))) | 437 | GNUNET_memcpy (&icmp_echo, |
426 | { | 438 | &buf[off], |
427 | /* malformed */ | 439 | sizeof(struct icmp_echo_header)); |
428 | return; | 440 | port = (uint16_t) ntohl (icmp_echo.reserved); |
429 | } | 441 | break; |
430 | /* grab ICMP ECHO content */ | 442 | |
431 | GNUNET_memcpy(&icmp_echo, | 443 | case IPPROTO_UDP: |
432 | &buf[off], | 444 | if (have != |
433 | sizeof(struct icmp_echo_header)); | 445 | (sizeof(struct ip_header) * 2 |
434 | port = (uint16_t)ntohl(icmp_echo.reserved); | 446 | + sizeof(struct icmp_ttl_exceeded_header) + sizeof(struct udp_header))) |
435 | break; | 447 | { |
436 | 448 | /* malformed */ | |
437 | case IPPROTO_UDP: | ||
438 | if (have != | ||
439 | (sizeof(struct ip_header) * 2 + | ||
440 | sizeof(struct icmp_ttl_exceeded_header) + sizeof(struct udp_header))) | ||
441 | { | ||
442 | /* malformed */ | ||
443 | return; | ||
444 | } | ||
445 | /* grab UDP content */ | ||
446 | GNUNET_memcpy(&udp_pkt, | ||
447 | &buf[off], | ||
448 | sizeof(struct udp_header)); | ||
449 | port = ntohs(udp_pkt.length); | ||
450 | break; | ||
451 | |||
452 | default: | ||
453 | /* different type than what we want */ | ||
454 | return; | 449 | return; |
455 | } | 450 | } |
451 | /* grab UDP content */ | ||
452 | GNUNET_memcpy (&udp_pkt, | ||
453 | &buf[off], | ||
454 | sizeof(struct udp_header)); | ||
455 | port = ntohs (udp_pkt.length); | ||
456 | break; | ||
457 | |||
458 | default: | ||
459 | /* different type than what we want */ | ||
460 | return; | ||
461 | } | ||
456 | 462 | ||
457 | if (port == 0) | 463 | if (port == 0) |
458 | fprintf(stdout, "%s\n", | 464 | fprintf (stdout, "%s\n", |
459 | inet_ntop(AF_INET, &source_ip, buf, sizeof(buf))); | 465 | inet_ntop (AF_INET, &source_ip, buf, sizeof(buf))); |
460 | else | 466 | else |
461 | fprintf(stdout, "%s:%u\n", | 467 | fprintf (stdout, "%s:%u\n", |
462 | inet_ntop(AF_INET, &source_ip, buf, sizeof(buf)), | 468 | inet_ntop (AF_INET, &source_ip, buf, sizeof(buf)), |
463 | (unsigned int)port); | 469 | (unsigned int) port); |
464 | fflush(stdout); | 470 | fflush (stdout); |
465 | } | 471 | } |
466 | 472 | ||
467 | 473 | ||
@@ -471,34 +477,34 @@ process_icmp_response() | |||
471 | * @return -1 on error, 0 on success | 477 | * @return -1 on error, 0 on success |
472 | */ | 478 | */ |
473 | static int | 479 | static int |
474 | setup_raw_socket() | 480 | setup_raw_socket () |
475 | { | 481 | { |
476 | const int one = 1; | 482 | const int one = 1; |
477 | 483 | ||
478 | if (-1 == | 484 | if (-1 == |
479 | setsockopt(rawsock, | 485 | setsockopt (rawsock, |
480 | SOL_SOCKET, | 486 | SOL_SOCKET, |
481 | SO_BROADCAST, | 487 | SO_BROADCAST, |
482 | (char *)&one, | 488 | (char *) &one, |
483 | sizeof(one))) | 489 | sizeof(one))) |
484 | { | 490 | { |
485 | fprintf(stderr, | 491 | fprintf (stderr, |
486 | "setsockopt failed: %s\n", | 492 | "setsockopt failed: %s\n", |
487 | strerror(errno)); | 493 | strerror (errno)); |
488 | return -1; | 494 | return -1; |
489 | } | 495 | } |
490 | if (-1 == | 496 | if (-1 == |
491 | setsockopt(rawsock, | 497 | setsockopt (rawsock, |
492 | IPPROTO_IP, | 498 | IPPROTO_IP, |
493 | IP_HDRINCL, | 499 | IP_HDRINCL, |
494 | (char *)&one, | 500 | (char *) &one, |
495 | sizeof(one))) | 501 | sizeof(one))) |
496 | { | 502 | { |
497 | fprintf(stderr, | 503 | fprintf (stderr, |
498 | "setsockopt failed: %s\n", | 504 | "setsockopt failed: %s\n", |
499 | strerror(errno)); | 505 | strerror (errno)); |
500 | return -1; | 506 | return -1; |
501 | } | 507 | } |
502 | return 0; | 508 | return 0; |
503 | } | 509 | } |
504 | 510 | ||
@@ -510,45 +516,45 @@ setup_raw_socket() | |||
510 | * @return -1 on error | 516 | * @return -1 on error |
511 | */ | 517 | */ |
512 | static int | 518 | static int |
513 | make_udp_socket(const struct in_addr *my_ip) | 519 | make_udp_socket (const struct in_addr *my_ip) |
514 | { | 520 | { |
515 | int ret; | 521 | int ret; |
516 | struct sockaddr_in addr; | 522 | struct sockaddr_in addr; |
517 | 523 | ||
518 | ret = socket(AF_INET, SOCK_DGRAM, 0); | 524 | ret = socket (AF_INET, SOCK_DGRAM, 0); |
519 | if (-1 == ret) | 525 | if (-1 == ret) |
520 | { | 526 | { |
521 | fprintf(stderr, | 527 | fprintf (stderr, |
522 | "Error opening UDP socket: %s\n", | 528 | "Error opening UDP socket: %s\n", |
523 | strerror(errno)); | 529 | strerror (errno)); |
524 | return -1; | 530 | return -1; |
525 | } | 531 | } |
526 | memset(&addr, 0, sizeof(addr)); | 532 | memset (&addr, 0, sizeof(addr)); |
527 | addr.sin_family = AF_INET; | 533 | addr.sin_family = AF_INET; |
528 | #if HAVE_SOCKADDR_IN_SIN_LEN | 534 | #if HAVE_SOCKADDR_IN_SIN_LEN |
529 | addr.sin_len = sizeof(struct sockaddr_in); | 535 | addr.sin_len = sizeof(struct sockaddr_in); |
530 | #endif | 536 | #endif |
531 | addr.sin_addr = *my_ip; | 537 | addr.sin_addr = *my_ip; |
532 | addr.sin_port = htons(NAT_TRAV_PORT); | 538 | addr.sin_port = htons (NAT_TRAV_PORT); |
533 | 539 | ||
534 | if (0 != bind(ret, | 540 | if (0 != bind (ret, |
535 | (struct sockaddr *)&addr, | 541 | (struct sockaddr *) &addr, |
536 | sizeof(addr))) | 542 | sizeof(addr))) |
537 | { | 543 | { |
538 | fprintf(stderr, | 544 | fprintf (stderr, |
539 | "Error binding UDP socket to port %u: %s\n", | 545 | "Error binding UDP socket to port %u: %s\n", |
540 | NAT_TRAV_PORT, | 546 | NAT_TRAV_PORT, |
541 | strerror(errno)); | 547 | strerror (errno)); |
542 | (void)close(ret); | 548 | (void) close (ret); |
543 | return -1; | 549 | return -1; |
544 | } | 550 | } |
545 | return ret; | 551 | return ret; |
546 | } | 552 | } |
547 | 553 | ||
548 | 554 | ||
549 | int | 555 | int |
550 | main(int argc, | 556 | main (int argc, |
551 | char *const *argv) | 557 | char *const *argv) |
552 | { | 558 | { |
553 | struct in_addr external; | 559 | struct in_addr external; |
554 | fd_set rs; | 560 | fd_set rs; |
@@ -560,147 +566,147 @@ main(int argc, | |||
560 | int global_ret; | 566 | int global_ret; |
561 | 567 | ||
562 | /* Create an ICMP raw socket for reading (we'll check errors later) */ | 568 | /* Create an ICMP raw socket for reading (we'll check errors later) */ |
563 | icmpsock = socket(AF_INET, | 569 | icmpsock = socket (AF_INET, |
564 | SOCK_RAW, | 570 | SOCK_RAW, |
565 | IPPROTO_ICMP); | 571 | IPPROTO_ICMP); |
566 | icmp_eno = errno; | 572 | icmp_eno = errno; |
567 | 573 | ||
568 | /* Create an (ICMP) raw socket for writing (we'll check errors later) */ | 574 | /* Create an (ICMP) raw socket for writing (we'll check errors later) */ |
569 | rawsock = socket(AF_INET, | 575 | rawsock = socket (AF_INET, |
570 | SOCK_RAW, | 576 | SOCK_RAW, |
571 | IPPROTO_RAW); | 577 | IPPROTO_RAW); |
572 | raw_eno = errno; | 578 | raw_eno = errno; |
573 | udpsock = -1; | 579 | udpsock = -1; |
574 | 580 | ||
575 | /* drop root rights */ | 581 | /* drop root rights */ |
576 | uid = getuid(); | 582 | uid = getuid (); |
577 | #ifdef HAVE_SETRESUID | 583 | #ifdef HAVE_SETRESUID |
578 | if (0 != setresuid(uid, uid, uid)) | 584 | if (0 != setresuid (uid, uid, uid)) |
579 | { | 585 | { |
580 | fprintf(stderr, | 586 | fprintf (stderr, |
581 | "Failed to setresuid: %s\n", | 587 | "Failed to setresuid: %s\n", |
582 | strerror(errno)); | 588 | strerror (errno)); |
583 | global_ret = 1; | 589 | global_ret = 1; |
584 | goto error_exit; | 590 | goto error_exit; |
585 | } | 591 | } |
586 | #else | 592 | #else |
587 | if (0 != (setuid(uid) | seteuid(uid))) | 593 | if (0 != (setuid (uid) | seteuid (uid))) |
588 | { | 594 | { |
589 | fprintf(stderr, | 595 | fprintf (stderr, |
590 | "Failed to setuid: %s\n", | 596 | "Failed to setuid: %s\n", |
591 | strerror(errno)); | 597 | strerror (errno)); |
592 | global_ret = 2; | 598 | global_ret = 2; |
593 | goto error_exit; | 599 | goto error_exit; |
594 | } | 600 | } |
595 | #endif | 601 | #endif |
596 | 602 | ||
597 | /* Now that we run without root rights, we can do error checking... */ | 603 | /* Now that we run without root rights, we can do error checking... */ |
598 | if (2 != argc) | 604 | if (2 != argc) |
599 | { | 605 | { |
600 | fprintf(stderr, | 606 | fprintf (stderr, |
601 | "This program must be started with our (internal NAT) IP as the only argument.\n"); | 607 | "This program must be started with our (internal NAT) IP as the only argument.\n"); |
602 | global_ret = 3; | 608 | global_ret = 3; |
603 | goto error_exit; | 609 | goto error_exit; |
604 | } | 610 | } |
605 | if (1 != inet_pton(AF_INET, argv[1], &external)) | 611 | if (1 != inet_pton (AF_INET, argv[1], &external)) |
606 | { | 612 | { |
607 | fprintf(stderr, | 613 | fprintf (stderr, |
608 | "Error parsing IPv4 address: %s\n", | 614 | "Error parsing IPv4 address: %s\n", |
609 | strerror(errno)); | 615 | strerror (errno)); |
610 | global_ret = 4; | 616 | global_ret = 4; |
611 | goto error_exit; | 617 | goto error_exit; |
612 | } | 618 | } |
613 | if (1 != inet_pton(AF_INET, DUMMY_IP, &dummy)) | 619 | if (1 != inet_pton (AF_INET, DUMMY_IP, &dummy)) |
614 | { | 620 | { |
615 | fprintf(stderr, | 621 | fprintf (stderr, |
616 | "Internal error converting dummy IP to binary.\n"); | 622 | "Internal error converting dummy IP to binary.\n"); |
617 | global_ret = 5; | 623 | global_ret = 5; |
618 | goto error_exit; | 624 | goto error_exit; |
619 | } | 625 | } |
620 | 626 | ||
621 | /* error checking icmpsock */ | 627 | /* error checking icmpsock */ |
622 | if (-1 == icmpsock) | 628 | if (-1 == icmpsock) |
623 | { | 629 | { |
624 | fprintf(stderr, | 630 | fprintf (stderr, |
625 | "Error opening RAW socket: %s\n", | 631 | "Error opening RAW socket: %s\n", |
626 | strerror(icmp_eno)); | 632 | strerror (icmp_eno)); |
627 | global_ret = 6; | 633 | global_ret = 6; |
628 | goto error_exit; | 634 | goto error_exit; |
629 | } | 635 | } |
630 | if (icmpsock >= FD_SETSIZE) | 636 | if (icmpsock >= FD_SETSIZE) |
631 | { | 637 | { |
632 | /* this could happen if we were started with a large number of already-open | 638 | /* this could happen if we were started with a large number of already-open |
633 | file descriptors... */ | 639 | file descriptors... */ |
634 | fprintf(stderr, | 640 | fprintf (stderr, |
635 | "Socket number too large (%d > %u)\n", | 641 | "Socket number too large (%d > %u)\n", |
636 | icmpsock, | 642 | icmpsock, |
637 | (unsigned int)FD_SETSIZE); | 643 | (unsigned int) FD_SETSIZE); |
638 | global_ret = 7; | 644 | global_ret = 7; |
639 | goto error_exit; | 645 | goto error_exit; |
640 | } | 646 | } |
641 | 647 | ||
642 | /* error checking rawsock */ | 648 | /* error checking rawsock */ |
643 | if (-1 == rawsock) | 649 | if (-1 == rawsock) |
644 | { | 650 | { |
645 | fprintf(stderr, | 651 | fprintf (stderr, |
646 | "Error opening RAW socket: %s\n", | 652 | "Error opening RAW socket: %s\n", |
647 | strerror(raw_eno)); | 653 | strerror (raw_eno)); |
648 | global_ret = 8; | 654 | global_ret = 8; |
649 | goto error_exit; | 655 | goto error_exit; |
650 | } | 656 | } |
651 | /* no need to check 'rawsock' against FD_SETSIZE as it is never used | 657 | /* no need to check 'rawsock' against FD_SETSIZE as it is never used |
652 | with 'select' */ | 658 | with 'select' */ |
653 | 659 | ||
654 | if (0 != setup_raw_socket()) | 660 | if (0 != setup_raw_socket ()) |
655 | { | 661 | { |
656 | global_ret = 9; | 662 | global_ret = 9; |
657 | goto error_exit; | 663 | goto error_exit; |
658 | } | 664 | } |
659 | 665 | ||
660 | if (-1 == (udpsock = make_udp_socket(&external))) | 666 | if (-1 == (udpsock = make_udp_socket (&external))) |
661 | { | 667 | { |
662 | global_ret = 10; | 668 | global_ret = 10; |
663 | goto error_exit; | 669 | goto error_exit; |
664 | } | 670 | } |
665 | 671 | ||
666 | alt = 0; | 672 | alt = 0; |
667 | while (1) | 673 | while (1) |
674 | { | ||
675 | FD_ZERO (&rs); | ||
676 | FD_SET (icmpsock, &rs); | ||
677 | tv.tv_sec = 0; | ||
678 | tv.tv_usec = ICMP_SEND_FREQUENCY_MS * 1000; | ||
679 | if (-1 == select (icmpsock + 1, &rs, NULL, NULL, &tv)) | ||
680 | { | ||
681 | if (errno == EINTR) | ||
682 | continue; | ||
683 | fprintf (stderr, | ||
684 | "select failed: %s\n", | ||
685 | strerror (errno)); | ||
686 | break; | ||
687 | } | ||
688 | if (1 == getppid ()) /* Check the parent process id, if 1 the parent has died, so we should die too */ | ||
689 | break; | ||
690 | if (FD_ISSET (icmpsock, &rs)) | ||
668 | { | 691 | { |
669 | FD_ZERO(&rs); | 692 | process_icmp_response (); |
670 | FD_SET(icmpsock, &rs); | 693 | continue; |
671 | tv.tv_sec = 0; | ||
672 | tv.tv_usec = ICMP_SEND_FREQUENCY_MS * 1000; | ||
673 | if (-1 == select(icmpsock + 1, &rs, NULL, NULL, &tv)) | ||
674 | { | ||
675 | if (errno == EINTR) | ||
676 | continue; | ||
677 | fprintf(stderr, | ||
678 | "select failed: %s\n", | ||
679 | strerror(errno)); | ||
680 | break; | ||
681 | } | ||
682 | if (1 == getppid()) /* Check the parent process id, if 1 the parent has died, so we should die too */ | ||
683 | break; | ||
684 | if (FD_ISSET(icmpsock, &rs)) | ||
685 | { | ||
686 | process_icmp_response(); | ||
687 | continue; | ||
688 | } | ||
689 | if (0 == (++alt % 2)) | ||
690 | send_icmp_echo(&external); | ||
691 | else | ||
692 | send_udp(); | ||
693 | } | 694 | } |
695 | if (0 == (++alt % 2)) | ||
696 | send_icmp_echo (&external); | ||
697 | else | ||
698 | send_udp (); | ||
699 | } | ||
694 | 700 | ||
695 | /* select failed (internal error or OS out of resources) */ | 701 | /* select failed (internal error or OS out of resources) */ |
696 | global_ret = 11; | 702 | global_ret = 11; |
697 | error_exit: | 703 | error_exit: |
698 | if (-1 != icmpsock) | 704 | if (-1 != icmpsock) |
699 | (void)close(icmpsock); | 705 | (void) close (icmpsock); |
700 | if (-1 != rawsock) | 706 | if (-1 != rawsock) |
701 | (void)close(rawsock); | 707 | (void) close (rawsock); |
702 | if (-1 != udpsock) | 708 | if (-1 != udpsock) |
703 | (void)close(udpsock); | 709 | (void) close (udpsock); |
704 | return global_ret; | 710 | return global_ret; |
705 | } | 711 | } |
706 | 712 | ||
diff --git a/src/nat/gnunet-nat.c b/src/nat/gnunet-nat.c index d82898f56..857ce5093 100644 --- a/src/nat/gnunet-nat.c +++ b/src/nat/gnunet-nat.c | |||
@@ -95,13 +95,13 @@ static struct GNUNET_SCHEDULER_Task *rtask; | |||
95 | * terminate. | 95 | * terminate. |
96 | */ | 96 | */ |
97 | static void | 97 | static void |
98 | test_finished() | 98 | test_finished () |
99 | { | 99 | { |
100 | if (NULL != nh) | 100 | if (NULL != nh) |
101 | return; | 101 | return; |
102 | if (NULL != rtask) | 102 | if (NULL != rtask) |
103 | return; | 103 | return; |
104 | GNUNET_SCHEDULER_shutdown(); | 104 | GNUNET_SCHEDULER_shutdown (); |
105 | } | 105 | } |
106 | 106 | ||
107 | 107 | ||
@@ -119,21 +119,21 @@ test_finished() | |||
119 | * @param addrlen actual length of the @a addr | 119 | * @param addrlen actual length of the @a addr |
120 | */ | 120 | */ |
121 | static void | 121 | static void |
122 | address_cb(void *cls, | 122 | address_cb (void *cls, |
123 | void **app_ctx, | 123 | void **app_ctx, |
124 | int add_remove, | 124 | int add_remove, |
125 | enum GNUNET_NAT_AddressClass ac, | 125 | enum GNUNET_NAT_AddressClass ac, |
126 | const struct sockaddr *addr, | 126 | const struct sockaddr *addr, |
127 | socklen_t addrlen) | 127 | socklen_t addrlen) |
128 | { | 128 | { |
129 | (void)cls; | 129 | (void) cls; |
130 | (void)app_ctx; | 130 | (void) app_ctx; |
131 | 131 | ||
132 | fprintf(stdout, | 132 | fprintf (stdout, |
133 | "%s %s (%d)\n", | 133 | "%s %s (%d)\n", |
134 | add_remove ? "+" : "-", | 134 | add_remove ? "+" : "-", |
135 | GNUNET_a2s(addr, addrlen), | 135 | GNUNET_a2s (addr, addrlen), |
136 | (int)ac); | 136 | (int) ac); |
137 | } | 137 | } |
138 | 138 | ||
139 | 139 | ||
@@ -147,13 +147,13 @@ address_cb(void *cls, | |||
147 | * @param remote_addrlen actual length of the @a remote_addr | 147 | * @param remote_addrlen actual length of the @a remote_addr |
148 | */ | 148 | */ |
149 | static void | 149 | static void |
150 | reversal_cb(void *cls, | 150 | reversal_cb (void *cls, |
151 | const struct sockaddr *remote_addr, | 151 | const struct sockaddr *remote_addr, |
152 | socklen_t remote_addrlen) | 152 | socklen_t remote_addrlen) |
153 | { | 153 | { |
154 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | 154 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, |
155 | "Connection reversal requested by %s\n", | 155 | "Connection reversal requested by %s\n", |
156 | GNUNET_a2s(remote_addr, remote_addrlen)); | 156 | GNUNET_a2s (remote_addr, remote_addrlen)); |
157 | } | 157 | } |
158 | 158 | ||
159 | 159 | ||
@@ -163,23 +163,23 @@ reversal_cb(void *cls, | |||
163 | * @param cls NULL | 163 | * @param cls NULL |
164 | */ | 164 | */ |
165 | static void | 165 | static void |
166 | do_shutdown(void *cls) | 166 | do_shutdown (void *cls) |
167 | { | 167 | { |
168 | if (NULL != nh) | 168 | if (NULL != nh) |
169 | { | 169 | { |
170 | GNUNET_NAT_unregister(nh); | 170 | GNUNET_NAT_unregister (nh); |
171 | nh = NULL; | 171 | nh = NULL; |
172 | } | 172 | } |
173 | if (NULL != ls) | 173 | if (NULL != ls) |
174 | { | 174 | { |
175 | GNUNET_NETWORK_socket_close(ls); | 175 | GNUNET_NETWORK_socket_close (ls); |
176 | ls = NULL; | 176 | ls = NULL; |
177 | } | 177 | } |
178 | if (NULL != rtask) | 178 | if (NULL != rtask) |
179 | { | 179 | { |
180 | GNUNET_SCHEDULER_cancel(rtask); | 180 | GNUNET_SCHEDULER_cancel (rtask); |
181 | rtask = NULL; | 181 | rtask = NULL; |
182 | } | 182 | } |
183 | } | 183 | } |
184 | 184 | ||
185 | 185 | ||
@@ -187,45 +187,45 @@ do_shutdown(void *cls) | |||
187 | * Task to receive incoming packets for STUN processing. | 187 | * Task to receive incoming packets for STUN processing. |
188 | */ | 188 | */ |
189 | static void | 189 | static void |
190 | stun_read_task(void *cls) | 190 | stun_read_task (void *cls) |
191 | { | 191 | { |
192 | ssize_t size; | 192 | ssize_t size; |
193 | 193 | ||
194 | rtask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 194 | rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
195 | ls, | 195 | ls, |
196 | &stun_read_task, | 196 | &stun_read_task, |
197 | NULL); | 197 | NULL); |
198 | size = GNUNET_NETWORK_socket_recvfrom_amount(ls); | 198 | size = GNUNET_NETWORK_socket_recvfrom_amount (ls); |
199 | if (size > 0) | 199 | if (size > 0) |
200 | { | 200 | { |
201 | GNUNET_break(0); | 201 | GNUNET_break (0); |
202 | GNUNET_SCHEDULER_shutdown(); | 202 | GNUNET_SCHEDULER_shutdown (); |
203 | global_ret = 1; | 203 | global_ret = 1; |
204 | return; | 204 | return; |
205 | } | 205 | } |
206 | { | 206 | { |
207 | char buf[size + 1]; | 207 | char buf[size + 1]; |
208 | struct sockaddr_storage sa; | 208 | struct sockaddr_storage sa; |
209 | socklen_t salen = sizeof(sa); | 209 | socklen_t salen = sizeof(sa); |
210 | ssize_t ret; | 210 | ssize_t ret; |
211 | 211 | ||
212 | ret = GNUNET_NETWORK_socket_recvfrom(ls, | 212 | ret = GNUNET_NETWORK_socket_recvfrom (ls, |
213 | buf, | 213 | buf, |
214 | size + 1, | 214 | size + 1, |
215 | (struct sockaddr *)&sa, | 215 | (struct sockaddr *) &sa, |
216 | &salen); | 216 | &salen); |
217 | if (ret != size) | 217 | if (ret != size) |
218 | { | 218 | { |
219 | GNUNET_break(0); | 219 | GNUNET_break (0); |
220 | GNUNET_SCHEDULER_shutdown(); | 220 | GNUNET_SCHEDULER_shutdown (); |
221 | global_ret = 1; | 221 | global_ret = 1; |
222 | return; | 222 | return; |
223 | } | 223 | } |
224 | (void)GNUNET_NAT_stun_handle_packet(nh, | 224 | (void) GNUNET_NAT_stun_handle_packet (nh, |
225 | (const struct sockaddr *)&sa, | 225 | (const struct sockaddr *) &sa, |
226 | salen, | 226 | salen, |
227 | buf, | 227 | buf, |
228 | ret); | 228 | ret); |
229 | } | 229 | } |
230 | } | 230 | } |
231 | 231 | ||
@@ -239,10 +239,10 @@ stun_read_task(void *cls) | |||
239 | * @param c configuration | 239 | * @param c configuration |
240 | */ | 240 | */ |
241 | static void | 241 | static void |
242 | run(void *cls, | 242 | run (void *cls, |
243 | char *const *args, | 243 | char *const *args, |
244 | const char *cfgfile, | 244 | const char *cfgfile, |
245 | const struct GNUNET_CONFIGURATION_Handle *c) | 245 | const struct GNUNET_CONFIGURATION_Handle *c) |
246 | { | 246 | { |
247 | uint8_t af; | 247 | uint8_t af; |
248 | struct sockaddr *local_sa; | 248 | struct sockaddr *local_sa; |
@@ -251,156 +251,156 @@ run(void *cls, | |||
251 | size_t remote_len; | 251 | size_t remote_len; |
252 | 252 | ||
253 | if (use_tcp && use_udp) | 253 | if (use_tcp && use_udp) |
254 | { | 254 | { |
255 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, "Cannot use TCP and UDP\n"); | 255 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Cannot use TCP and UDP\n"); |
256 | global_ret = 1; | 256 | global_ret = 1; |
257 | return; | 257 | return; |
258 | } | 258 | } |
259 | proto = 0; | 259 | proto = 0; |
260 | if (use_tcp) | 260 | if (use_tcp) |
261 | proto = IPPROTO_TCP; | 261 | proto = IPPROTO_TCP; |
262 | if (use_udp) | 262 | if (use_udp) |
263 | proto = IPPROTO_UDP; | 263 | proto = IPPROTO_UDP; |
264 | 264 | ||
265 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL); | 265 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); |
266 | 266 | ||
267 | if (0 == proto) | 267 | if (0 == proto) |
268 | { | 268 | { |
269 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, "Must specify either TCP or UDP\n"); | 269 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Must specify either TCP or UDP\n"); |
270 | global_ret = 1; | 270 | global_ret = 1; |
271 | return; | 271 | return; |
272 | } | 272 | } |
273 | local_len = 0; | 273 | local_len = 0; |
274 | local_sa = NULL; | 274 | local_sa = NULL; |
275 | remote_len = 0; | 275 | remote_len = 0; |
276 | remote_sa = NULL; | 276 | remote_sa = NULL; |
277 | if (NULL != local_addr) | 277 | if (NULL != local_addr) |
278 | { | ||
279 | local_len = | ||
280 | (socklen_t) GNUNET_STRINGS_parse_socket_addr (local_addr, &af, &local_sa); | ||
281 | if (0 == local_len) | ||
278 | { | 282 | { |
279 | local_len = | 283 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, |
280 | (socklen_t)GNUNET_STRINGS_parse_socket_addr(local_addr, &af, &local_sa); | 284 | "Invalid socket address `%s'\n", |
281 | if (0 == local_len) | 285 | local_addr); |
282 | { | 286 | goto fail_and_shutdown; |
283 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | ||
284 | "Invalid socket address `%s'\n", | ||
285 | local_addr); | ||
286 | goto fail_and_shutdown; | ||
287 | } | ||
288 | } | 287 | } |
288 | } | ||
289 | 289 | ||
290 | if (NULL != remote_addr) | 290 | if (NULL != remote_addr) |
291 | { | ||
292 | remote_len = | ||
293 | GNUNET_STRINGS_parse_socket_addr (remote_addr, &af, &remote_sa); | ||
294 | if (0 == remote_len) | ||
291 | { | 295 | { |
292 | remote_len = | 296 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, |
293 | GNUNET_STRINGS_parse_socket_addr(remote_addr, &af, &remote_sa); | 297 | "Invalid socket address `%s'\n", |
294 | if (0 == remote_len) | 298 | remote_addr); |
295 | { | 299 | goto fail_and_shutdown; |
296 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | ||
297 | "Invalid socket address `%s'\n", | ||
298 | remote_addr); | ||
299 | goto fail_and_shutdown; | ||
300 | } | ||
301 | } | 300 | } |
301 | } | ||
302 | 302 | ||
303 | if (NULL != local_addr) | 303 | if (NULL != local_addr) |
304 | { | ||
305 | if (NULL == section_name) | ||
306 | section_name = GNUNET_strdup ("undefined"); | ||
307 | nh = GNUNET_NAT_register (c, | ||
308 | section_name, | ||
309 | proto, | ||
310 | 1, | ||
311 | (const struct sockaddr **) &local_sa, | ||
312 | &local_len, | ||
313 | &address_cb, | ||
314 | (listen_reversal) ? &reversal_cb : NULL, | ||
315 | NULL); | ||
316 | } | ||
317 | else if (listen_reversal) | ||
318 | { | ||
319 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, | ||
320 | "Use of `-W` only effective in combination with `-i`\n"); | ||
321 | goto fail_and_shutdown; | ||
322 | } | ||
323 | |||
324 | if (NULL != remote_addr) | ||
325 | { | ||
326 | int ret; | ||
327 | |||
328 | if ((NULL == nh) || (sizeof(struct sockaddr_in) != local_len)) | ||
304 | { | 329 | { |
305 | if (NULL == section_name) | 330 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, |
306 | section_name = GNUNET_strdup("undefined"); | 331 | "Require IPv4 local address to initiate connection reversal\n"); |
307 | nh = GNUNET_NAT_register(c, | 332 | goto fail_and_shutdown; |
308 | section_name, | ||
309 | proto, | ||
310 | 1, | ||
311 | (const struct sockaddr **)&local_sa, | ||
312 | &local_len, | ||
313 | &address_cb, | ||
314 | (listen_reversal) ? &reversal_cb : NULL, | ||
315 | NULL); | ||
316 | } | 333 | } |
317 | else if (listen_reversal) | 334 | if (sizeof(struct sockaddr_in) != remote_len) |
318 | { | 335 | { |
319 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | 336 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, |
320 | "Use of `-W` only effective in combination with `-i`\n"); | 337 | "Require IPv4 reversal target address\n"); |
321 | goto fail_and_shutdown; | 338 | goto fail_and_shutdown; |
322 | } | 339 | } |
323 | 340 | GNUNET_assert (AF_INET == local_sa->sa_family); | |
324 | if (NULL != remote_addr) | 341 | GNUNET_assert (AF_INET == remote_sa->sa_family); |
342 | ret = GNUNET_NAT_request_reversal (nh, | ||
343 | (const struct sockaddr_in *) local_sa, | ||
344 | (const struct sockaddr_in *) remote_sa); | ||
345 | switch (ret) | ||
325 | { | 346 | { |
326 | int ret; | 347 | case GNUNET_SYSERR: |
327 | 348 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, | |
328 | if ((NULL == nh) || (sizeof(struct sockaddr_in) != local_len)) | 349 | "Connection reversal internal error\n"); |
329 | { | 350 | break; |
330 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | 351 | |
331 | "Require IPv4 local address to initiate connection reversal\n"); | 352 | case GNUNET_NO: |
332 | goto fail_and_shutdown; | 353 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, |
333 | } | 354 | "Connection reversal unavailable\n"); |
334 | if (sizeof(struct sockaddr_in) != remote_len) | 355 | break; |
335 | { | 356 | |
336 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | 357 | case GNUNET_OK: |
337 | "Require IPv4 reversal target address\n"); | 358 | /* operation in progress */ |
338 | goto fail_and_shutdown; | 359 | break; |
339 | } | ||
340 | GNUNET_assert(AF_INET == local_sa->sa_family); | ||
341 | GNUNET_assert(AF_INET == remote_sa->sa_family); | ||
342 | ret = GNUNET_NAT_request_reversal(nh, | ||
343 | (const struct sockaddr_in *)local_sa, | ||
344 | (const struct sockaddr_in *)remote_sa); | ||
345 | switch (ret) | ||
346 | { | ||
347 | case GNUNET_SYSERR: | ||
348 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | ||
349 | "Connection reversal internal error\n"); | ||
350 | break; | ||
351 | |||
352 | case GNUNET_NO: | ||
353 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | ||
354 | "Connection reversal unavailable\n"); | ||
355 | break; | ||
356 | |||
357 | case GNUNET_OK: | ||
358 | /* operation in progress */ | ||
359 | break; | ||
360 | } | ||
361 | } | 360 | } |
361 | } | ||
362 | 362 | ||
363 | if (do_stun) | 363 | if (do_stun) |
364 | { | ||
365 | if (NULL == local_addr) | ||
366 | { | ||
367 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, | ||
368 | "Require local address to support STUN requests\n"); | ||
369 | goto fail_and_shutdown; | ||
370 | } | ||
371 | if (IPPROTO_UDP != proto) | ||
372 | { | ||
373 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "STUN only supported over UDP\n"); | ||
374 | goto fail_and_shutdown; | ||
375 | } | ||
376 | ls = GNUNET_NETWORK_socket_create (af, SOCK_DGRAM, IPPROTO_UDP); | ||
377 | if (NULL == ls) | ||
378 | { | ||
379 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Failed to create socket\n"); | ||
380 | goto fail_and_shutdown; | ||
381 | } | ||
382 | if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ls, local_sa, local_len)) | ||
364 | { | 383 | { |
365 | if (NULL == local_addr) | 384 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
366 | { | 385 | "Failed to bind to %s: %s\n", |
367 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | 386 | GNUNET_a2s (local_sa, local_len), |
368 | "Require local address to support STUN requests\n"); | 387 | strerror (errno)); |
369 | goto fail_and_shutdown; | 388 | goto fail_and_shutdown; |
370 | } | ||
371 | if (IPPROTO_UDP != proto) | ||
372 | { | ||
373 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, "STUN only supported over UDP\n"); | ||
374 | goto fail_and_shutdown; | ||
375 | } | ||
376 | ls = GNUNET_NETWORK_socket_create(af, SOCK_DGRAM, IPPROTO_UDP); | ||
377 | if (NULL == ls) | ||
378 | { | ||
379 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, "Failed to create socket\n"); | ||
380 | goto fail_and_shutdown; | ||
381 | } | ||
382 | if (GNUNET_OK != GNUNET_NETWORK_socket_bind(ls, local_sa, local_len)) | ||
383 | { | ||
384 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
385 | "Failed to bind to %s: %s\n", | ||
386 | GNUNET_a2s(local_sa, local_len), | ||
387 | strerror(errno)); | ||
388 | goto fail_and_shutdown; | ||
389 | } | ||
390 | rtask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
391 | ls, | ||
392 | &stun_read_task, | ||
393 | NULL); | ||
394 | } | 389 | } |
395 | GNUNET_free_non_null(remote_sa); | 390 | rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
396 | GNUNET_free_non_null(local_sa); | 391 | ls, |
397 | test_finished(); | 392 | &stun_read_task, |
393 | NULL); | ||
394 | } | ||
395 | GNUNET_free_non_null (remote_sa); | ||
396 | GNUNET_free_non_null (local_sa); | ||
397 | test_finished (); | ||
398 | return; | 398 | return; |
399 | fail_and_shutdown: | 399 | fail_and_shutdown: |
400 | global_ret = 1; | 400 | global_ret = 1; |
401 | GNUNET_SCHEDULER_shutdown(); | 401 | GNUNET_SCHEDULER_shutdown (); |
402 | GNUNET_free_non_null(remote_sa); | 402 | GNUNET_free_non_null (remote_sa); |
403 | GNUNET_free_non_null(local_sa); | 403 | GNUNET_free_non_null (local_sa); |
404 | } | 404 | } |
405 | 405 | ||
406 | 406 | ||
@@ -412,63 +412,63 @@ fail_and_shutdown: | |||
412 | * @return 0 on success, -1 on error | 412 | * @return 0 on success, -1 on error |
413 | */ | 413 | */ |
414 | int | 414 | int |
415 | main(int argc, char *const argv[]) | 415 | main (int argc, char *const argv[]) |
416 | { | 416 | { |
417 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 417 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
418 | GNUNET_GETOPT_option_string( | 418 | GNUNET_GETOPT_option_string ( |
419 | 'i', | 419 | 'i', |
420 | "in", | 420 | "in", |
421 | "ADDRESS", | 421 | "ADDRESS", |
422 | gettext_noop("which IP and port are we locally using to bind/listen to"), | 422 | gettext_noop ("which IP and port are we locally using to bind/listen to"), |
423 | &local_addr), | 423 | &local_addr), |
424 | 424 | ||
425 | GNUNET_GETOPT_option_string( | 425 | GNUNET_GETOPT_option_string ( |
426 | 'r', | 426 | 'r', |
427 | "remote", | 427 | "remote", |
428 | "ADDRESS", | 428 | "ADDRESS", |
429 | gettext_noop( | 429 | gettext_noop ( |
430 | "which remote IP and port should be asked for connection reversal"), | 430 | "which remote IP and port should be asked for connection reversal"), |
431 | &remote_addr), | 431 | &remote_addr), |
432 | 432 | ||
433 | GNUNET_GETOPT_option_string( | 433 | GNUNET_GETOPT_option_string ( |
434 | 'S', | 434 | 'S', |
435 | "section", | 435 | "section", |
436 | NULL, | 436 | NULL, |
437 | gettext_noop( | 437 | gettext_noop ( |
438 | "name of configuration section to find additional options, such as manual host punching data"), | 438 | "name of configuration section to find additional options, such as manual host punching data"), |
439 | §ion_name), | 439 | §ion_name), |
440 | 440 | ||
441 | GNUNET_GETOPT_option_flag('s', | 441 | GNUNET_GETOPT_option_flag ('s', |
442 | "stun", | 442 | "stun", |
443 | gettext_noop("enable STUN processing"), | 443 | gettext_noop ("enable STUN processing"), |
444 | &do_stun), | 444 | &do_stun), |
445 | 445 | ||
446 | GNUNET_GETOPT_option_flag('t', "tcp", gettext_noop("use TCP"), &use_tcp), | 446 | GNUNET_GETOPT_option_flag ('t', "tcp", gettext_noop ("use TCP"), &use_tcp), |
447 | 447 | ||
448 | GNUNET_GETOPT_option_flag('u', "udp", gettext_noop("use UDP"), &use_udp), | 448 | GNUNET_GETOPT_option_flag ('u', "udp", gettext_noop ("use UDP"), &use_udp), |
449 | 449 | ||
450 | GNUNET_GETOPT_option_flag('W', | 450 | GNUNET_GETOPT_option_flag ('W', |
451 | "watch", | 451 | "watch", |
452 | gettext_noop( | 452 | gettext_noop ( |
453 | "watch for connection reversal requests"), | 453 | "watch for connection reversal requests"), |
454 | &listen_reversal), | 454 | &listen_reversal), |
455 | GNUNET_GETOPT_OPTION_END | 455 | GNUNET_GETOPT_OPTION_END |
456 | }; | 456 | }; |
457 | 457 | ||
458 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) | 458 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) |
459 | return 2; | 459 | return 2; |
460 | if (GNUNET_OK != | 460 | if (GNUNET_OK != |
461 | GNUNET_PROGRAM_run(argc, | 461 | GNUNET_PROGRAM_run (argc, |
462 | argv, | 462 | argv, |
463 | "gnunet-nat [options]", | 463 | "gnunet-nat [options]", |
464 | _("GNUnet NAT traversal autoconfigure daemon"), | 464 | _ ("GNUnet NAT traversal autoconfigure daemon"), |
465 | options, | 465 | options, |
466 | &run, | 466 | &run, |
467 | NULL)) | 467 | NULL)) |
468 | { | 468 | { |
469 | global_ret = 1; | 469 | global_ret = 1; |
470 | } | 470 | } |
471 | GNUNET_free((void *)argv); | 471 | GNUNET_free ((void *) argv); |
472 | return global_ret; | 472 | return global_ret; |
473 | } | 473 | } |
474 | 474 | ||
diff --git a/src/nat/gnunet-service-nat.c b/src/nat/gnunet-service-nat.c index 6fd09a7d9..694949dde 100644 --- a/src/nat/gnunet-service-nat.c +++ b/src/nat/gnunet-service-nat.c | |||
@@ -55,23 +55,26 @@ | |||
55 | * How often should we ask the OS about a list of active | 55 | * How often should we ask the OS about a list of active |
56 | * network interfaces? | 56 | * network interfaces? |
57 | */ | 57 | */ |
58 | #define SCAN_FREQ GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15) | 58 | #define SCAN_FREQ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15) |
59 | 59 | ||
60 | /** | 60 | /** |
61 | * How long do we wait until we forcefully terminate autoconfiguration? | 61 | * How long do we wait until we forcefully terminate autoconfiguration? |
62 | */ | 62 | */ |
63 | #define AUTOCONFIG_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5) | 63 | #define AUTOCONFIG_TIMEOUT GNUNET_TIME_relative_multiply ( \ |
64 | GNUNET_TIME_UNIT_SECONDS, 5) | ||
64 | 65 | ||
65 | /** | 66 | /** |
66 | * How often do we scan for changes in how our external (dyndns) hostname resolves? | 67 | * How often do we scan for changes in how our external (dyndns) hostname resolves? |
67 | */ | 68 | */ |
68 | #define DYNDNS_FREQUENCY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 7) | 69 | #define DYNDNS_FREQUENCY GNUNET_TIME_relative_multiply ( \ |
70 | GNUNET_TIME_UNIT_MINUTES, 7) | ||
69 | 71 | ||
70 | 72 | ||
71 | /** | 73 | /** |
72 | * Information we track per client address. | 74 | * Information we track per client address. |
73 | */ | 75 | */ |
74 | struct ClientAddress { | 76 | struct ClientAddress |
77 | { | ||
75 | /** | 78 | /** |
76 | * Network address used by the client. | 79 | * Network address used by the client. |
77 | */ | 80 | */ |
@@ -89,7 +92,8 @@ struct ClientAddress { | |||
89 | /** | 92 | /** |
90 | * List of local addresses this system has. | 93 | * List of local addresses this system has. |
91 | */ | 94 | */ |
92 | struct LocalAddressList { | 95 | struct LocalAddressList |
96 | { | ||
93 | /** | 97 | /** |
94 | * This is a linked list. | 98 | * This is a linked list. |
95 | */ | 99 | */ |
@@ -134,7 +138,8 @@ struct LocalAddressList { | |||
134 | /** | 138 | /** |
135 | * Internal data structure we track for each of our clients. | 139 | * Internal data structure we track for each of our clients. |
136 | */ | 140 | */ |
137 | struct ClientHandle { | 141 | struct ClientHandle |
142 | { | ||
138 | /** | 143 | /** |
139 | * Kept in a DLL. | 144 | * Kept in a DLL. |
140 | */ | 145 | */ |
@@ -232,7 +237,8 @@ struct ClientHandle { | |||
232 | /** | 237 | /** |
233 | * External IP address as given to us via some STUN server. | 238 | * External IP address as given to us via some STUN server. |
234 | */ | 239 | */ |
235 | struct StunExternalIP { | 240 | struct StunExternalIP |
241 | { | ||
236 | /** | 242 | /** |
237 | * Kept in a DLL. | 243 | * Kept in a DLL. |
238 | */ | 244 | */ |
@@ -336,22 +342,22 @@ int enable_upnp; | |||
336 | * @param lal entry to free | 342 | * @param lal entry to free |
337 | */ | 343 | */ |
338 | static void | 344 | static void |
339 | free_lal(struct LocalAddressList *lal) | 345 | free_lal (struct LocalAddressList *lal) |
340 | { | 346 | { |
341 | GNUNET_CONTAINER_DLL_remove(lal_head, | 347 | GNUNET_CONTAINER_DLL_remove (lal_head, |
342 | lal_tail, | 348 | lal_tail, |
343 | lal); | 349 | lal); |
344 | if (NULL != lal->hc) | 350 | if (NULL != lal->hc) |
345 | { | 351 | { |
346 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | 352 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, |
347 | "Lost NATed local address %s, stopping NAT server\n", | 353 | "Lost NATed local address %s, stopping NAT server\n", |
348 | GNUNET_a2s((const struct sockaddr *)&lal->addr, | 354 | GNUNET_a2s ((const struct sockaddr *) &lal->addr, |
349 | sizeof(struct sockaddr_in))); | 355 | sizeof(struct sockaddr_in))); |
350 | 356 | ||
351 | GN_stop_gnunet_nat_server_(lal->hc); | 357 | GN_stop_gnunet_nat_server_ (lal->hc); |
352 | lal->hc = NULL; | 358 | lal->hc = NULL; |
353 | } | 359 | } |
354 | GNUNET_free(lal); | 360 | GNUNET_free (lal); |
355 | } | 361 | } |
356 | 362 | ||
357 | 363 | ||
@@ -359,12 +365,12 @@ free_lal(struct LocalAddressList *lal) | |||
359 | * Free the DLL starting at #lal_head. | 365 | * Free the DLL starting at #lal_head. |
360 | */ | 366 | */ |
361 | static void | 367 | static void |
362 | destroy_lal() | 368 | destroy_lal () |
363 | { | 369 | { |
364 | struct LocalAddressList *lal; | 370 | struct LocalAddressList *lal; |
365 | 371 | ||
366 | while (NULL != (lal = lal_head)) | 372 | while (NULL != (lal = lal_head)) |
367 | free_lal(lal); | 373 | free_lal (lal); |
368 | } | 374 | } |
369 | 375 | ||
370 | 376 | ||
@@ -377,55 +383,55 @@ destroy_lal() | |||
377 | * @return #GNUNET_OK if message is well-formed | 383 | * @return #GNUNET_OK if message is well-formed |
378 | */ | 384 | */ |
379 | static int | 385 | static int |
380 | check_register(void *cls, | 386 | check_register (void *cls, |
381 | const struct GNUNET_NAT_RegisterMessage *message) | 387 | const struct GNUNET_NAT_RegisterMessage *message) |
382 | { | 388 | { |
383 | uint16_t num_addrs = ntohs(message->num_addrs); | 389 | uint16_t num_addrs = ntohs (message->num_addrs); |
384 | const char *off = (const char *)&message[1]; | 390 | const char *off = (const char *) &message[1]; |
385 | size_t left = ntohs(message->header.size) - sizeof(*message); | 391 | size_t left = ntohs (message->header.size) - sizeof(*message); |
386 | 392 | ||
387 | for (unsigned int i = 0; i < num_addrs; i++) | 393 | for (unsigned int i = 0; i < num_addrs; i++) |
394 | { | ||
395 | size_t alen; | ||
396 | const struct sockaddr *sa = (const struct sockaddr *) off; | ||
397 | |||
398 | if (sizeof(sa_family_t) > left) | ||
399 | { | ||
400 | GNUNET_break (0); | ||
401 | return GNUNET_SYSERR; | ||
402 | } | ||
403 | switch (sa->sa_family) | ||
388 | { | 404 | { |
389 | size_t alen; | 405 | case AF_INET: |
390 | const struct sockaddr *sa = (const struct sockaddr *)off; | 406 | alen = sizeof(struct sockaddr_in); |
391 | 407 | break; | |
392 | if (sizeof(sa_family_t) > left) | 408 | |
393 | { | 409 | case AF_INET6: |
394 | GNUNET_break(0); | 410 | alen = sizeof(struct sockaddr_in6); |
395 | return GNUNET_SYSERR; | 411 | break; |
396 | } | ||
397 | switch (sa->sa_family) | ||
398 | { | ||
399 | case AF_INET: | ||
400 | alen = sizeof(struct sockaddr_in); | ||
401 | break; | ||
402 | |||
403 | case AF_INET6: | ||
404 | alen = sizeof(struct sockaddr_in6); | ||
405 | break; | ||
406 | 412 | ||
407 | #if AF_UNIX | 413 | #if AF_UNIX |
408 | case AF_UNIX: | 414 | case AF_UNIX: |
409 | alen = sizeof(struct sockaddr_un); | 415 | alen = sizeof(struct sockaddr_un); |
410 | break; | 416 | break; |
411 | #endif | 417 | #endif |
412 | default: | 418 | default: |
413 | GNUNET_break(0); | 419 | GNUNET_break (0); |
414 | return GNUNET_SYSERR; | 420 | return GNUNET_SYSERR; |
415 | } | ||
416 | if (alen > left) | ||
417 | { | ||
418 | GNUNET_break(0); | ||
419 | return GNUNET_SYSERR; | ||
420 | } | ||
421 | off += alen; | ||
422 | left -= alen; | ||
423 | } | 421 | } |
424 | if (left != ntohs(message->str_len)) | 422 | if (alen > left) |
425 | { | 423 | { |
426 | GNUNET_break(0); | 424 | GNUNET_break (0); |
427 | return GNUNET_SYSERR; | 425 | return GNUNET_SYSERR; |
428 | } | 426 | } |
427 | off += alen; | ||
428 | left -= alen; | ||
429 | } | ||
430 | if (left != ntohs (message->str_len)) | ||
431 | { | ||
432 | GNUNET_break (0); | ||
433 | return GNUNET_SYSERR; | ||
434 | } | ||
429 | return GNUNET_OK; | 435 | return GNUNET_OK; |
430 | } | 436 | } |
431 | 437 | ||
@@ -439,9 +445,9 @@ check_register(void *cls, | |||
439 | * @return #GNUNET_YES if @a ip is in @a network | 445 | * @return #GNUNET_YES if @a ip is in @a network |
440 | */ | 446 | */ |
441 | static int | 447 | static int |
442 | match_ipv4(const char *network, | 448 | match_ipv4 (const char *network, |
443 | const struct in_addr *ip, | 449 | const struct in_addr *ip, |
444 | uint8_t bits) | 450 | uint8_t bits) |
445 | { | 451 | { |
446 | struct in_addr net; | 452 | struct in_addr net; |
447 | 453 | ||
@@ -449,10 +455,10 @@ match_ipv4(const char *network, | |||
449 | return GNUNET_YES; | 455 | return GNUNET_YES; |
450 | if (0 == bits) | 456 | if (0 == bits) |
451 | return GNUNET_YES; | 457 | return GNUNET_YES; |
452 | GNUNET_assert(1 == inet_pton(AF_INET, | 458 | GNUNET_assert (1 == inet_pton (AF_INET, |
453 | network, | 459 | network, |
454 | &net)); | 460 | &net)); |
455 | return !((ip->s_addr ^ net.s_addr) & htonl(0xFFFFFFFFu << (32 - bits))); | 461 | return ! ((ip->s_addr ^ net.s_addr) & htonl (0xFFFFFFFFu << (32 - bits))); |
456 | } | 462 | } |
457 | 463 | ||
458 | 464 | ||
@@ -465,9 +471,9 @@ match_ipv4(const char *network, | |||
465 | * @return #GNUNET_YES if @a ip is in @a network | 471 | * @return #GNUNET_YES if @a ip is in @a network |
466 | */ | 472 | */ |
467 | static int | 473 | static int |
468 | match_ipv6(const char *network, | 474 | match_ipv6 (const char *network, |
469 | const struct in6_addr *ip, | 475 | const struct in6_addr *ip, |
470 | uint8_t bits) | 476 | uint8_t bits) |
471 | { | 477 | { |
472 | struct in6_addr net; | 478 | struct in6_addr net; |
473 | struct in6_addr mask; | 479 | struct in6_addr mask; |
@@ -475,27 +481,27 @@ match_ipv6(const char *network, | |||
475 | 481 | ||
476 | if (0 == bits) | 482 | if (0 == bits) |
477 | return GNUNET_YES; | 483 | return GNUNET_YES; |
478 | GNUNET_assert(1 == inet_pton(AF_INET6, | 484 | GNUNET_assert (1 == inet_pton (AF_INET6, |
479 | network, | 485 | network, |
480 | &net)); | 486 | &net)); |
481 | memset(&mask, 0, sizeof(mask)); | 487 | memset (&mask, 0, sizeof(mask)); |
482 | if (0 == GNUNET_memcmp(&mask, | 488 | if (0 == GNUNET_memcmp (&mask, |
483 | ip)) | 489 | ip)) |
484 | return GNUNET_YES; | 490 | return GNUNET_YES; |
485 | off = 0; | 491 | off = 0; |
486 | while (bits > 8) | 492 | while (bits > 8) |
487 | { | 493 | { |
488 | mask.s6_addr[off++] = 0xFF; | 494 | mask.s6_addr[off++] = 0xFF; |
489 | bits -= 8; | 495 | bits -= 8; |
490 | } | 496 | } |
491 | while (bits > 0) | 497 | while (bits > 0) |
492 | { | 498 | { |
493 | mask.s6_addr[off] = (mask.s6_addr[off] >> 1) + 0x80; | 499 | mask.s6_addr[off] = (mask.s6_addr[off] >> 1) + 0x80; |
494 | bits--; | 500 | bits--; |
495 | } | 501 | } |
496 | for (unsigned j = 0; j < sizeof(struct in6_addr) / sizeof(uint32_t); j++) | 502 | for (unsigned j = 0; j < sizeof(struct in6_addr) / sizeof(uint32_t); j++) |
497 | if (((((uint32_t *)ip)[j] & ((uint32_t *)&mask)[j])) != | 503 | if (((((uint32_t *) ip)[j] & ((uint32_t *) &mask)[j])) != |
498 | (((uint32_t *)&net)[j] & ((int *)&mask)[j])) | 504 | (((uint32_t *) &net)[j] & ((int *) &mask)[j])) |
499 | return GNUNET_NO; | 505 | return GNUNET_NO; |
500 | return GNUNET_YES; | 506 | return GNUNET_YES; |
501 | } | 507 | } |
@@ -509,14 +515,14 @@ match_ipv6(const char *network, | |||
509 | * @return #GNUNET_YES if @a ip is in a NAT range | 515 | * @return #GNUNET_YES if @a ip is in a NAT range |
510 | */ | 516 | */ |
511 | static int | 517 | static int |
512 | is_nat_v4(const struct in_addr *ip) | 518 | is_nat_v4 (const struct in_addr *ip) |
513 | { | 519 | { |
514 | return | 520 | return |
515 | match_ipv4("10.0.0.0", ip, 8) || /* RFC 1918 */ | 521 | match_ipv4 ("10.0.0.0", ip, 8) || /* RFC 1918 */ |
516 | match_ipv4("100.64.0.0", ip, 10) || /* CG-NAT, RFC 6598 */ | 522 | match_ipv4 ("100.64.0.0", ip, 10) || /* CG-NAT, RFC 6598 */ |
517 | match_ipv4("192.168.0.0", ip, 12) || /* RFC 1918 */ | 523 | match_ipv4 ("192.168.0.0", ip, 12) || /* RFC 1918 */ |
518 | match_ipv4("169.254.0.0", ip, 16) || /* AUTO, RFC 3927 */ | 524 | match_ipv4 ("169.254.0.0", ip, 16) || /* AUTO, RFC 3927 */ |
519 | match_ipv4("172.16.0.0", ip, 16); /* RFC 1918 */ | 525 | match_ipv4 ("172.16.0.0", ip, 16); /* RFC 1918 */ |
520 | } | 526 | } |
521 | 527 | ||
522 | 528 | ||
@@ -528,19 +534,20 @@ is_nat_v4(const struct in_addr *ip) | |||
528 | * @return #GNUNET_YES if @a ip is in a NAT range | 534 | * @return #GNUNET_YES if @a ip is in a NAT range |
529 | */ | 535 | */ |
530 | static int | 536 | static int |
531 | is_nat_v6(const struct in6_addr *ip) | 537 | is_nat_v6 (const struct in6_addr *ip) |
532 | { | 538 | { |
533 | return | 539 | return |
534 | match_ipv6("fc00::", ip, 7) || /* RFC 4193 */ | 540 | match_ipv6 ("fc00::", ip, 7) || /* RFC 4193 */ |
535 | match_ipv6("fec0::", ip, 10) || /* RFC 3879 */ | 541 | match_ipv6 ("fec0::", ip, 10) || /* RFC 3879 */ |
536 | match_ipv6("fe80::", ip, 10); /* RFC 4291, link-local */ | 542 | match_ipv6 ("fe80::", ip, 10); /* RFC 4291, link-local */ |
537 | } | 543 | } |
538 | 544 | ||
539 | 545 | ||
540 | /** | 546 | /** |
541 | * Closure for #ifc_proc. | 547 | * Closure for #ifc_proc. |
542 | */ | 548 | */ |
543 | struct IfcProcContext { | 549 | struct IfcProcContext |
550 | { | ||
544 | /** | 551 | /** |
545 | * Head of DLL of local addresses. | 552 | * Head of DLL of local addresses. |
546 | */ | 553 | */ |
@@ -567,13 +574,13 @@ struct IfcProcContext { | |||
567 | * @return #GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort | 574 | * @return #GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort |
568 | */ | 575 | */ |
569 | static int | 576 | static int |
570 | ifc_proc(void *cls, | 577 | ifc_proc (void *cls, |
571 | const char *name, | 578 | const char *name, |
572 | int isDefault, | 579 | int isDefault, |
573 | const struct sockaddr *addr, | 580 | const struct sockaddr *addr, |
574 | const struct sockaddr *broadcast_addr, | 581 | const struct sockaddr *broadcast_addr, |
575 | const struct sockaddr *netmask, | 582 | const struct sockaddr *netmask, |
576 | socklen_t addrlen) | 583 | socklen_t addrlen) |
577 | { | 584 | { |
578 | struct IfcProcContext *ifc_ctx = cls; | 585 | struct IfcProcContext *ifc_ctx = cls; |
579 | struct LocalAddressList *lal; | 586 | struct LocalAddressList *lal; |
@@ -583,53 +590,53 @@ ifc_proc(void *cls, | |||
583 | enum GNUNET_NAT_AddressClass ac; | 590 | enum GNUNET_NAT_AddressClass ac; |
584 | 591 | ||
585 | switch (addr->sa_family) | 592 | switch (addr->sa_family) |
593 | { | ||
594 | case AF_INET: | ||
595 | alen = sizeof(struct sockaddr_in); | ||
596 | ip4 = &((const struct sockaddr_in *) addr)->sin_addr; | ||
597 | if (match_ipv4 ("127.0.0.0", ip4, 8)) | ||
598 | ac = GNUNET_NAT_AC_LOOPBACK; | ||
599 | else if (is_nat_v4 (ip4)) | ||
600 | ac = GNUNET_NAT_AC_LAN; | ||
601 | else | ||
602 | ac = GNUNET_NAT_AC_GLOBAL; | ||
603 | break; | ||
604 | |||
605 | case AF_INET6: | ||
606 | alen = sizeof(struct sockaddr_in6); | ||
607 | ip6 = &((const struct sockaddr_in6 *) addr)->sin6_addr; | ||
608 | if (match_ipv6 ("::1", ip6, 128)) | ||
609 | ac = GNUNET_NAT_AC_LOOPBACK; | ||
610 | else if (is_nat_v6 (ip6)) | ||
611 | ac = GNUNET_NAT_AC_LAN; | ||
612 | else | ||
613 | ac = GNUNET_NAT_AC_GLOBAL; | ||
614 | if ((ip6->s6_addr[11] == 0xFF) && | ||
615 | (ip6->s6_addr[12] == 0xFE)) | ||
586 | { | 616 | { |
587 | case AF_INET: | 617 | /* contains a MAC, be extra careful! */ |
588 | alen = sizeof(struct sockaddr_in); | 618 | ac |= GNUNET_NAT_AC_PRIVATE; |
589 | ip4 = &((const struct sockaddr_in *)addr)->sin_addr; | 619 | } |
590 | if (match_ipv4("127.0.0.0", ip4, 8)) | 620 | break; |
591 | ac = GNUNET_NAT_AC_LOOPBACK; | ||
592 | else if (is_nat_v4(ip4)) | ||
593 | ac = GNUNET_NAT_AC_LAN; | ||
594 | else | ||
595 | ac = GNUNET_NAT_AC_GLOBAL; | ||
596 | break; | ||
597 | |||
598 | case AF_INET6: | ||
599 | alen = sizeof(struct sockaddr_in6); | ||
600 | ip6 = &((const struct sockaddr_in6 *)addr)->sin6_addr; | ||
601 | if (match_ipv6("::1", ip6, 128)) | ||
602 | ac = GNUNET_NAT_AC_LOOPBACK; | ||
603 | else if (is_nat_v6(ip6)) | ||
604 | ac = GNUNET_NAT_AC_LAN; | ||
605 | else | ||
606 | ac = GNUNET_NAT_AC_GLOBAL; | ||
607 | if ((ip6->s6_addr[11] == 0xFF) && | ||
608 | (ip6->s6_addr[12] == 0xFE)) | ||
609 | { | ||
610 | /* contains a MAC, be extra careful! */ | ||
611 | ac |= GNUNET_NAT_AC_PRIVATE; | ||
612 | } | ||
613 | break; | ||
614 | 621 | ||
615 | #if AF_UNIX | 622 | #if AF_UNIX |
616 | case AF_UNIX: | 623 | case AF_UNIX: |
617 | GNUNET_break(0); | 624 | GNUNET_break (0); |
618 | return GNUNET_OK; | 625 | return GNUNET_OK; |
619 | #endif | 626 | #endif |
620 | default: | 627 | default: |
621 | GNUNET_break(0); | 628 | GNUNET_break (0); |
622 | return GNUNET_OK; | 629 | return GNUNET_OK; |
623 | } | 630 | } |
624 | lal = GNUNET_malloc(sizeof(*lal)); | 631 | lal = GNUNET_malloc (sizeof(*lal)); |
625 | lal->af = addr->sa_family; | 632 | lal->af = addr->sa_family; |
626 | lal->ac = ac; | 633 | lal->ac = ac; |
627 | GNUNET_memcpy(&lal->addr, | 634 | GNUNET_memcpy (&lal->addr, |
628 | addr, | 635 | addr, |
629 | alen); | 636 | alen); |
630 | GNUNET_CONTAINER_DLL_insert(ifc_ctx->lal_head, | 637 | GNUNET_CONTAINER_DLL_insert (ifc_ctx->lal_head, |
631 | ifc_ctx->lal_tail, | 638 | ifc_ctx->lal_tail, |
632 | lal); | 639 | lal); |
633 | return GNUNET_OK; | 640 | return GNUNET_OK; |
634 | } | 641 | } |
635 | 642 | ||
@@ -645,30 +652,30 @@ ifc_proc(void *cls, | |||
645 | * @param addr_len number of bytes in @a addr | 652 | * @param addr_len number of bytes in @a addr |
646 | */ | 653 | */ |
647 | static void | 654 | static void |
648 | notify_client(enum GNUNET_NAT_AddressClass ac, | 655 | notify_client (enum GNUNET_NAT_AddressClass ac, |
649 | struct ClientHandle *ch, | 656 | struct ClientHandle *ch, |
650 | int add, | 657 | int add, |
651 | const void *addr, | 658 | const void *addr, |
652 | size_t addr_len) | 659 | size_t addr_len) |
653 | { | 660 | { |
654 | struct GNUNET_MQ_Envelope *env; | 661 | struct GNUNET_MQ_Envelope *env; |
655 | struct GNUNET_NAT_AddressChangeNotificationMessage *msg; | 662 | struct GNUNET_NAT_AddressChangeNotificationMessage *msg; |
656 | 663 | ||
657 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 664 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
658 | "Notifying client about %s of IP %s\n", | 665 | "Notifying client about %s of IP %s\n", |
659 | add ? "addition" : "removal", | 666 | add ? "addition" : "removal", |
660 | GNUNET_a2s(addr, | 667 | GNUNET_a2s (addr, |
661 | addr_len)); | 668 | addr_len)); |
662 | env = GNUNET_MQ_msg_extra(msg, | 669 | env = GNUNET_MQ_msg_extra (msg, |
663 | addr_len, | 670 | addr_len, |
664 | GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE); | 671 | GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE); |
665 | msg->add_remove = htonl(add); | 672 | msg->add_remove = htonl (add); |
666 | msg->addr_class = htonl(ac); | 673 | msg->addr_class = htonl (ac); |
667 | GNUNET_memcpy(&msg[1], | 674 | GNUNET_memcpy (&msg[1], |
668 | addr, | 675 | addr, |
669 | addr_len); | 676 | addr_len); |
670 | GNUNET_MQ_send(ch->mq, | 677 | GNUNET_MQ_send (ch->mq, |
671 | env); | 678 | env); |
672 | } | 679 | } |
673 | 680 | ||
674 | 681 | ||
@@ -681,123 +688,123 @@ notify_client(enum GNUNET_NAT_AddressClass ac, | |||
681 | * @param add #GNUNET_YES to add, #GNUNET_NO to remove | 688 | * @param add #GNUNET_YES to add, #GNUNET_NO to remove |
682 | */ | 689 | */ |
683 | static void | 690 | static void |
684 | check_notify_client(struct LocalAddressList *delta, | 691 | check_notify_client (struct LocalAddressList *delta, |
685 | struct ClientHandle *ch, | 692 | struct ClientHandle *ch, |
686 | int add) | 693 | int add) |
687 | { | 694 | { |
688 | size_t alen; | 695 | size_t alen; |
689 | struct sockaddr_in v4; | 696 | struct sockaddr_in v4; |
690 | struct sockaddr_in6 v6; | 697 | struct sockaddr_in6 v6; |
691 | 698 | ||
692 | if (0 == (ch->flags & GNUNET_NAT_RF_ADDRESSES)) | 699 | if (0 == (ch->flags & GNUNET_NAT_RF_ADDRESSES)) |
693 | { | 700 | { |
694 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 701 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
695 | "Not notifying client as it does not care about addresses\n"); | 702 | "Not notifying client as it does not care about addresses\n"); |
696 | return; | 703 | return; |
697 | } | 704 | } |
698 | switch (delta->af) | 705 | switch (delta->af) |
706 | { | ||
707 | case AF_INET: | ||
708 | alen = sizeof(struct sockaddr_in); | ||
709 | GNUNET_memcpy (&v4, | ||
710 | &delta->addr, | ||
711 | alen); | ||
712 | |||
713 | /* Check for client notifications */ | ||
714 | for (unsigned int i = 0; i < ch->num_caddrs; i++) | ||
699 | { | 715 | { |
700 | case AF_INET: | 716 | const struct sockaddr_in *c4; |
701 | alen = sizeof(struct sockaddr_in); | 717 | |
702 | GNUNET_memcpy(&v4, | 718 | if (AF_INET != ch->caddrs[i].ss.ss_family) |
703 | &delta->addr, | 719 | continue; /* IPv4 not relevant */ |
704 | alen); | 720 | c4 = (const struct sockaddr_in *) &ch->caddrs[i].ss; |
705 | 721 | if (match_ipv4 ("127.0.0.1", &c4->sin_addr, 8) && | |
706 | /* Check for client notifications */ | 722 | (0 != c4->sin_addr.s_addr) && |
707 | for (unsigned int i = 0; i < ch->num_caddrs; i++) | 723 | (! match_ipv4 ("127.0.0.1", &v4.sin_addr, 8))) |
708 | { | 724 | continue; /* bound to loopback, but this is not loopback */ |
709 | const struct sockaddr_in *c4; | 725 | if ((! match_ipv4 ("127.0.0.1", &c4->sin_addr, 8)) && |
710 | 726 | match_ipv4 ("127.0.0.1", &v4.sin_addr, 8)) | |
711 | if (AF_INET != ch->caddrs[i].ss.ss_family) | 727 | continue; /* bound to non-loopback, but this is loopback */ |
712 | continue; /* IPv4 not relevant */ | 728 | if ((0 != (delta->ac & GNUNET_NAT_AC_EXTERN)) && |
713 | c4 = (const struct sockaddr_in *)&ch->caddrs[i].ss; | 729 | (0 != c4->sin_addr.s_addr) && |
714 | if (match_ipv4("127.0.0.1", &c4->sin_addr, 8) && | 730 | (! is_nat_v4 (&v4.sin_addr))) |
715 | (0 != c4->sin_addr.s_addr) && | 731 | continue; /* based on external-IP, but this IP is not |
716 | (!match_ipv4("127.0.0.1", &v4.sin_addr, 8))) | ||
717 | continue; /* bound to loopback, but this is not loopback */ | ||
718 | if ((!match_ipv4("127.0.0.1", &c4->sin_addr, 8)) && | ||
719 | match_ipv4("127.0.0.1", &v4.sin_addr, 8)) | ||
720 | continue; /* bound to non-loopback, but this is loopback */ | ||
721 | if ((0 != (delta->ac & GNUNET_NAT_AC_EXTERN)) && | ||
722 | (0 != c4->sin_addr.s_addr) && | ||
723 | (!is_nat_v4(&v4.sin_addr))) | ||
724 | continue; /* based on external-IP, but this IP is not | ||
725 | from private address range. */ | 732 | from private address range. */ |
726 | if ((0 != GNUNET_memcmp(&v4.sin_addr, | 733 | if ((0 != GNUNET_memcmp (&v4.sin_addr, |
727 | &c4->sin_addr)) && | 734 | &c4->sin_addr)) && |
728 | (0 != c4->sin_addr.s_addr) && | 735 | (0 != c4->sin_addr.s_addr) && |
729 | (!is_nat_v4(&c4->sin_addr))) | 736 | (! is_nat_v4 (&c4->sin_addr))) |
730 | continue; /* this IP is not from private address range, | 737 | continue; /* this IP is not from private address range, |
731 | and IP does not match. */ | 738 | and IP does not match. */ |
732 | 739 | ||
733 | /* OK, IP seems relevant, notify client */ | 740 | /* OK, IP seems relevant, notify client */ |
734 | if (0 == htons(v4.sin_port)) | 741 | if (0 == htons (v4.sin_port)) |
735 | v4.sin_port = c4->sin_port; | 742 | v4.sin_port = c4->sin_port; |
736 | notify_client(delta->ac, | 743 | notify_client (delta->ac, |
737 | ch, | 744 | ch, |
738 | add, | 745 | add, |
739 | &v4, | 746 | &v4, |
740 | alen); | 747 | alen); |
741 | } | 748 | } |
742 | break; | 749 | break; |
743 | 750 | ||
744 | case AF_INET6: | 751 | case AF_INET6: |
745 | alen = sizeof(struct sockaddr_in6); | 752 | alen = sizeof(struct sockaddr_in6); |
746 | GNUNET_memcpy(&v6, | 753 | GNUNET_memcpy (&v6, |
747 | &delta->addr, | 754 | &delta->addr, |
748 | alen); | 755 | alen); |
749 | for (unsigned int i = 0; i < ch->num_caddrs; i++) | 756 | for (unsigned int i = 0; i < ch->num_caddrs; i++) |
750 | { | 757 | { |
751 | const struct sockaddr_in6 *c6; | 758 | const struct sockaddr_in6 *c6; |
752 | 759 | ||
753 | if (AF_INET6 != ch->caddrs[i].ss.ss_family) | 760 | if (AF_INET6 != ch->caddrs[i].ss.ss_family) |
754 | continue; /* IPv4 not relevant */ | 761 | continue; /* IPv4 not relevant */ |
755 | c6 = (const struct sockaddr_in6 *)&ch->caddrs[i].ss; | 762 | c6 = (const struct sockaddr_in6 *) &ch->caddrs[i].ss; |
756 | if (match_ipv6("::1", &c6->sin6_addr, 128) && | 763 | if (match_ipv6 ("::1", &c6->sin6_addr, 128) && |
757 | (0 != GNUNET_memcmp(&c6->sin6_addr, | 764 | (0 != GNUNET_memcmp (&c6->sin6_addr, |
758 | &in6addr_any)) && | 765 | &in6addr_any)) && |
759 | (!match_ipv6("::1", &v6.sin6_addr, 128))) | 766 | (! match_ipv6 ("::1", &v6.sin6_addr, 128))) |
760 | continue; /* bound to loopback, but this is not loopback */ | 767 | continue; /* bound to loopback, but this is not loopback */ |
761 | if ((!match_ipv6("::1", &c6->sin6_addr, 128)) && | 768 | if ((! match_ipv6 ("::1", &c6->sin6_addr, 128)) && |
762 | match_ipv6("::1", &v6.sin6_addr, 128)) | 769 | match_ipv6 ("::1", &v6.sin6_addr, 128)) |
763 | continue; /* bound to non-loopback, but this is loopback */ | 770 | continue; /* bound to non-loopback, but this is loopback */ |
764 | if ((0 != (delta->ac & GNUNET_NAT_AC_EXTERN)) && | 771 | if ((0 != (delta->ac & GNUNET_NAT_AC_EXTERN)) && |
765 | (0 != GNUNET_memcmp(&c6->sin6_addr, | 772 | (0 != GNUNET_memcmp (&c6->sin6_addr, |
766 | &in6addr_any)) && | 773 | &in6addr_any)) && |
767 | (!is_nat_v6(&v6.sin6_addr))) | 774 | (! is_nat_v6 (&v6.sin6_addr))) |
768 | continue; /* based on external-IP, but this IP is not | 775 | continue; /* based on external-IP, but this IP is not |
769 | from private address range. */ | 776 | from private address range. */ |
770 | if ((0 != GNUNET_memcmp(&v6.sin6_addr, | 777 | if ((0 != GNUNET_memcmp (&v6.sin6_addr, |
771 | &c6->sin6_addr)) && | 778 | &c6->sin6_addr)) && |
772 | (0 != GNUNET_memcmp(&c6->sin6_addr, | 779 | (0 != GNUNET_memcmp (&c6->sin6_addr, |
773 | &in6addr_any)) && | 780 | &in6addr_any)) && |
774 | (!is_nat_v6(&c6->sin6_addr))) | 781 | (! is_nat_v6 (&c6->sin6_addr))) |
775 | continue; /* this IP is not from private address range, | 782 | continue; /* this IP is not from private address range, |
776 | and IP does not match. */ | 783 | and IP does not match. */ |
777 | if ((match_ipv6("fe80::", &c6->sin6_addr, 10)) && | 784 | if ((match_ipv6 ("fe80::", &c6->sin6_addr, 10)) && |
778 | (0 != GNUNET_memcmp(&c6->sin6_addr, | 785 | (0 != GNUNET_memcmp (&c6->sin6_addr, |
779 | &in6addr_any)) && | 786 | &in6addr_any)) && |
780 | (0 != GNUNET_memcmp(&v6.sin6_addr, | 787 | (0 != GNUNET_memcmp (&v6.sin6_addr, |
781 | &c6->sin6_addr)) && | 788 | &c6->sin6_addr)) && |
782 | (0 == (delta->ac & GNUNET_NAT_AC_EXTERN))) | 789 | (0 == (delta->ac & GNUNET_NAT_AC_EXTERN))) |
783 | continue; /* client bound to link-local, and the other address | 790 | continue; /* client bound to link-local, and the other address |
784 | does not match and is not an external IP */ | 791 | does not match and is not an external IP */ |
785 | 792 | ||
786 | /* OK, IP seems relevant, notify client */ | 793 | /* OK, IP seems relevant, notify client */ |
787 | if (0 == htons(v6.sin6_port)) | 794 | if (0 == htons (v6.sin6_port)) |
788 | v6.sin6_port = c6->sin6_port; | 795 | v6.sin6_port = c6->sin6_port; |
789 | notify_client(delta->ac, | 796 | notify_client (delta->ac, |
790 | ch, | 797 | ch, |
791 | add, | 798 | add, |
792 | &v6, | 799 | &v6, |
793 | alen); | 800 | alen); |
794 | } | ||
795 | break; | ||
796 | |||
797 | default: | ||
798 | GNUNET_break(0); | ||
799 | return; | ||
800 | } | 801 | } |
802 | break; | ||
803 | |||
804 | default: | ||
805 | GNUNET_break (0); | ||
806 | return; | ||
807 | } | ||
801 | } | 808 | } |
802 | 809 | ||
803 | 810 | ||
@@ -809,15 +816,15 @@ check_notify_client(struct LocalAddressList *delta, | |||
809 | * @param add #GNUNET_YES to add, #GNUNET_NO to remove | 816 | * @param add #GNUNET_YES to add, #GNUNET_NO to remove |
810 | */ | 817 | */ |
811 | static void | 818 | static void |
812 | notify_clients(struct LocalAddressList *delta, | 819 | notify_clients (struct LocalAddressList *delta, |
813 | int add) | 820 | int add) |
814 | { | 821 | { |
815 | for (struct ClientHandle *ch = ch_head; | 822 | for (struct ClientHandle *ch = ch_head; |
816 | NULL != ch; | 823 | NULL != ch; |
817 | ch = ch->next) | 824 | ch = ch->next) |
818 | check_notify_client(delta, | 825 | check_notify_client (delta, |
819 | ch, | 826 | ch, |
820 | add); | 827 | add); |
821 | } | 828 | } |
822 | 829 | ||
823 | 830 | ||
@@ -830,9 +837,9 @@ notify_clients(struct LocalAddressList *delta, | |||
830 | * @param add #GNUNET_YES to add, #GNUNET_NO to remove | 837 | * @param add #GNUNET_YES to add, #GNUNET_NO to remove |
831 | */ | 838 | */ |
832 | static void | 839 | static void |
833 | notify_client_external_ipv4_change(void *cls, | 840 | notify_client_external_ipv4_change (void *cls, |
834 | const struct in_addr *v4, | 841 | const struct in_addr *v4, |
835 | int add) | 842 | int add) |
836 | { | 843 | { |
837 | struct ClientHandle *ch = cls; | 844 | struct ClientHandle *ch = cls; |
838 | struct sockaddr_in sa; | 845 | struct sockaddr_in sa; |
@@ -840,64 +847,64 @@ notify_client_external_ipv4_change(void *cls, | |||
840 | 847 | ||
841 | /* (0) check if this impacts 'hole_external' */ | 848 | /* (0) check if this impacts 'hole_external' */ |
842 | if ((NULL != ch->hole_external) && | 849 | if ((NULL != ch->hole_external) && |
843 | (0 == strcasecmp(ch->hole_external, | 850 | (0 == strcasecmp (ch->hole_external, |
844 | "AUTO"))) | 851 | "AUTO"))) |
845 | { | 852 | { |
846 | struct LocalAddressList lal; | 853 | struct LocalAddressList lal; |
847 | struct sockaddr_in *s4; | 854 | struct sockaddr_in *s4; |
848 | 855 | ||
849 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 856 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
850 | "Detected eternal IP, can now back-fill AUTO:%u in hole punching specification of `%s'\n", | 857 | "Detected eternal IP, can now back-fill AUTO:%u in hole punching specification of `%s'\n", |
851 | (unsigned int)ch->ext_dns_port, | 858 | (unsigned int) ch->ext_dns_port, |
852 | ch->section_name); | 859 | ch->section_name); |
853 | memset(&lal, 0, sizeof(lal)); | 860 | memset (&lal, 0, sizeof(lal)); |
854 | s4 = (struct sockaddr_in *)&lal.addr; | 861 | s4 = (struct sockaddr_in *) &lal.addr; |
855 | s4->sin_family = AF_INET; | 862 | s4->sin_family = AF_INET; |
856 | s4->sin_port = htons(ch->ext_dns_port); | 863 | s4->sin_port = htons (ch->ext_dns_port); |
857 | s4->sin_addr = *v4; | 864 | s4->sin_addr = *v4; |
858 | lal.af = AF_INET; | 865 | lal.af = AF_INET; |
859 | lal.ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL; | 866 | lal.ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL; |
860 | check_notify_client(&lal, | 867 | check_notify_client (&lal, |
861 | ch, | 868 | ch, |
862 | add); | 869 | add); |
863 | } | 870 | } |
864 | 871 | ||
865 | /* (1) check if client cares. */ | 872 | /* (1) check if client cares. */ |
866 | if (!ch->natted_address) | 873 | if (! ch->natted_address) |
867 | return; | 874 | return; |
868 | have_v4 = GNUNET_NO; | 875 | have_v4 = GNUNET_NO; |
869 | for (unsigned int i = 0; i < ch->num_caddrs; i++) | 876 | for (unsigned int i = 0; i < ch->num_caddrs; i++) |
870 | { | 877 | { |
871 | const struct sockaddr_storage *ss = &ch->caddrs[i].ss; | 878 | const struct sockaddr_storage *ss = &ch->caddrs[i].ss; |
872 | 879 | ||
873 | if (AF_INET != ss->ss_family) | 880 | if (AF_INET != ss->ss_family) |
874 | continue; | 881 | continue; |
875 | have_v4 = GNUNET_YES; | 882 | have_v4 = GNUNET_YES; |
876 | break; | 883 | break; |
877 | } | 884 | } |
878 | if (GNUNET_NO == have_v4) | 885 | if (GNUNET_NO == have_v4) |
879 | return; /* IPv6-only */ | 886 | return; /* IPv6-only */ |
880 | 887 | ||
881 | /* (2) build address info */ | 888 | /* (2) build address info */ |
882 | memset(&sa, | 889 | memset (&sa, |
883 | 0, | 890 | 0, |
884 | sizeof(sa)); | 891 | sizeof(sa)); |
885 | sa.sin_family = AF_INET; | 892 | sa.sin_family = AF_INET; |
886 | sa.sin_addr = *v4; | 893 | sa.sin_addr = *v4; |
887 | sa.sin_port = htons(0); | 894 | sa.sin_port = htons (0); |
888 | 895 | ||
889 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 896 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
890 | "Detected eternal IP %s, notifying client of external IP (without port)\n", | 897 | "Detected eternal IP %s, notifying client of external IP (without port)\n", |
891 | GNUNET_a2s((const struct sockaddr *)&sa, | 898 | GNUNET_a2s ((const struct sockaddr *) &sa, |
892 | sizeof(sa))); | 899 | sizeof(sa))); |
893 | /* (3) notify client of change */ | 900 | /* (3) notify client of change */ |
894 | notify_client(is_nat_v4(v4) | 901 | notify_client (is_nat_v4 (v4) |
895 | ? GNUNET_NAT_AC_EXTERN | GNUNET_NAT_AC_LAN | 902 | ? GNUNET_NAT_AC_EXTERN | GNUNET_NAT_AC_LAN |
896 | : GNUNET_NAT_AC_EXTERN | GNUNET_NAT_AC_GLOBAL, | 903 | : GNUNET_NAT_AC_EXTERN | GNUNET_NAT_AC_GLOBAL, |
897 | ch, | 904 | ch, |
898 | add, | 905 | add, |
899 | &sa, | 906 | &sa, |
900 | sizeof(sa)); | 907 | sizeof(sa)); |
901 | } | 908 | } |
902 | 909 | ||
903 | 910 | ||
@@ -909,54 +916,54 @@ notify_client_external_ipv4_change(void *cls, | |||
909 | * @param ra IP address of the peer who wants us to connect to it | 916 | * @param ra IP address of the peer who wants us to connect to it |
910 | */ | 917 | */ |
911 | static void | 918 | static void |
912 | reversal_callback(void *cls, | 919 | reversal_callback (void *cls, |
913 | const struct sockaddr_in *ra) | 920 | const struct sockaddr_in *ra) |
914 | { | 921 | { |
915 | struct LocalAddressList *lal = cls; | 922 | struct LocalAddressList *lal = cls; |
916 | const struct sockaddr_in *l4; | 923 | const struct sockaddr_in *l4; |
917 | 924 | ||
918 | GNUNET_assert(AF_INET == lal->af); | 925 | GNUNET_assert (AF_INET == lal->af); |
919 | l4 = (const struct sockaddr_in *)&lal->addr; | 926 | l4 = (const struct sockaddr_in *) &lal->addr; |
920 | for (struct ClientHandle *ch = ch_head; | 927 | for (struct ClientHandle *ch = ch_head; |
921 | NULL != ch; | 928 | NULL != ch; |
922 | ch = ch->next) | 929 | ch = ch->next) |
930 | { | ||
931 | struct GNUNET_NAT_ConnectionReversalRequestedMessage *crrm; | ||
932 | struct GNUNET_MQ_Envelope *env; | ||
933 | int match; | ||
934 | |||
935 | /* Check if client is in applicable range for ICMP NAT traversal | ||
936 | for this local address */ | ||
937 | if (! ch->natted_address) | ||
938 | continue; | ||
939 | match = GNUNET_NO; | ||
940 | for (unsigned int i = 0; i < ch->num_caddrs; i++) | ||
923 | { | 941 | { |
924 | struct GNUNET_NAT_ConnectionReversalRequestedMessage *crrm; | 942 | struct ClientAddress *ca = &ch->caddrs[i]; |
925 | struct GNUNET_MQ_Envelope *env; | 943 | const struct sockaddr_in *c4; |
926 | int match; | ||
927 | 944 | ||
928 | /* Check if client is in applicable range for ICMP NAT traversal | 945 | if (AF_INET != ca->ss.ss_family) |
929 | for this local address */ | ||
930 | if (!ch->natted_address) | ||
931 | continue; | 946 | continue; |
932 | match = GNUNET_NO; | 947 | c4 = (const struct sockaddr_in *) &ca->ss; |
933 | for (unsigned int i = 0; i < ch->num_caddrs; i++) | 948 | if ((0 != c4->sin_addr.s_addr) && |
934 | { | 949 | (l4->sin_addr.s_addr != c4->sin_addr.s_addr)) |
935 | struct ClientAddress *ca = &ch->caddrs[i]; | ||
936 | const struct sockaddr_in *c4; | ||
937 | |||
938 | if (AF_INET != ca->ss.ss_family) | ||
939 | continue; | ||
940 | c4 = (const struct sockaddr_in *)&ca->ss; | ||
941 | if ((0 != c4->sin_addr.s_addr) && | ||
942 | (l4->sin_addr.s_addr != c4->sin_addr.s_addr)) | ||
943 | continue; | ||
944 | match = GNUNET_YES; | ||
945 | break; | ||
946 | } | ||
947 | if (!match) | ||
948 | continue; | 950 | continue; |
949 | 951 | match = GNUNET_YES; | |
950 | /* Notify applicable client about connection reversal request */ | 952 | break; |
951 | env = GNUNET_MQ_msg_extra(crrm, | ||
952 | sizeof(struct sockaddr_in), | ||
953 | GNUNET_MESSAGE_TYPE_NAT_CONNECTION_REVERSAL_REQUESTED); | ||
954 | GNUNET_memcpy(&crrm[1], | ||
955 | ra, | ||
956 | sizeof(struct sockaddr_in)); | ||
957 | GNUNET_MQ_send(ch->mq, | ||
958 | env); | ||
959 | } | 953 | } |
954 | if (! match) | ||
955 | continue; | ||
956 | |||
957 | /* Notify applicable client about connection reversal request */ | ||
958 | env = GNUNET_MQ_msg_extra (crrm, | ||
959 | sizeof(struct sockaddr_in), | ||
960 | GNUNET_MESSAGE_TYPE_NAT_CONNECTION_REVERSAL_REQUESTED); | ||
961 | GNUNET_memcpy (&crrm[1], | ||
962 | ra, | ||
963 | sizeof(struct sockaddr_in)); | ||
964 | GNUNET_MQ_send (ch->mq, | ||
965 | env); | ||
966 | } | ||
960 | } | 967 | } |
961 | 968 | ||
962 | 969 | ||
@@ -966,104 +973,104 @@ reversal_callback(void *cls, | |||
966 | * @param cls NULL | 973 | * @param cls NULL |
967 | */ | 974 | */ |
968 | static void | 975 | static void |
969 | run_scan(void *cls) | 976 | run_scan (void *cls) |
970 | { | 977 | { |
971 | struct IfcProcContext ifc_ctx; | 978 | struct IfcProcContext ifc_ctx; |
972 | int found; | 979 | int found; |
973 | int have_nat; | 980 | int have_nat; |
974 | struct LocalAddressList *lnext; | 981 | struct LocalAddressList *lnext; |
975 | 982 | ||
976 | scan_task = GNUNET_SCHEDULER_add_delayed(SCAN_FREQ, | 983 | scan_task = GNUNET_SCHEDULER_add_delayed (SCAN_FREQ, |
977 | &run_scan, | 984 | &run_scan, |
978 | NULL); | 985 | NULL); |
979 | memset(&ifc_ctx, | 986 | memset (&ifc_ctx, |
980 | 0, | 987 | 0, |
981 | sizeof(ifc_ctx)); | 988 | sizeof(ifc_ctx)); |
982 | GNUNET_OS_network_interfaces_list(&ifc_proc, | 989 | GNUNET_OS_network_interfaces_list (&ifc_proc, |
983 | &ifc_ctx); | 990 | &ifc_ctx); |
984 | /* remove addresses that disappeared */ | 991 | /* remove addresses that disappeared */ |
985 | for (struct LocalAddressList *lal = lal_head; | 992 | for (struct LocalAddressList *lal = lal_head; |
986 | NULL != lal; | 993 | NULL != lal; |
987 | lal = lnext) | 994 | lal = lnext) |
995 | { | ||
996 | lnext = lal->next; | ||
997 | found = GNUNET_NO; | ||
998 | for (struct LocalAddressList *pos = ifc_ctx.lal_head; | ||
999 | NULL != pos; | ||
1000 | pos = pos->next) | ||
1001 | { | ||
1002 | if ((pos->af == lal->af) && | ||
1003 | (0 == memcmp (&lal->addr, | ||
1004 | &pos->addr, | ||
1005 | (AF_INET == lal->af) | ||
1006 | ? sizeof(struct sockaddr_in) | ||
1007 | : sizeof(struct sockaddr_in6)))) | ||
1008 | { | ||
1009 | found = GNUNET_YES; | ||
1010 | } | ||
1011 | } | ||
1012 | if (GNUNET_NO == found) | ||
988 | { | 1013 | { |
989 | lnext = lal->next; | 1014 | notify_clients (lal, |
990 | found = GNUNET_NO; | 1015 | GNUNET_NO); |
991 | for (struct LocalAddressList *pos = ifc_ctx.lal_head; | 1016 | free_lal (lal); |
992 | NULL != pos; | ||
993 | pos = pos->next) | ||
994 | { | ||
995 | if ((pos->af == lal->af) && | ||
996 | (0 == memcmp(&lal->addr, | ||
997 | &pos->addr, | ||
998 | (AF_INET == lal->af) | ||
999 | ? sizeof(struct sockaddr_in) | ||
1000 | : sizeof(struct sockaddr_in6)))) | ||
1001 | { | ||
1002 | found = GNUNET_YES; | ||
1003 | } | ||
1004 | } | ||
1005 | if (GNUNET_NO == found) | ||
1006 | { | ||
1007 | notify_clients(lal, | ||
1008 | GNUNET_NO); | ||
1009 | free_lal(lal); | ||
1010 | } | ||
1011 | } | 1017 | } |
1018 | } | ||
1012 | 1019 | ||
1013 | /* add addresses that appeared */ | 1020 | /* add addresses that appeared */ |
1014 | have_nat = GNUNET_NO; | 1021 | have_nat = GNUNET_NO; |
1015 | for (struct LocalAddressList *pos = ifc_ctx.lal_head; | 1022 | for (struct LocalAddressList *pos = ifc_ctx.lal_head; |
1016 | NULL != pos; | 1023 | NULL != pos; |
1017 | pos = ifc_ctx.lal_head) | 1024 | pos = ifc_ctx.lal_head) |
1025 | { | ||
1026 | found = GNUNET_NO; | ||
1027 | if (GNUNET_NAT_AC_LAN == (GNUNET_NAT_AC_LAN & pos->ac)) | ||
1028 | have_nat = GNUNET_YES; | ||
1029 | for (struct LocalAddressList *lal = lal_head; | ||
1030 | NULL != lal; | ||
1031 | lal = lal->next) | ||
1018 | { | 1032 | { |
1019 | found = GNUNET_NO; | 1033 | if ((pos->af == lal->af) && |
1020 | if (GNUNET_NAT_AC_LAN == (GNUNET_NAT_AC_LAN & pos->ac)) | 1034 | (0 == memcmp (&lal->addr, |
1021 | have_nat = GNUNET_YES; | 1035 | &pos->addr, |
1022 | for (struct LocalAddressList *lal = lal_head; | 1036 | (AF_INET == lal->af) |
1023 | NULL != lal; | 1037 | ? sizeof(struct sockaddr_in) |
1024 | lal = lal->next) | 1038 | : sizeof(struct sockaddr_in6)))) |
1025 | { | 1039 | found = GNUNET_YES; |
1026 | if ((pos->af == lal->af) && | 1040 | } |
1027 | (0 == memcmp(&lal->addr, | 1041 | GNUNET_CONTAINER_DLL_remove (ifc_ctx.lal_head, |
1028 | &pos->addr, | 1042 | ifc_ctx.lal_tail, |
1029 | (AF_INET == lal->af) | 1043 | pos); |
1030 | ? sizeof(struct sockaddr_in) | 1044 | if (GNUNET_YES == found) |
1031 | : sizeof(struct sockaddr_in6)))) | 1045 | { |
1032 | found = GNUNET_YES; | 1046 | GNUNET_free (pos); |
1033 | } | ||
1034 | GNUNET_CONTAINER_DLL_remove(ifc_ctx.lal_head, | ||
1035 | ifc_ctx.lal_tail, | ||
1036 | pos); | ||
1037 | if (GNUNET_YES == found) | ||
1038 | { | ||
1039 | GNUNET_free(pos); | ||
1040 | } | ||
1041 | else | ||
1042 | { | ||
1043 | notify_clients(pos, | ||
1044 | GNUNET_YES); | ||
1045 | GNUNET_CONTAINER_DLL_insert(lal_head, | ||
1046 | lal_tail, | ||
1047 | pos); | ||
1048 | if ((AF_INET == pos->af) && | ||
1049 | (NULL == pos->hc) && | ||
1050 | (0 != (GNUNET_NAT_AC_LAN & pos->ac))) | ||
1051 | { | ||
1052 | const struct sockaddr_in *s4 | ||
1053 | = (const struct sockaddr_in *)&pos->addr; | ||
1054 | |||
1055 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
1056 | "Found NATed local address %s, starting NAT server\n", | ||
1057 | GNUNET_a2s((const struct sockaddr *)&pos->addr, | ||
1058 | sizeof(*s4))); | ||
1059 | pos->hc = GN_start_gnunet_nat_server_(&s4->sin_addr, | ||
1060 | &reversal_callback, | ||
1061 | pos, | ||
1062 | cfg); | ||
1063 | } | ||
1064 | } | ||
1065 | } | 1047 | } |
1066 | GN_nat_status_changed(have_nat); | 1048 | else |
1049 | { | ||
1050 | notify_clients (pos, | ||
1051 | GNUNET_YES); | ||
1052 | GNUNET_CONTAINER_DLL_insert (lal_head, | ||
1053 | lal_tail, | ||
1054 | pos); | ||
1055 | if ((AF_INET == pos->af) && | ||
1056 | (NULL == pos->hc) && | ||
1057 | (0 != (GNUNET_NAT_AC_LAN & pos->ac))) | ||
1058 | { | ||
1059 | const struct sockaddr_in *s4 | ||
1060 | = (const struct sockaddr_in *) &pos->addr; | ||
1061 | |||
1062 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1063 | "Found NATed local address %s, starting NAT server\n", | ||
1064 | GNUNET_a2s ((const struct sockaddr *) &pos->addr, | ||
1065 | sizeof(*s4))); | ||
1066 | pos->hc = GN_start_gnunet_nat_server_ (&s4->sin_addr, | ||
1067 | &reversal_callback, | ||
1068 | pos, | ||
1069 | cfg); | ||
1070 | } | ||
1071 | } | ||
1072 | } | ||
1073 | GN_nat_status_changed (have_nat); | ||
1067 | } | 1074 | } |
1068 | 1075 | ||
1069 | 1076 | ||
@@ -1079,91 +1086,91 @@ run_scan(void *cls) | |||
1079 | * @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code | 1086 | * @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code |
1080 | */ | 1087 | */ |
1081 | static void | 1088 | static void |
1082 | upnp_addr_change_cb(void *cls, | 1089 | upnp_addr_change_cb (void *cls, |
1083 | int add_remove, | 1090 | int add_remove, |
1084 | const struct sockaddr *addr, | 1091 | const struct sockaddr *addr, |
1085 | socklen_t addrlen, | 1092 | socklen_t addrlen, |
1086 | enum GNUNET_NAT_StatusCode result) | 1093 | enum GNUNET_NAT_StatusCode result) |
1087 | { | 1094 | { |
1088 | struct ClientHandle *ch = cls; | 1095 | struct ClientHandle *ch = cls; |
1089 | enum GNUNET_NAT_AddressClass ac; | 1096 | enum GNUNET_NAT_AddressClass ac; |
1090 | 1097 | ||
1091 | switch (result) | 1098 | switch (result) |
1092 | { | 1099 | { |
1093 | case GNUNET_NAT_ERROR_SUCCESS: | 1100 | case GNUNET_NAT_ERROR_SUCCESS: |
1094 | GNUNET_assert(NULL != addr); | 1101 | GNUNET_assert (NULL != addr); |
1095 | break; | 1102 | break; |
1096 | 1103 | ||
1097 | case GNUNET_NAT_ERROR_UPNPC_FAILED: | 1104 | case GNUNET_NAT_ERROR_UPNPC_FAILED: |
1098 | case GNUNET_NAT_ERROR_UPNPC_TIMEOUT: | 1105 | case GNUNET_NAT_ERROR_UPNPC_TIMEOUT: |
1099 | case GNUNET_NAT_ERROR_IPC_FAILURE: | 1106 | case GNUNET_NAT_ERROR_IPC_FAILURE: |
1100 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1107 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1101 | "Running upnpc failed: %d\n", | 1108 | "Running upnpc failed: %d\n", |
1102 | result); | 1109 | result); |
1103 | return; | 1110 | return; |
1104 | 1111 | ||
1105 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND: | 1112 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND: |
1106 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1113 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1107 | "external-ip binary not found\n"); | 1114 | "external-ip binary not found\n"); |
1108 | return; | 1115 | return; |
1109 | 1116 | ||
1110 | case GNUNET_NAT_ERROR_UPNPC_NOT_FOUND: | 1117 | case GNUNET_NAT_ERROR_UPNPC_NOT_FOUND: |
1111 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1118 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1112 | "upnpc binary not found\n"); | 1119 | "upnpc binary not found\n"); |
1113 | return; | 1120 | return; |
1114 | 1121 | ||
1115 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED: | 1122 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED: |
1116 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 1123 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1117 | "external-ip binary could not be run\n"); | 1124 | "external-ip binary could not be run\n"); |
1118 | return; | 1125 | return; |
1119 | 1126 | ||
1120 | case GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED: | 1127 | case GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED: |
1121 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 1128 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1122 | "upnpc failed to create port mapping\n"); | 1129 | "upnpc failed to create port mapping\n"); |
1123 | return; | 1130 | return; |
1124 | 1131 | ||
1125 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID: | 1132 | case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID: |
1126 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1133 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1127 | "Invalid output from upnpc\n"); | 1134 | "Invalid output from upnpc\n"); |
1128 | return; | 1135 | return; |
1129 | 1136 | ||
1130 | case GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID: | 1137 | case GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID: |
1131 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1138 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1132 | "Invalid address returned by upnpc\n"); | 1139 | "Invalid address returned by upnpc\n"); |
1133 | return; | 1140 | return; |
1134 | 1141 | ||
1135 | default: | 1142 | default: |
1136 | GNUNET_break(0); /* should not be possible */ | 1143 | GNUNET_break (0); /* should not be possible */ |
1137 | return; | 1144 | return; |
1138 | } | 1145 | } |
1139 | switch (addr->sa_family) | 1146 | switch (addr->sa_family) |
1140 | { | 1147 | { |
1141 | case AF_INET: | 1148 | case AF_INET: |
1142 | ac = is_nat_v4(&((const struct sockaddr_in *)addr)->sin_addr) | 1149 | ac = is_nat_v4 (&((const struct sockaddr_in *) addr)->sin_addr) |
1143 | ? GNUNET_NAT_AC_LAN | 1150 | ? GNUNET_NAT_AC_LAN |
1144 | : GNUNET_NAT_AC_EXTERN; | 1151 | : GNUNET_NAT_AC_EXTERN; |
1145 | break; | 1152 | break; |
1146 | 1153 | ||
1147 | case AF_INET6: | 1154 | case AF_INET6: |
1148 | ac = is_nat_v6(&((const struct sockaddr_in6 *)addr)->sin6_addr) | 1155 | ac = is_nat_v6 (&((const struct sockaddr_in6 *) addr)->sin6_addr) |
1149 | ? GNUNET_NAT_AC_LAN | 1156 | ? GNUNET_NAT_AC_LAN |
1150 | : GNUNET_NAT_AC_EXTERN; | 1157 | : GNUNET_NAT_AC_EXTERN; |
1151 | break; | 1158 | break; |
1152 | 1159 | ||
1153 | default: | 1160 | default: |
1154 | GNUNET_break(0); | 1161 | GNUNET_break (0); |
1155 | return; | 1162 | return; |
1156 | } | 1163 | } |
1157 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1164 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1158 | "upnp external address %s: %s\n", | 1165 | "upnp external address %s: %s\n", |
1159 | add_remove ? "added" : "removed", | 1166 | add_remove ? "added" : "removed", |
1160 | GNUNET_a2s(addr, | 1167 | GNUNET_a2s (addr, |
1161 | addrlen)); | 1168 | addrlen)); |
1162 | notify_client(ac, | 1169 | notify_client (ac, |
1163 | ch, | 1170 | ch, |
1164 | add_remove, | 1171 | add_remove, |
1165 | addr, | 1172 | addr, |
1166 | addrlen); | 1173 | addrlen); |
1167 | } | 1174 | } |
1168 | 1175 | ||
1169 | 1176 | ||
@@ -1176,7 +1183,7 @@ upnp_addr_change_cb(void *cls, | |||
1176 | * @param ch client handle to act upon | 1183 | * @param ch client handle to act upon |
1177 | */ | 1184 | */ |
1178 | static void | 1185 | static void |
1179 | dyndns_lookup(void *cls); | 1186 | dyndns_lookup (void *cls); |
1180 | 1187 | ||
1181 | 1188 | ||
1182 | /** | 1189 | /** |
@@ -1189,9 +1196,9 @@ dyndns_lookup(void *cls); | |||
1189 | * @param addrlen number of bytes in @a addr | 1196 | * @param addrlen number of bytes in @a addr |
1190 | */ | 1197 | */ |
1191 | static void | 1198 | static void |
1192 | process_external_ip(void *cls, | 1199 | process_external_ip (void *cls, |
1193 | const struct sockaddr *addr, | 1200 | const struct sockaddr *addr, |
1194 | socklen_t addrlen) | 1201 | socklen_t addrlen) |
1195 | { | 1202 | { |
1196 | struct ClientHandle *ch = cls; | 1203 | struct ClientHandle *ch = cls; |
1197 | struct LocalAddressList *lal; | 1204 | struct LocalAddressList *lal; |
@@ -1200,86 +1207,86 @@ process_external_ip(void *cls, | |||
1200 | struct sockaddr_in6 *v6; | 1207 | struct sockaddr_in6 *v6; |
1201 | 1208 | ||
1202 | if (NULL == addr) | 1209 | if (NULL == addr) |
1210 | { | ||
1211 | struct LocalAddressList *laln; | ||
1212 | |||
1213 | ch->ext_dns = NULL; | ||
1214 | ch->ext_dns_task | ||
1215 | = GNUNET_SCHEDULER_add_delayed (dyndns_frequency, | ||
1216 | &dyndns_lookup, | ||
1217 | ch); | ||
1218 | /* Current iteration is over, remove 'old' IPs now */ | ||
1219 | for (lal = ch->ext_addr_head; NULL != lal; lal = laln) | ||
1203 | { | 1220 | { |
1204 | struct LocalAddressList *laln; | 1221 | laln = lal->next; |
1205 | 1222 | if (GNUNET_YES == lal->old) | |
1206 | ch->ext_dns = NULL; | 1223 | { |
1207 | ch->ext_dns_task | 1224 | GNUNET_CONTAINER_DLL_remove (ch->ext_addr_head, |
1208 | = GNUNET_SCHEDULER_add_delayed(dyndns_frequency, | 1225 | ch->ext_addr_tail, |
1209 | &dyndns_lookup, | 1226 | lal); |
1210 | ch); | 1227 | check_notify_client (lal, |
1211 | /* Current iteration is over, remove 'old' IPs now */ | 1228 | ch, |
1212 | for (lal = ch->ext_addr_head; NULL != lal; lal = laln) | 1229 | GNUNET_NO); |
1213 | { | 1230 | GNUNET_free (lal); |
1214 | laln = lal->next; | 1231 | } |
1215 | if (GNUNET_YES == lal->old) | ||
1216 | { | ||
1217 | GNUNET_CONTAINER_DLL_remove(ch->ext_addr_head, | ||
1218 | ch->ext_addr_tail, | ||
1219 | lal); | ||
1220 | check_notify_client(lal, | ||
1221 | ch, | ||
1222 | GNUNET_NO); | ||
1223 | GNUNET_free(lal); | ||
1224 | } | ||
1225 | } | ||
1226 | return; | ||
1227 | } | 1232 | } |
1228 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1233 | return; |
1229 | "Got IP `%s' for external address `%s'\n", | 1234 | } |
1230 | GNUNET_a2s(addr, | 1235 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1231 | addrlen), | 1236 | "Got IP `%s' for external address `%s'\n", |
1232 | ch->hole_external); | 1237 | GNUNET_a2s (addr, |
1238 | addrlen), | ||
1239 | ch->hole_external); | ||
1233 | 1240 | ||
1234 | /* build sockaddr storage with port number */ | 1241 | /* build sockaddr storage with port number */ |
1235 | memset(&ss, | 1242 | memset (&ss, |
1236 | 0, | 1243 | 0, |
1237 | sizeof(ss)); | 1244 | sizeof(ss)); |
1238 | GNUNET_memcpy(&ss, | 1245 | GNUNET_memcpy (&ss, |
1239 | addr, | 1246 | addr, |
1240 | addrlen); | 1247 | addrlen); |
1241 | switch (addr->sa_family) | 1248 | switch (addr->sa_family) |
1242 | { | 1249 | { |
1243 | case AF_INET: | 1250 | case AF_INET: |
1244 | v4 = (struct sockaddr_in *)&ss; | 1251 | v4 = (struct sockaddr_in *) &ss; |
1245 | v4->sin_port = htons(ch->ext_dns_port); | 1252 | v4->sin_port = htons (ch->ext_dns_port); |
1246 | break; | 1253 | break; |
1247 | 1254 | ||
1248 | case AF_INET6: | 1255 | case AF_INET6: |
1249 | v6 = (struct sockaddr_in6 *)&ss; | 1256 | v6 = (struct sockaddr_in6 *) &ss; |
1250 | v6->sin6_port = htons(ch->ext_dns_port); | 1257 | v6->sin6_port = htons (ch->ext_dns_port); |
1251 | break; | 1258 | break; |
1252 | 1259 | ||
1253 | default: | 1260 | default: |
1254 | GNUNET_break(0); | 1261 | GNUNET_break (0); |
1255 | return; | 1262 | return; |
1256 | } | 1263 | } |
1257 | /* See if 'ss' matches any of our known addresses */ | 1264 | /* See if 'ss' matches any of our known addresses */ |
1258 | for (lal = ch->ext_addr_head; NULL != lal; lal = lal->next) | 1265 | for (lal = ch->ext_addr_head; NULL != lal; lal = lal->next) |
1266 | { | ||
1267 | if (GNUNET_NO == lal->old) | ||
1268 | continue; /* already processed, skip */ | ||
1269 | if ((addr->sa_family == lal->addr.ss_family) && | ||
1270 | (0 == memcmp (&ss, | ||
1271 | &lal->addr, | ||
1272 | addrlen))) | ||
1259 | { | 1273 | { |
1260 | if (GNUNET_NO == lal->old) | 1274 | /* Address unchanged, remember so we do not remove */ |
1261 | continue; /* already processed, skip */ | 1275 | lal->old = GNUNET_NO; |
1262 | if ((addr->sa_family == lal->addr.ss_family) && | 1276 | return; /* done here */ |
1263 | (0 == memcmp(&ss, | ||
1264 | &lal->addr, | ||
1265 | addrlen))) | ||
1266 | { | ||
1267 | /* Address unchanged, remember so we do not remove */ | ||
1268 | lal->old = GNUNET_NO; | ||
1269 | return; /* done here */ | ||
1270 | } | ||
1271 | } | 1277 | } |
1278 | } | ||
1272 | /* notify client, and remember IP for later removal! */ | 1279 | /* notify client, and remember IP for later removal! */ |
1273 | lal = GNUNET_new(struct LocalAddressList); | 1280 | lal = GNUNET_new (struct LocalAddressList); |
1274 | lal->addr = ss; | 1281 | lal->addr = ss; |
1275 | lal->af = ss.ss_family; | 1282 | lal->af = ss.ss_family; |
1276 | lal->ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL; | 1283 | lal->ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL; |
1277 | GNUNET_CONTAINER_DLL_insert(ch->ext_addr_head, | 1284 | GNUNET_CONTAINER_DLL_insert (ch->ext_addr_head, |
1278 | ch->ext_addr_tail, | 1285 | ch->ext_addr_tail, |
1279 | lal); | 1286 | lal); |
1280 | check_notify_client(lal, | 1287 | check_notify_client (lal, |
1281 | ch, | 1288 | ch, |
1282 | GNUNET_YES); | 1289 | GNUNET_YES); |
1283 | } | 1290 | } |
1284 | 1291 | ||
1285 | 1292 | ||
@@ -1292,24 +1299,24 @@ process_external_ip(void *cls, | |||
1292 | * @param ch client handle to act upon | 1299 | * @param ch client handle to act upon |
1293 | */ | 1300 | */ |
1294 | static void | 1301 | static void |
1295 | dyndns_lookup(void *cls) | 1302 | dyndns_lookup (void *cls) |
1296 | { | 1303 | { |
1297 | struct ClientHandle *ch = cls; | 1304 | struct ClientHandle *ch = cls; |
1298 | struct LocalAddressList *lal; | 1305 | struct LocalAddressList *lal; |
1299 | 1306 | ||
1300 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1307 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1301 | "Performing DNS lookup for punched hole given for `%s' as `%s:%u'\n", | 1308 | "Performing DNS lookup for punched hole given for `%s' as `%s:%u'\n", |
1302 | ch->section_name, | 1309 | ch->section_name, |
1303 | ch->hole_external, | 1310 | ch->hole_external, |
1304 | (unsigned int)ch->ext_dns_port); | 1311 | (unsigned int) ch->ext_dns_port); |
1305 | for (lal = ch->ext_addr_head; NULL != lal; lal = lal->next) | 1312 | for (lal = ch->ext_addr_head; NULL != lal; lal = lal->next) |
1306 | lal->old = GNUNET_YES; | 1313 | lal->old = GNUNET_YES; |
1307 | ch->ext_dns_task = NULL; | 1314 | ch->ext_dns_task = NULL; |
1308 | ch->ext_dns = GNUNET_RESOLVER_ip_get(ch->hole_external, | 1315 | ch->ext_dns = GNUNET_RESOLVER_ip_get (ch->hole_external, |
1309 | AF_UNSPEC, | 1316 | AF_UNSPEC, |
1310 | GNUNET_TIME_UNIT_MINUTES, | 1317 | GNUNET_TIME_UNIT_MINUTES, |
1311 | &process_external_ip, | 1318 | &process_external_ip, |
1312 | ch); | 1319 | ch); |
1313 | } | 1320 | } |
1314 | 1321 | ||
1315 | 1322 | ||
@@ -1325,105 +1332,107 @@ dyndns_lookup(void *cls) | |||
1325 | * @param ch client handle to act upon | 1332 | * @param ch client handle to act upon |
1326 | */ | 1333 | */ |
1327 | static void | 1334 | static void |
1328 | lookup_hole_external(struct ClientHandle *ch) | 1335 | lookup_hole_external (struct ClientHandle *ch) |
1329 | { | 1336 | { |
1330 | char *port; | 1337 | char *port; |
1331 | unsigned int pnum; | 1338 | unsigned int pnum; |
1332 | struct sockaddr_in *s4; | 1339 | struct sockaddr_in *s4; |
1333 | struct LocalAddressList *lal; | 1340 | struct LocalAddressList *lal; |
1334 | 1341 | ||
1335 | port = strrchr(ch->hole_external, ':'); | 1342 | port = strrchr (ch->hole_external, ':'); |
1336 | if (NULL == port) | 1343 | if (NULL == port) |
1337 | { | 1344 | { |
1338 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 1345 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1339 | _("Malformed punched hole specification `%s' (lacks port)\n"), | 1346 | _ ("Malformed punched hole specification `%s' (lacks port)\n"), |
1340 | ch->hole_external); | 1347 | ch->hole_external); |
1341 | return; | 1348 | return; |
1342 | } | 1349 | } |
1343 | if ((1 != sscanf(port + 1, | 1350 | if ((1 != sscanf (port + 1, |
1344 | "%u", | 1351 | "%u", |
1345 | &pnum)) || | 1352 | &pnum)) || |
1346 | (pnum > 65535)) | 1353 | (pnum > 65535)) |
1347 | { | 1354 | { |
1348 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 1355 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1349 | _("Invalid port number in punched hole specification `%s' (lacks port)\n"), | 1356 | _ ( |
1350 | port + 1); | 1357 | "Invalid port number in punched hole specification `%s' (lacks port)\n"), |
1351 | return; | 1358 | port + 1); |
1352 | } | 1359 | return; |
1353 | ch->ext_dns_port = (uint16_t)pnum; | 1360 | } |
1361 | ch->ext_dns_port = (uint16_t) pnum; | ||
1354 | *port = '\0'; | 1362 | *port = '\0'; |
1355 | 1363 | ||
1356 | lal = GNUNET_new(struct LocalAddressList); | 1364 | lal = GNUNET_new (struct LocalAddressList); |
1357 | if ('[' == *ch->hole_external) | 1365 | if ('[' == *ch->hole_external) |
1358 | { | 1366 | { |
1359 | struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)&lal->addr; | 1367 | struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) &lal->addr; |
1360 | |||
1361 | s6->sin6_family = AF_INET6; | ||
1362 | if (']' != (ch->hole_external[strlen(ch->hole_external) - 1])) | ||
1363 | { | ||
1364 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | ||
1365 | _("Malformed punched hole specification `%s' (lacks `]')\n"), | ||
1366 | ch->hole_external); | ||
1367 | GNUNET_free(lal); | ||
1368 | return; | ||
1369 | } | ||
1370 | ch->hole_external[strlen(ch->hole_external) - 1] = '\0'; | ||
1371 | if (1 != inet_pton(AF_INET6, | ||
1372 | ch->hole_external + 1, | ||
1373 | &s6->sin6_addr)) | ||
1374 | { | ||
1375 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | ||
1376 | _("Malformed punched hole specification `%s' (IPv6 address invalid)"), | ||
1377 | ch->hole_external + 1); | ||
1378 | GNUNET_free(lal); | ||
1379 | return; | ||
1380 | } | ||
1381 | s6->sin6_port = htons(ch->ext_dns_port); | ||
1382 | lal->af = AF_INET6; | ||
1383 | lal->ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL; | ||
1384 | GNUNET_CONTAINER_DLL_insert(ch->ext_addr_head, | ||
1385 | ch->ext_addr_tail, | ||
1386 | lal); | ||
1387 | check_notify_client(lal, | ||
1388 | ch, | ||
1389 | GNUNET_YES); | ||
1390 | return; | ||
1391 | } | ||
1392 | 1368 | ||
1393 | s4 = (struct sockaddr_in *)&lal->addr; | 1369 | s6->sin6_family = AF_INET6; |
1394 | s4->sin_family = AF_INET; | 1370 | if (']' != (ch->hole_external[strlen (ch->hole_external) - 1])) |
1395 | if (1 == inet_pton(AF_INET, | ||
1396 | ch->hole_external, | ||
1397 | &s4->sin_addr)) | ||
1398 | { | 1371 | { |
1399 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1372 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1400 | "IPv4 punched hole given for `%s' via `%s:%u'\n", | 1373 | _ ("Malformed punched hole specification `%s' (lacks `]')\n"), |
1401 | ch->section_name, | 1374 | ch->hole_external); |
1402 | ch->hole_external, | 1375 | GNUNET_free (lal); |
1403 | (unsigned int)ch->ext_dns_port); | ||
1404 | s4->sin_port = htons(ch->ext_dns_port); | ||
1405 | lal->af = AF_INET; | ||
1406 | lal->ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL; | ||
1407 | GNUNET_CONTAINER_DLL_insert(ch->ext_addr_head, | ||
1408 | ch->ext_addr_tail, | ||
1409 | lal); | ||
1410 | check_notify_client(lal, | ||
1411 | ch, | ||
1412 | GNUNET_YES); | ||
1413 | return; | 1376 | return; |
1414 | } | 1377 | } |
1415 | if (0 == strcasecmp(ch->hole_external, | 1378 | ch->hole_external[strlen (ch->hole_external) - 1] = '\0'; |
1416 | "AUTO")) | 1379 | if (1 != inet_pton (AF_INET6, |
1380 | ch->hole_external + 1, | ||
1381 | &s6->sin6_addr)) | ||
1417 | { | 1382 | { |
1418 | /* handled in #notify_client_external_ipv4_change() */ | 1383 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1419 | GNUNET_free(lal); | 1384 | _ ( |
1385 | "Malformed punched hole specification `%s' (IPv6 address invalid)"), | ||
1386 | ch->hole_external + 1); | ||
1387 | GNUNET_free (lal); | ||
1420 | return; | 1388 | return; |
1421 | } | 1389 | } |
1390 | s6->sin6_port = htons (ch->ext_dns_port); | ||
1391 | lal->af = AF_INET6; | ||
1392 | lal->ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL; | ||
1393 | GNUNET_CONTAINER_DLL_insert (ch->ext_addr_head, | ||
1394 | ch->ext_addr_tail, | ||
1395 | lal); | ||
1396 | check_notify_client (lal, | ||
1397 | ch, | ||
1398 | GNUNET_YES); | ||
1399 | return; | ||
1400 | } | ||
1401 | |||
1402 | s4 = (struct sockaddr_in *) &lal->addr; | ||
1403 | s4->sin_family = AF_INET; | ||
1404 | if (1 == inet_pton (AF_INET, | ||
1405 | ch->hole_external, | ||
1406 | &s4->sin_addr)) | ||
1407 | { | ||
1408 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1409 | "IPv4 punched hole given for `%s' via `%s:%u'\n", | ||
1410 | ch->section_name, | ||
1411 | ch->hole_external, | ||
1412 | (unsigned int) ch->ext_dns_port); | ||
1413 | s4->sin_port = htons (ch->ext_dns_port); | ||
1414 | lal->af = AF_INET; | ||
1415 | lal->ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL; | ||
1416 | GNUNET_CONTAINER_DLL_insert (ch->ext_addr_head, | ||
1417 | ch->ext_addr_tail, | ||
1418 | lal); | ||
1419 | check_notify_client (lal, | ||
1420 | ch, | ||
1421 | GNUNET_YES); | ||
1422 | return; | ||
1423 | } | ||
1424 | if (0 == strcasecmp (ch->hole_external, | ||
1425 | "AUTO")) | ||
1426 | { | ||
1427 | /* handled in #notify_client_external_ipv4_change() */ | ||
1428 | GNUNET_free (lal); | ||
1429 | return; | ||
1430 | } | ||
1422 | /* got a DNS name, trigger lookup! */ | 1431 | /* got a DNS name, trigger lookup! */ |
1423 | GNUNET_free(lal); | 1432 | GNUNET_free (lal); |
1424 | ch->ext_dns_task | 1433 | ch->ext_dns_task |
1425 | = GNUNET_SCHEDULER_add_now(&dyndns_lookup, | 1434 | = GNUNET_SCHEDULER_add_now (&dyndns_lookup, |
1426 | ch); | 1435 | ch); |
1427 | } | 1436 | } |
1428 | 1437 | ||
1429 | 1438 | ||
@@ -1435,8 +1444,8 @@ lookup_hole_external(struct ClientHandle *ch) | |||
1435 | * @param message the message received | 1444 | * @param message the message received |
1436 | */ | 1445 | */ |
1437 | static void | 1446 | static void |
1438 | handle_register(void *cls, | 1447 | handle_register (void *cls, |
1439 | const struct GNUNET_NAT_RegisterMessage *message) | 1448 | const struct GNUNET_NAT_RegisterMessage *message) |
1440 | { | 1449 | { |
1441 | struct ClientHandle *ch = cls; | 1450 | struct ClientHandle *ch = cls; |
1442 | const char *off; | 1451 | const char *off; |
@@ -1444,125 +1453,125 @@ handle_register(void *cls, | |||
1444 | 1453 | ||
1445 | if ((0 != ch->proto) || | 1454 | if ((0 != ch->proto) || |
1446 | (NULL != ch->caddrs)) | 1455 | (NULL != ch->caddrs)) |
1447 | { | 1456 | { |
1448 | /* double registration not allowed */ | 1457 | /* double registration not allowed */ |
1449 | GNUNET_break(0); | 1458 | GNUNET_break (0); |
1450 | GNUNET_SERVICE_client_drop(ch->client); | 1459 | GNUNET_SERVICE_client_drop (ch->client); |
1451 | return; | 1460 | return; |
1452 | } | 1461 | } |
1453 | ch->flags = message->flags; | 1462 | ch->flags = message->flags; |
1454 | ch->proto = message->proto; | 1463 | ch->proto = message->proto; |
1455 | ch->num_caddrs = ntohs(message->num_addrs); | 1464 | ch->num_caddrs = ntohs (message->num_addrs); |
1456 | ch->caddrs = GNUNET_new_array(ch->num_caddrs, | 1465 | ch->caddrs = GNUNET_new_array (ch->num_caddrs, |
1457 | struct ClientAddress); | 1466 | struct ClientAddress); |
1458 | left = ntohs(message->header.size) - sizeof(*message); | 1467 | left = ntohs (message->header.size) - sizeof(*message); |
1459 | off = (const char *)&message[1]; | 1468 | off = (const char *) &message[1]; |
1460 | for (unsigned int i = 0; i < ch->num_caddrs; i++) | 1469 | for (unsigned int i = 0; i < ch->num_caddrs; i++) |
1470 | { | ||
1471 | const struct sockaddr *sa = (const struct sockaddr *) off; | ||
1472 | size_t alen; | ||
1473 | uint16_t port; | ||
1474 | int is_nat; | ||
1475 | |||
1476 | if (sizeof(sa_family_t) > left) | ||
1461 | { | 1477 | { |
1462 | const struct sockaddr *sa = (const struct sockaddr *)off; | 1478 | GNUNET_break (0); |
1463 | size_t alen; | 1479 | GNUNET_SERVICE_client_drop (ch->client); |
1464 | uint16_t port; | 1480 | return; |
1465 | int is_nat; | 1481 | } |
1466 | 1482 | is_nat = GNUNET_NO; | |
1467 | if (sizeof(sa_family_t) > left) | 1483 | switch (sa->sa_family) |
1468 | { | 1484 | { |
1469 | GNUNET_break(0); | 1485 | case AF_INET: |
1470 | GNUNET_SERVICE_client_drop(ch->client); | 1486 | { |
1471 | return; | 1487 | struct sockaddr_in s4; |
1472 | } | 1488 | |
1473 | is_nat = GNUNET_NO; | 1489 | GNUNET_memcpy (&s4, |
1474 | switch (sa->sa_family) | 1490 | off, |
1475 | { | 1491 | sizeof(struct sockaddr_in)); |
1476 | case AF_INET: | 1492 | alen = sizeof(struct sockaddr_in); |
1477 | { | 1493 | if (is_nat_v4 (&s4.sin_addr)) |
1478 | struct sockaddr_in s4; | 1494 | is_nat = GNUNET_YES; |
1479 | 1495 | port = ntohs (s4.sin_port); | |
1480 | GNUNET_memcpy(&s4, | 1496 | } |
1481 | off, | 1497 | break; |
1482 | sizeof(struct sockaddr_in)); | 1498 | |
1483 | alen = sizeof(struct sockaddr_in); | 1499 | case AF_INET6: |
1484 | if (is_nat_v4(&s4.sin_addr)) | 1500 | { |
1485 | is_nat = GNUNET_YES; | 1501 | struct sockaddr_in6 s6; |
1486 | port = ntohs(s4.sin_port); | 1502 | |
1487 | } | 1503 | GNUNET_memcpy (&s6, |
1488 | break; | 1504 | off, |
1489 | 1505 | sizeof(struct sockaddr_in6)); | |
1490 | case AF_INET6: | 1506 | alen = sizeof(struct sockaddr_in6); |
1491 | { | 1507 | if (is_nat_v6 (&s6.sin6_addr)) |
1492 | struct sockaddr_in6 s6; | 1508 | is_nat = GNUNET_YES; |
1493 | 1509 | port = ntohs (s6.sin6_port); | |
1494 | GNUNET_memcpy(&s6, | 1510 | } |
1495 | off, | 1511 | break; |
1496 | sizeof(struct sockaddr_in6)); | ||
1497 | alen = sizeof(struct sockaddr_in6); | ||
1498 | if (is_nat_v6(&s6.sin6_addr)) | ||
1499 | is_nat = GNUNET_YES; | ||
1500 | port = ntohs(s6.sin6_port); | ||
1501 | } | ||
1502 | break; | ||
1503 | 1512 | ||
1504 | #if AF_UNIX | 1513 | #if AF_UNIX |
1505 | case AF_UNIX: | 1514 | case AF_UNIX: |
1506 | alen = sizeof(struct sockaddr_un); | 1515 | alen = sizeof(struct sockaddr_un); |
1507 | port = 0; | 1516 | port = 0; |
1508 | break; | 1517 | break; |
1509 | #endif | 1518 | #endif |
1510 | default: | 1519 | default: |
1511 | GNUNET_break(0); | 1520 | GNUNET_break (0); |
1512 | GNUNET_SERVICE_client_drop(ch->client); | 1521 | GNUNET_SERVICE_client_drop (ch->client); |
1513 | return; | 1522 | return; |
1514 | } | ||
1515 | /* store address */ | ||
1516 | GNUNET_assert(alen <= left); | ||
1517 | GNUNET_assert(alen <= sizeof(struct sockaddr_storage)); | ||
1518 | GNUNET_memcpy(&ch->caddrs[i].ss, | ||
1519 | off, | ||
1520 | alen); | ||
1521 | |||
1522 | /* If applicable, try UPNPC NAT punching */ | ||
1523 | if ((is_nat) && | ||
1524 | (enable_upnp) && | ||
1525 | ((IPPROTO_TCP == ch->proto) || | ||
1526 | (IPPROTO_UDP == ch->proto))) | ||
1527 | { | ||
1528 | ch->natted_address = GNUNET_YES; | ||
1529 | ch->caddrs[i].mh | ||
1530 | = GNUNET_NAT_mini_map_start(port, | ||
1531 | IPPROTO_TCP == ch->proto, | ||
1532 | &upnp_addr_change_cb, | ||
1533 | ch); | ||
1534 | } | ||
1535 | |||
1536 | off += alen; | ||
1537 | } | 1523 | } |
1524 | /* store address */ | ||
1525 | GNUNET_assert (alen <= left); | ||
1526 | GNUNET_assert (alen <= sizeof(struct sockaddr_storage)); | ||
1527 | GNUNET_memcpy (&ch->caddrs[i].ss, | ||
1528 | off, | ||
1529 | alen); | ||
1530 | |||
1531 | /* If applicable, try UPNPC NAT punching */ | ||
1532 | if ((is_nat) && | ||
1533 | (enable_upnp) && | ||
1534 | ((IPPROTO_TCP == ch->proto) || | ||
1535 | (IPPROTO_UDP == ch->proto))) | ||
1536 | { | ||
1537 | ch->natted_address = GNUNET_YES; | ||
1538 | ch->caddrs[i].mh | ||
1539 | = GNUNET_NAT_mini_map_start (port, | ||
1540 | IPPROTO_TCP == ch->proto, | ||
1541 | &upnp_addr_change_cb, | ||
1542 | ch); | ||
1543 | } | ||
1544 | |||
1545 | off += alen; | ||
1546 | } | ||
1538 | 1547 | ||
1539 | ch->section_name | 1548 | ch->section_name |
1540 | = GNUNET_strndup(off, | 1549 | = GNUNET_strndup (off, |
1541 | ntohs(message->str_len)); | 1550 | ntohs (message->str_len)); |
1542 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1551 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1543 | "Received REGISTER message from client for subsystem `%s'\n", | 1552 | "Received REGISTER message from client for subsystem `%s'\n", |
1544 | ch->section_name); | 1553 | ch->section_name); |
1545 | if (GNUNET_OK == | 1554 | if (GNUNET_OK == |
1546 | GNUNET_CONFIGURATION_get_value_string(cfg, | 1555 | GNUNET_CONFIGURATION_get_value_string (cfg, |
1547 | ch->section_name, | 1556 | ch->section_name, |
1548 | "HOLE_EXTERNAL", | 1557 | "HOLE_EXTERNAL", |
1549 | &ch->hole_external)) | 1558 | &ch->hole_external)) |
1550 | lookup_hole_external(ch); | 1559 | lookup_hole_external (ch); |
1551 | 1560 | ||
1552 | /* Actually send IP address list to client */ | 1561 | /* Actually send IP address list to client */ |
1553 | for (struct LocalAddressList *lal = lal_head; | 1562 | for (struct LocalAddressList *lal = lal_head; |
1554 | NULL != lal; | 1563 | NULL != lal; |
1555 | lal = lal->next) | 1564 | lal = lal->next) |
1556 | { | 1565 | { |
1557 | check_notify_client(lal, | 1566 | check_notify_client (lal, |
1558 | ch, | 1567 | ch, |
1559 | GNUNET_YES); | 1568 | GNUNET_YES); |
1560 | } | 1569 | } |
1561 | /* Also consider IPv4 determined by `external-ip` */ | 1570 | /* Also consider IPv4 determined by `external-ip` */ |
1562 | ch->external_monitor | 1571 | ch->external_monitor |
1563 | = GN_external_ipv4_monitor_start(¬ify_client_external_ipv4_change, | 1572 | = GN_external_ipv4_monitor_start (¬ify_client_external_ipv4_change, |
1564 | ch); | 1573 | ch); |
1565 | GNUNET_SERVICE_client_continue(ch->client); | 1574 | GNUNET_SERVICE_client_continue (ch->client); |
1566 | } | 1575 | } |
1567 | 1576 | ||
1568 | 1577 | ||
@@ -1575,22 +1584,22 @@ handle_register(void *cls, | |||
1575 | * @return #GNUNET_OK if message is well-formed | 1584 | * @return #GNUNET_OK if message is well-formed |
1576 | */ | 1585 | */ |
1577 | static int | 1586 | static int |
1578 | check_stun(void *cls, | 1587 | check_stun (void *cls, |
1579 | const struct GNUNET_NAT_HandleStunMessage *message) | 1588 | const struct GNUNET_NAT_HandleStunMessage *message) |
1580 | { | 1589 | { |
1581 | size_t sa_len = ntohs(message->sender_addr_size); | 1590 | size_t sa_len = ntohs (message->sender_addr_size); |
1582 | size_t expect = sa_len + ntohs(message->payload_size); | 1591 | size_t expect = sa_len + ntohs (message->payload_size); |
1583 | 1592 | ||
1584 | if (ntohs(message->header.size) - sizeof(*message) != expect) | 1593 | if (ntohs (message->header.size) - sizeof(*message) != expect) |
1585 | { | 1594 | { |
1586 | GNUNET_break(0); | 1595 | GNUNET_break (0); |
1587 | return GNUNET_SYSERR; | 1596 | return GNUNET_SYSERR; |
1588 | } | 1597 | } |
1589 | if (sa_len < sizeof(sa_family_t)) | 1598 | if (sa_len < sizeof(sa_family_t)) |
1590 | { | 1599 | { |
1591 | GNUNET_break(0); | 1600 | GNUNET_break (0); |
1592 | return GNUNET_SYSERR; | 1601 | return GNUNET_SYSERR; |
1593 | } | 1602 | } |
1594 | return GNUNET_OK; | 1603 | return GNUNET_OK; |
1595 | } | 1604 | } |
1596 | 1605 | ||
@@ -1603,33 +1612,33 @@ check_stun(void *cls, | |||
1603 | * @param add #GNUNET_YES to add, #GNUNET_NO to remove | 1612 | * @param add #GNUNET_YES to add, #GNUNET_NO to remove |
1604 | */ | 1613 | */ |
1605 | static void | 1614 | static void |
1606 | notify_clients_stun_change(const struct sockaddr_in *ip, | 1615 | notify_clients_stun_change (const struct sockaddr_in *ip, |
1607 | int add) | 1616 | int add) |
1608 | { | 1617 | { |
1609 | for (struct ClientHandle *ch = ch_head; | 1618 | for (struct ClientHandle *ch = ch_head; |
1610 | NULL != ch; | 1619 | NULL != ch; |
1611 | ch = ch->next) | 1620 | ch = ch->next) |
1612 | { | 1621 | { |
1613 | struct sockaddr_in v4; | 1622 | struct sockaddr_in v4; |
1614 | struct GNUNET_NAT_AddressChangeNotificationMessage *msg; | 1623 | struct GNUNET_NAT_AddressChangeNotificationMessage *msg; |
1615 | struct GNUNET_MQ_Envelope *env; | 1624 | struct GNUNET_MQ_Envelope *env; |
1616 | 1625 | ||
1617 | if (!ch->natted_address) | 1626 | if (! ch->natted_address) |
1618 | continue; | 1627 | continue; |
1619 | v4 = *ip; | 1628 | v4 = *ip; |
1620 | v4.sin_port = htons(0); | 1629 | v4.sin_port = htons (0); |
1621 | env = GNUNET_MQ_msg_extra(msg, | 1630 | env = GNUNET_MQ_msg_extra (msg, |
1622 | sizeof(v4), | 1631 | sizeof(v4), |
1623 | GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE); | 1632 | GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE); |
1624 | msg->add_remove = htonl((int32_t)add); | 1633 | msg->add_remove = htonl ((int32_t) add); |
1625 | msg->addr_class = htonl(GNUNET_NAT_AC_EXTERN | | 1634 | msg->addr_class = htonl (GNUNET_NAT_AC_EXTERN |
1626 | GNUNET_NAT_AC_GLOBAL); | 1635 | | GNUNET_NAT_AC_GLOBAL); |
1627 | GNUNET_memcpy(&msg[1], | 1636 | GNUNET_memcpy (&msg[1], |
1628 | &v4, | 1637 | &v4, |
1629 | sizeof(v4)); | 1638 | sizeof(v4)); |
1630 | GNUNET_MQ_send(ch->mq, | 1639 | GNUNET_MQ_send (ch->mq, |
1631 | env); | 1640 | env); |
1632 | } | 1641 | } |
1633 | } | 1642 | } |
1634 | 1643 | ||
1635 | 1644 | ||
@@ -1641,17 +1650,17 @@ notify_clients_stun_change(const struct sockaddr_in *ip, | |||
1641 | * @param cls the `struct StunExternalIP` to drop | 1650 | * @param cls the `struct StunExternalIP` to drop |
1642 | */ | 1651 | */ |
1643 | static void | 1652 | static void |
1644 | stun_ip_timeout(void *cls) | 1653 | stun_ip_timeout (void *cls) |
1645 | { | 1654 | { |
1646 | struct StunExternalIP *se = cls; | 1655 | struct StunExternalIP *se = cls; |
1647 | 1656 | ||
1648 | se->timeout_task = NULL; | 1657 | se->timeout_task = NULL; |
1649 | notify_clients_stun_change(&se->external_addr, | 1658 | notify_clients_stun_change (&se->external_addr, |
1650 | GNUNET_NO); | 1659 | GNUNET_NO); |
1651 | GNUNET_CONTAINER_DLL_remove(se_head, | 1660 | GNUNET_CONTAINER_DLL_remove (se_head, |
1652 | se_tail, | 1661 | se_tail, |
1653 | se); | 1662 | se); |
1654 | GNUNET_free(se); | 1663 | GNUNET_free (se); |
1655 | } | 1664 | } |
1656 | 1665 | ||
1657 | 1666 | ||
@@ -1663,107 +1672,107 @@ stun_ip_timeout(void *cls) | |||
1663 | * @param message the message received | 1672 | * @param message the message received |
1664 | */ | 1673 | */ |
1665 | static void | 1674 | static void |
1666 | handle_stun(void *cls, | 1675 | handle_stun (void *cls, |
1667 | const struct GNUNET_NAT_HandleStunMessage *message) | 1676 | const struct GNUNET_NAT_HandleStunMessage *message) |
1668 | { | 1677 | { |
1669 | struct ClientHandle *ch = cls; | 1678 | struct ClientHandle *ch = cls; |
1670 | const char *buf = (const char *)&message[1]; | 1679 | const char *buf = (const char *) &message[1]; |
1671 | const struct sockaddr *sa; | 1680 | const struct sockaddr *sa; |
1672 | const void *payload; | 1681 | const void *payload; |
1673 | size_t sa_len; | 1682 | size_t sa_len; |
1674 | size_t payload_size; | 1683 | size_t payload_size; |
1675 | struct sockaddr_in external_addr; | 1684 | struct sockaddr_in external_addr; |
1676 | 1685 | ||
1677 | sa_len = ntohs(message->sender_addr_size); | 1686 | sa_len = ntohs (message->sender_addr_size); |
1678 | payload_size = ntohs(message->payload_size); | 1687 | payload_size = ntohs (message->payload_size); |
1679 | sa = (const struct sockaddr *)&buf[0]; | 1688 | sa = (const struct sockaddr *) &buf[0]; |
1680 | payload = (const struct sockaddr *)&buf[sa_len]; | 1689 | payload = (const struct sockaddr *) &buf[sa_len]; |
1681 | switch (sa->sa_family) | 1690 | switch (sa->sa_family) |
1691 | { | ||
1692 | case AF_INET: | ||
1693 | if (sa_len != sizeof(struct sockaddr_in)) | ||
1682 | { | 1694 | { |
1683 | case AF_INET: | 1695 | GNUNET_break (0); |
1684 | if (sa_len != sizeof(struct sockaddr_in)) | 1696 | GNUNET_SERVICE_client_drop (ch->client); |
1685 | { | 1697 | return; |
1686 | GNUNET_break(0); | 1698 | } |
1687 | GNUNET_SERVICE_client_drop(ch->client); | 1699 | break; |
1688 | return; | ||
1689 | } | ||
1690 | break; | ||
1691 | 1700 | ||
1692 | case AF_INET6: | 1701 | case AF_INET6: |
1693 | if (sa_len != sizeof(struct sockaddr_in6)) | 1702 | if (sa_len != sizeof(struct sockaddr_in6)) |
1694 | { | 1703 | { |
1695 | GNUNET_break(0); | 1704 | GNUNET_break (0); |
1696 | GNUNET_SERVICE_client_drop(ch->client); | 1705 | GNUNET_SERVICE_client_drop (ch->client); |
1697 | return; | 1706 | return; |
1698 | } | ||
1699 | break; | ||
1700 | } | 1707 | } |
1701 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1708 | break; |
1702 | "Received HANDLE_STUN message from client\n"); | 1709 | } |
1710 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1711 | "Received HANDLE_STUN message from client\n"); | ||
1703 | if (GNUNET_OK == | 1712 | if (GNUNET_OK == |
1704 | GNUNET_NAT_stun_handle_packet_(payload, | 1713 | GNUNET_NAT_stun_handle_packet_ (payload, |
1705 | payload_size, | 1714 | payload_size, |
1706 | &external_addr)) | 1715 | &external_addr)) |
1716 | { | ||
1717 | /* We now know that a server at "sa" claims that | ||
1718 | we are visible at IP "external_addr". | ||
1719 | |||
1720 | We should (for some fixed period of time) tell | ||
1721 | all of our clients that listen to a NAT'ed address | ||
1722 | that they might want to consider the given 'external_ip' | ||
1723 | as their public IP address (this includes TCP and UDP | ||
1724 | clients, even if only UDP sends STUN requests). | ||
1725 | |||
1726 | If we do not get a renewal, the "external_addr" should be | ||
1727 | removed again. The timeout frequency should be configurable | ||
1728 | (with a sane default), so that the UDP plugin can tell how | ||
1729 | often to re-request STUN. | ||
1730 | */ | ||
1731 | struct StunExternalIP *se; | ||
1732 | |||
1733 | /* Check if we had a prior response from this STUN server */ | ||
1734 | for (se = se_head; NULL != se; se = se->next) | ||
1707 | { | 1735 | { |
1708 | /* We now know that a server at "sa" claims that | 1736 | if ((se->stun_server_addr_len != sa_len) || |
1709 | we are visible at IP "external_addr". | 1737 | (0 != memcmp (sa, |
1710 | 1738 | &se->stun_server_addr, | |
1711 | We should (for some fixed period of time) tell | 1739 | sa_len))) |
1712 | all of our clients that listen to a NAT'ed address | 1740 | continue; /* different STUN server */ |
1713 | that they might want to consider the given 'external_ip' | 1741 | if (0 != GNUNET_memcmp (&external_addr, |
1714 | as their public IP address (this includes TCP and UDP | 1742 | &se->external_addr)) |
1715 | clients, even if only UDP sends STUN requests). | 1743 | { |
1716 | 1744 | /* external IP changed, update! */ | |
1717 | If we do not get a renewal, the "external_addr" should be | 1745 | notify_clients_stun_change (&se->external_addr, |
1718 | removed again. The timeout frequency should be configurable | 1746 | GNUNET_NO); |
1719 | (with a sane default), so that the UDP plugin can tell how | 1747 | se->external_addr = external_addr; |
1720 | often to re-request STUN. | 1748 | notify_clients_stun_change (&se->external_addr, |
1721 | */ | 1749 | GNUNET_YES); |
1722 | struct StunExternalIP *se; | 1750 | } |
1723 | 1751 | /* update timeout */ | |
1724 | /* Check if we had a prior response from this STUN server */ | 1752 | GNUNET_SCHEDULER_cancel (se->timeout_task); |
1725 | for (se = se_head; NULL != se; se = se->next) | 1753 | se->timeout_task |
1726 | { | 1754 | = GNUNET_SCHEDULER_add_delayed (stun_stale_timeout, |
1727 | if ((se->stun_server_addr_len != sa_len) || | 1755 | &stun_ip_timeout, |
1728 | (0 != memcmp(sa, | 1756 | se); |
1729 | &se->stun_server_addr, | 1757 | return; |
1730 | sa_len))) | ||
1731 | continue; /* different STUN server */ | ||
1732 | if (0 != GNUNET_memcmp(&external_addr, | ||
1733 | &se->external_addr)) | ||
1734 | { | ||
1735 | /* external IP changed, update! */ | ||
1736 | notify_clients_stun_change(&se->external_addr, | ||
1737 | GNUNET_NO); | ||
1738 | se->external_addr = external_addr; | ||
1739 | notify_clients_stun_change(&se->external_addr, | ||
1740 | GNUNET_YES); | ||
1741 | } | ||
1742 | /* update timeout */ | ||
1743 | GNUNET_SCHEDULER_cancel(se->timeout_task); | ||
1744 | se->timeout_task | ||
1745 | = GNUNET_SCHEDULER_add_delayed(stun_stale_timeout, | ||
1746 | &stun_ip_timeout, | ||
1747 | se); | ||
1748 | return; | ||
1749 | } | ||
1750 | /* STUN server is completely new, create fresh entry */ | ||
1751 | se = GNUNET_new(struct StunExternalIP); | ||
1752 | se->external_addr = external_addr; | ||
1753 | GNUNET_memcpy(&se->stun_server_addr, | ||
1754 | sa, | ||
1755 | sa_len); | ||
1756 | se->stun_server_addr_len = sa_len; | ||
1757 | se->timeout_task = GNUNET_SCHEDULER_add_delayed(stun_stale_timeout, | ||
1758 | &stun_ip_timeout, | ||
1759 | se); | ||
1760 | GNUNET_CONTAINER_DLL_insert(se_head, | ||
1761 | se_tail, | ||
1762 | se); | ||
1763 | notify_clients_stun_change(&se->external_addr, | ||
1764 | GNUNET_NO); | ||
1765 | } | 1758 | } |
1766 | GNUNET_SERVICE_client_continue(ch->client); | 1759 | /* STUN server is completely new, create fresh entry */ |
1760 | se = GNUNET_new (struct StunExternalIP); | ||
1761 | se->external_addr = external_addr; | ||
1762 | GNUNET_memcpy (&se->stun_server_addr, | ||
1763 | sa, | ||
1764 | sa_len); | ||
1765 | se->stun_server_addr_len = sa_len; | ||
1766 | se->timeout_task = GNUNET_SCHEDULER_add_delayed (stun_stale_timeout, | ||
1767 | &stun_ip_timeout, | ||
1768 | se); | ||
1769 | GNUNET_CONTAINER_DLL_insert (se_head, | ||
1770 | se_tail, | ||
1771 | se); | ||
1772 | notify_clients_stun_change (&se->external_addr, | ||
1773 | GNUNET_NO); | ||
1774 | } | ||
1775 | GNUNET_SERVICE_client_continue (ch->client); | ||
1767 | } | 1776 | } |
1768 | 1777 | ||
1769 | 1778 | ||
@@ -1777,18 +1786,20 @@ handle_stun(void *cls, | |||
1777 | * @return #GNUNET_OK if message is well-formed | 1786 | * @return #GNUNET_OK if message is well-formed |
1778 | */ | 1787 | */ |
1779 | static int | 1788 | static int |
1780 | check_request_connection_reversal(void *cls, | 1789 | check_request_connection_reversal (void *cls, |
1781 | const struct GNUNET_NAT_RequestConnectionReversalMessage *message) | 1790 | const struct |
1791 | GNUNET_NAT_RequestConnectionReversalMessage * | ||
1792 | message) | ||
1782 | { | 1793 | { |
1783 | size_t expect; | 1794 | size_t expect; |
1784 | 1795 | ||
1785 | expect = ntohs(message->local_addr_size) | 1796 | expect = ntohs (message->local_addr_size) |
1786 | + ntohs(message->remote_addr_size); | 1797 | + ntohs (message->remote_addr_size); |
1787 | if (ntohs(message->header.size) - sizeof(*message) != expect) | 1798 | if (ntohs (message->header.size) - sizeof(*message) != expect) |
1788 | { | 1799 | { |
1789 | GNUNET_break(0); | 1800 | GNUNET_break (0); |
1790 | return GNUNET_SYSERR; | 1801 | return GNUNET_SYSERR; |
1791 | } | 1802 | } |
1792 | return GNUNET_OK; | 1803 | return GNUNET_OK; |
1793 | } | 1804 | } |
1794 | 1805 | ||
@@ -1801,48 +1812,50 @@ check_request_connection_reversal(void *cls, | |||
1801 | * @param message the message received | 1812 | * @param message the message received |
1802 | */ | 1813 | */ |
1803 | static void | 1814 | static void |
1804 | handle_request_connection_reversal(void *cls, | 1815 | handle_request_connection_reversal (void *cls, |
1805 | const struct GNUNET_NAT_RequestConnectionReversalMessage *message) | 1816 | const struct |
1817 | GNUNET_NAT_RequestConnectionReversalMessage | ||
1818 | *message) | ||
1806 | { | 1819 | { |
1807 | struct ClientHandle *ch = cls; | 1820 | struct ClientHandle *ch = cls; |
1808 | const char *buf = (const char *)&message[1]; | 1821 | const char *buf = (const char *) &message[1]; |
1809 | size_t local_sa_len = ntohs(message->local_addr_size); | 1822 | size_t local_sa_len = ntohs (message->local_addr_size); |
1810 | size_t remote_sa_len = ntohs(message->remote_addr_size); | 1823 | size_t remote_sa_len = ntohs (message->remote_addr_size); |
1811 | struct sockaddr_in l4; | 1824 | struct sockaddr_in l4; |
1812 | struct sockaddr_in r4; | 1825 | struct sockaddr_in r4; |
1813 | int ret; | 1826 | int ret; |
1814 | 1827 | ||
1815 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1828 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1816 | "Received REQUEST CONNECTION REVERSAL message from client\n"); | 1829 | "Received REQUEST CONNECTION REVERSAL message from client\n"); |
1817 | if (local_sa_len != sizeof(struct sockaddr_in)) | 1830 | if (local_sa_len != sizeof(struct sockaddr_in)) |
1818 | { | 1831 | { |
1819 | GNUNET_break_op(0); | 1832 | GNUNET_break_op (0); |
1820 | GNUNET_SERVICE_client_drop(ch->client); | 1833 | GNUNET_SERVICE_client_drop (ch->client); |
1821 | return; | 1834 | return; |
1822 | } | 1835 | } |
1823 | if (remote_sa_len != sizeof(struct sockaddr_in)) | 1836 | if (remote_sa_len != sizeof(struct sockaddr_in)) |
1824 | { | 1837 | { |
1825 | GNUNET_break_op(0); | 1838 | GNUNET_break_op (0); |
1826 | GNUNET_SERVICE_client_drop(ch->client); | 1839 | GNUNET_SERVICE_client_drop (ch->client); |
1827 | return; | 1840 | return; |
1828 | } | 1841 | } |
1829 | GNUNET_memcpy(&l4, | 1842 | GNUNET_memcpy (&l4, |
1830 | buf, | 1843 | buf, |
1831 | sizeof(struct sockaddr_in)); | 1844 | sizeof(struct sockaddr_in)); |
1832 | GNUNET_break_op(AF_INET == l4.sin_family); | 1845 | GNUNET_break_op (AF_INET == l4.sin_family); |
1833 | buf += sizeof(struct sockaddr_in); | 1846 | buf += sizeof(struct sockaddr_in); |
1834 | GNUNET_memcpy(&r4, | 1847 | GNUNET_memcpy (&r4, |
1835 | buf, | 1848 | buf, |
1836 | sizeof(struct sockaddr_in)); | 1849 | sizeof(struct sockaddr_in)); |
1837 | GNUNET_break_op(AF_INET == r4.sin_family); | 1850 | GNUNET_break_op (AF_INET == r4.sin_family); |
1838 | ret = GN_request_connection_reversal(&l4.sin_addr, | 1851 | ret = GN_request_connection_reversal (&l4.sin_addr, |
1839 | ntohs(l4.sin_port), | 1852 | ntohs (l4.sin_port), |
1840 | &r4.sin_addr, | 1853 | &r4.sin_addr, |
1841 | cfg); | 1854 | cfg); |
1842 | if (GNUNET_OK != ret) | 1855 | if (GNUNET_OK != ret) |
1843 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 1856 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1844 | _("Connection reversal request failed\n")); | 1857 | _ ("Connection reversal request failed\n")); |
1845 | GNUNET_SERVICE_client_continue(ch->client); | 1858 | GNUNET_SERVICE_client_continue (ch->client); |
1846 | } | 1859 | } |
1847 | 1860 | ||
1848 | 1861 | ||
@@ -1852,31 +1865,31 @@ handle_request_connection_reversal(void *cls, | |||
1852 | * @param cls unused | 1865 | * @param cls unused |
1853 | */ | 1866 | */ |
1854 | static void | 1867 | static void |
1855 | shutdown_task(void *cls) | 1868 | shutdown_task (void *cls) |
1856 | { | 1869 | { |
1857 | struct StunExternalIP *se; | 1870 | struct StunExternalIP *se; |
1858 | 1871 | ||
1859 | while (NULL != (se = se_head)) | 1872 | while (NULL != (se = se_head)) |
1860 | { | 1873 | { |
1861 | GNUNET_CONTAINER_DLL_remove(se_head, | 1874 | GNUNET_CONTAINER_DLL_remove (se_head, |
1862 | se_tail, | 1875 | se_tail, |
1863 | se); | 1876 | se); |
1864 | GNUNET_SCHEDULER_cancel(se->timeout_task); | 1877 | GNUNET_SCHEDULER_cancel (se->timeout_task); |
1865 | GNUNET_free(se); | 1878 | GNUNET_free (se); |
1866 | } | 1879 | } |
1867 | GN_nat_status_changed(GNUNET_NO); | 1880 | GN_nat_status_changed (GNUNET_NO); |
1868 | if (NULL != scan_task) | 1881 | if (NULL != scan_task) |
1869 | { | 1882 | { |
1870 | GNUNET_SCHEDULER_cancel(scan_task); | 1883 | GNUNET_SCHEDULER_cancel (scan_task); |
1871 | scan_task = NULL; | 1884 | scan_task = NULL; |
1872 | } | 1885 | } |
1873 | if (NULL != stats) | 1886 | if (NULL != stats) |
1874 | { | 1887 | { |
1875 | GNUNET_STATISTICS_destroy(stats, | 1888 | GNUNET_STATISTICS_destroy (stats, |
1876 | GNUNET_NO); | 1889 | GNUNET_NO); |
1877 | stats = NULL; | 1890 | stats = NULL; |
1878 | } | 1891 | } |
1879 | destroy_lal(); | 1892 | destroy_lal (); |
1880 | } | 1893 | } |
1881 | 1894 | ||
1882 | 1895 | ||
@@ -1888,49 +1901,50 @@ shutdown_task(void *cls) | |||
1888 | * @param service the initialized service | 1901 | * @param service the initialized service |
1889 | */ | 1902 | */ |
1890 | static void | 1903 | static void |
1891 | run(void *cls, | 1904 | run (void *cls, |
1892 | const struct GNUNET_CONFIGURATION_Handle *c, | 1905 | const struct GNUNET_CONFIGURATION_Handle *c, |
1893 | struct GNUNET_SERVICE_Handle *service) | 1906 | struct GNUNET_SERVICE_Handle *service) |
1894 | { | 1907 | { |
1895 | cfg = c; | 1908 | cfg = c; |
1896 | if (GNUNET_OK != | 1909 | if (GNUNET_OK != |
1897 | GNUNET_CONFIGURATION_get_value_time(cfg, | 1910 | GNUNET_CONFIGURATION_get_value_time (cfg, |
1898 | "NAT", | 1911 | "NAT", |
1899 | "STUN_STALE", | 1912 | "STUN_STALE", |
1900 | &stun_stale_timeout)) | 1913 | &stun_stale_timeout)) |
1901 | stun_stale_timeout = GNUNET_TIME_UNIT_HOURS; | 1914 | stun_stale_timeout = GNUNET_TIME_UNIT_HOURS; |
1902 | 1915 | ||
1903 | /* Check for UPnP */ | 1916 | /* Check for UPnP */ |
1904 | enable_upnp | 1917 | enable_upnp |
1905 | = GNUNET_CONFIGURATION_get_value_yesno(cfg, | 1918 | = GNUNET_CONFIGURATION_get_value_yesno (cfg, |
1906 | "NAT", | 1919 | "NAT", |
1907 | "ENABLE_UPNP"); | 1920 | "ENABLE_UPNP"); |
1908 | if (GNUNET_YES == enable_upnp) | 1921 | if (GNUNET_YES == enable_upnp) |
1922 | { | ||
1923 | /* check if it works */ | ||
1924 | if (GNUNET_SYSERR == | ||
1925 | GNUNET_OS_check_helper_binary ("upnpc", | ||
1926 | GNUNET_NO, | ||
1927 | NULL)) | ||
1909 | { | 1928 | { |
1910 | /* check if it works */ | 1929 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1911 | if (GNUNET_SYSERR == | 1930 | _ ( |
1912 | GNUNET_OS_check_helper_binary("upnpc", | 1931 | "UPnP enabled in configuration, but UPnP client `upnpc` command not found, disabling UPnP\n")); |
1913 | GNUNET_NO, | 1932 | enable_upnp = GNUNET_SYSERR; |
1914 | NULL)) | ||
1915 | { | ||
1916 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
1917 | _("UPnP enabled in configuration, but UPnP client `upnpc` command not found, disabling UPnP\n")); | ||
1918 | enable_upnp = GNUNET_SYSERR; | ||
1919 | } | ||
1920 | } | 1933 | } |
1934 | } | ||
1921 | if (GNUNET_OK != | 1935 | if (GNUNET_OK != |
1922 | GNUNET_CONFIGURATION_get_value_time(cfg, | 1936 | GNUNET_CONFIGURATION_get_value_time (cfg, |
1923 | "nat", | 1937 | "nat", |
1924 | "DYNDNS_FREQUENCY", | 1938 | "DYNDNS_FREQUENCY", |
1925 | &dyndns_frequency)) | 1939 | &dyndns_frequency)) |
1926 | dyndns_frequency = DYNDNS_FREQUENCY; | 1940 | dyndns_frequency = DYNDNS_FREQUENCY; |
1927 | 1941 | ||
1928 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, | 1942 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, |
1929 | NULL); | 1943 | NULL); |
1930 | stats = GNUNET_STATISTICS_create("nat", | 1944 | stats = GNUNET_STATISTICS_create ("nat", |
1931 | cfg); | 1945 | cfg); |
1932 | scan_task = GNUNET_SCHEDULER_add_now(&run_scan, | 1946 | scan_task = GNUNET_SCHEDULER_add_now (&run_scan, |
1933 | NULL); | 1947 | NULL); |
1934 | } | 1948 | } |
1935 | 1949 | ||
1936 | 1950 | ||
@@ -1943,18 +1957,18 @@ run(void *cls, | |||
1943 | * @return a `struct ClientHandle` | 1957 | * @return a `struct ClientHandle` |
1944 | */ | 1958 | */ |
1945 | static void * | 1959 | static void * |
1946 | client_connect_cb(void *cls, | 1960 | client_connect_cb (void *cls, |
1947 | struct GNUNET_SERVICE_Client *c, | 1961 | struct GNUNET_SERVICE_Client *c, |
1948 | struct GNUNET_MQ_Handle *mq) | 1962 | struct GNUNET_MQ_Handle *mq) |
1949 | { | 1963 | { |
1950 | struct ClientHandle *ch; | 1964 | struct ClientHandle *ch; |
1951 | 1965 | ||
1952 | ch = GNUNET_new(struct ClientHandle); | 1966 | ch = GNUNET_new (struct ClientHandle); |
1953 | ch->mq = mq; | 1967 | ch->mq = mq; |
1954 | ch->client = c; | 1968 | ch->client = c; |
1955 | GNUNET_CONTAINER_DLL_insert(ch_head, | 1969 | GNUNET_CONTAINER_DLL_insert (ch_head, |
1956 | ch_tail, | 1970 | ch_tail, |
1957 | ch); | 1971 | ch); |
1958 | return ch; | 1972 | return ch; |
1959 | } | 1973 | } |
1960 | 1974 | ||
@@ -1967,50 +1981,50 @@ client_connect_cb(void *cls, | |||
1967 | * @param internal_cls a `struct ClientHandle *` | 1981 | * @param internal_cls a `struct ClientHandle *` |
1968 | */ | 1982 | */ |
1969 | static void | 1983 | static void |
1970 | client_disconnect_cb(void *cls, | 1984 | client_disconnect_cb (void *cls, |
1971 | struct GNUNET_SERVICE_Client *c, | 1985 | struct GNUNET_SERVICE_Client *c, |
1972 | void *internal_cls) | 1986 | void *internal_cls) |
1973 | { | 1987 | { |
1974 | struct ClientHandle *ch = internal_cls; | 1988 | struct ClientHandle *ch = internal_cls; |
1975 | struct LocalAddressList *lal; | 1989 | struct LocalAddressList *lal; |
1976 | 1990 | ||
1977 | GNUNET_CONTAINER_DLL_remove(ch_head, | 1991 | GNUNET_CONTAINER_DLL_remove (ch_head, |
1978 | ch_tail, | 1992 | ch_tail, |
1979 | ch); | 1993 | ch); |
1980 | for (unsigned int i = 0; i < ch->num_caddrs; i++) | 1994 | for (unsigned int i = 0; i < ch->num_caddrs; i++) |
1995 | { | ||
1996 | if (NULL != ch->caddrs[i].mh) | ||
1981 | { | 1997 | { |
1982 | if (NULL != ch->caddrs[i].mh) | 1998 | GNUNET_NAT_mini_map_stop (ch->caddrs[i].mh); |
1983 | { | 1999 | ch->caddrs[i].mh = NULL; |
1984 | GNUNET_NAT_mini_map_stop(ch->caddrs[i].mh); | ||
1985 | ch->caddrs[i].mh = NULL; | ||
1986 | } | ||
1987 | } | 2000 | } |
1988 | GNUNET_free_non_null(ch->caddrs); | 2001 | } |
2002 | GNUNET_free_non_null (ch->caddrs); | ||
1989 | while (NULL != (lal = ch->ext_addr_head)) | 2003 | while (NULL != (lal = ch->ext_addr_head)) |
1990 | { | 2004 | { |
1991 | GNUNET_CONTAINER_DLL_remove(ch->ext_addr_head, | 2005 | GNUNET_CONTAINER_DLL_remove (ch->ext_addr_head, |
1992 | ch->ext_addr_tail, | 2006 | ch->ext_addr_tail, |
1993 | lal); | 2007 | lal); |
1994 | GNUNET_free(lal); | 2008 | GNUNET_free (lal); |
1995 | } | 2009 | } |
1996 | if (NULL != ch->ext_dns_task) | 2010 | if (NULL != ch->ext_dns_task) |
1997 | { | 2011 | { |
1998 | GNUNET_SCHEDULER_cancel(ch->ext_dns_task); | 2012 | GNUNET_SCHEDULER_cancel (ch->ext_dns_task); |
1999 | ch->ext_dns_task = NULL; | 2013 | ch->ext_dns_task = NULL; |
2000 | } | 2014 | } |
2001 | if (NULL != ch->external_monitor) | 2015 | if (NULL != ch->external_monitor) |
2002 | { | 2016 | { |
2003 | GN_external_ipv4_monitor_stop(ch->external_monitor); | 2017 | GN_external_ipv4_monitor_stop (ch->external_monitor); |
2004 | ch->external_monitor = NULL; | 2018 | ch->external_monitor = NULL; |
2005 | } | 2019 | } |
2006 | if (NULL != ch->ext_dns) | 2020 | if (NULL != ch->ext_dns) |
2007 | { | 2021 | { |
2008 | GNUNET_RESOLVER_request_cancel(ch->ext_dns); | 2022 | GNUNET_RESOLVER_request_cancel (ch->ext_dns); |
2009 | ch->ext_dns = NULL; | 2023 | ch->ext_dns = NULL; |
2010 | } | 2024 | } |
2011 | GNUNET_free_non_null(ch->hole_external); | 2025 | GNUNET_free_non_null (ch->hole_external); |
2012 | GNUNET_free_non_null(ch->section_name); | 2026 | GNUNET_free_non_null (ch->section_name); |
2013 | GNUNET_free(ch); | 2027 | GNUNET_free (ch); |
2014 | } | 2028 | } |
2015 | 2029 | ||
2016 | 2030 | ||
@@ -2024,19 +2038,19 @@ GNUNET_SERVICE_MAIN | |||
2024 | &client_connect_cb, | 2038 | &client_connect_cb, |
2025 | &client_disconnect_cb, | 2039 | &client_disconnect_cb, |
2026 | NULL, | 2040 | NULL, |
2027 | GNUNET_MQ_hd_var_size(register, | 2041 | GNUNET_MQ_hd_var_size (register, |
2028 | GNUNET_MESSAGE_TYPE_NAT_REGISTER, | 2042 | GNUNET_MESSAGE_TYPE_NAT_REGISTER, |
2029 | struct GNUNET_NAT_RegisterMessage, | 2043 | struct GNUNET_NAT_RegisterMessage, |
2030 | NULL), | 2044 | NULL), |
2031 | GNUNET_MQ_hd_var_size(stun, | 2045 | GNUNET_MQ_hd_var_size (stun, |
2032 | GNUNET_MESSAGE_TYPE_NAT_HANDLE_STUN, | 2046 | GNUNET_MESSAGE_TYPE_NAT_HANDLE_STUN, |
2033 | struct GNUNET_NAT_HandleStunMessage, | 2047 | struct GNUNET_NAT_HandleStunMessage, |
2034 | NULL), | 2048 | NULL), |
2035 | GNUNET_MQ_hd_var_size(request_connection_reversal, | 2049 | GNUNET_MQ_hd_var_size (request_connection_reversal, |
2036 | GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL, | 2050 | GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL, |
2037 | struct GNUNET_NAT_RequestConnectionReversalMessage, | 2051 | struct GNUNET_NAT_RequestConnectionReversalMessage, |
2038 | NULL), | 2052 | NULL), |
2039 | GNUNET_MQ_handler_end()); | 2053 | GNUNET_MQ_handler_end ()); |
2040 | 2054 | ||
2041 | 2055 | ||
2042 | #if defined(LINUX) && defined(__GLIBC__) | 2056 | #if defined(LINUX) && defined(__GLIBC__) |
@@ -2046,11 +2060,11 @@ GNUNET_SERVICE_MAIN | |||
2046 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. | 2060 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. |
2047 | */ | 2061 | */ |
2048 | void __attribute__ ((constructor)) | 2062 | void __attribute__ ((constructor)) |
2049 | GNUNET_ARM_memory_init() | 2063 | GNUNET_ARM_memory_init () |
2050 | { | 2064 | { |
2051 | mallopt(M_TRIM_THRESHOLD, 4 * 1024); | 2065 | mallopt (M_TRIM_THRESHOLD, 4 * 1024); |
2052 | mallopt(M_TOP_PAD, 1 * 1024); | 2066 | mallopt (M_TOP_PAD, 1 * 1024); |
2053 | malloc_trim(0); | 2067 | malloc_trim (0); |
2054 | } | 2068 | } |
2055 | #endif | 2069 | #endif |
2056 | 2070 | ||
diff --git a/src/nat/gnunet-service-nat_externalip.c b/src/nat/gnunet-service-nat_externalip.c index c97f7f58b..0a251bdb2 100644 --- a/src/nat/gnunet-service-nat_externalip.c +++ b/src/nat/gnunet-service-nat_externalip.c | |||
@@ -54,25 +54,29 @@ | |||
54 | * How long do we wait until we re-try running `external-ip` if the | 54 | * How long do we wait until we re-try running `external-ip` if the |
55 | * command failed to terminate nicely? | 55 | * command failed to terminate nicely? |
56 | */ | 56 | */ |
57 | #define EXTERN_IP_RETRY_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15) | 57 | #define EXTERN_IP_RETRY_TIMEOUT GNUNET_TIME_relative_multiply ( \ |
58 | GNUNET_TIME_UNIT_MINUTES, 15) | ||
58 | 59 | ||
59 | /** | 60 | /** |
60 | * How long do we wait until we re-try running `external-ip` if the | 61 | * How long do we wait until we re-try running `external-ip` if the |
61 | * command failed (but terminated)? | 62 | * command failed (but terminated)? |
62 | */ | 63 | */ |
63 | #define EXTERN_IP_RETRY_FAILURE GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30) | 64 | #define EXTERN_IP_RETRY_FAILURE GNUNET_TIME_relative_multiply ( \ |
65 | GNUNET_TIME_UNIT_MINUTES, 30) | ||
64 | 66 | ||
65 | /** | 67 | /** |
66 | * How long do we wait until we re-try running `external-ip` if the | 68 | * How long do we wait until we re-try running `external-ip` if the |
67 | * command succeeded? | 69 | * command succeeded? |
68 | */ | 70 | */ |
69 | #define EXTERN_IP_RETRY_SUCCESS GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5) | 71 | #define EXTERN_IP_RETRY_SUCCESS GNUNET_TIME_relative_multiply ( \ |
72 | GNUNET_TIME_UNIT_MINUTES, 5) | ||
70 | 73 | ||
71 | 74 | ||
72 | /** | 75 | /** |
73 | * Handle to monitor for external IP changes. | 76 | * Handle to monitor for external IP changes. |
74 | */ | 77 | */ |
75 | struct GN_ExternalIPMonitor { | 78 | struct GN_ExternalIPMonitor |
79 | { | ||
76 | /** | 80 | /** |
77 | * Kept in DLL. | 81 | * Kept in DLL. |
78 | */ | 82 | */ |
@@ -131,15 +135,15 @@ static struct in_addr mini_external_ipv4; | |||
131 | * @param v4 the external address that changed | 135 | * @param v4 the external address that changed |
132 | */ | 136 | */ |
133 | static void | 137 | static void |
134 | notify_monitors_external_ipv4_change(int add, | 138 | notify_monitors_external_ipv4_change (int add, |
135 | const struct in_addr *v4) | 139 | const struct in_addr *v4) |
136 | { | 140 | { |
137 | for (struct GN_ExternalIPMonitor *mon = mon_head; | 141 | for (struct GN_ExternalIPMonitor *mon = mon_head; |
138 | NULL != mon; | 142 | NULL != mon; |
139 | mon = mon->next) | 143 | mon = mon->next) |
140 | mon->cb(mon->cb_cls, | 144 | mon->cb (mon->cb_cls, |
141 | v4, | 145 | v4, |
142 | add); | 146 | add); |
143 | } | 147 | } |
144 | 148 | ||
145 | 149 | ||
@@ -150,7 +154,7 @@ notify_monitors_external_ipv4_change(int add, | |||
150 | * @param cls NULL | 154 | * @param cls NULL |
151 | */ | 155 | */ |
152 | static void | 156 | static void |
153 | run_external_ip(void *cls); | 157 | run_external_ip (void *cls); |
154 | 158 | ||
155 | 159 | ||
156 | /** | 160 | /** |
@@ -163,47 +167,47 @@ run_external_ip(void *cls); | |||
163 | * @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code | 167 | * @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code |
164 | */ | 168 | */ |
165 | static void | 169 | static void |
166 | handle_external_ip(void *cls, | 170 | handle_external_ip (void *cls, |
167 | const struct in_addr *addr, | 171 | const struct in_addr *addr, |
168 | enum GNUNET_NAT_StatusCode result) | 172 | enum GNUNET_NAT_StatusCode result) |
169 | { | 173 | { |
170 | char buf[INET_ADDRSTRLEN]; | 174 | char buf[INET_ADDRSTRLEN]; |
171 | 175 | ||
172 | probe_external_ip_op = NULL; | 176 | probe_external_ip_op = NULL; |
173 | GNUNET_SCHEDULER_cancel(probe_external_ip_task); | 177 | GNUNET_SCHEDULER_cancel (probe_external_ip_task); |
174 | probe_external_ip_task | 178 | probe_external_ip_task |
175 | = GNUNET_SCHEDULER_add_delayed((NULL == addr) | 179 | = GNUNET_SCHEDULER_add_delayed ((NULL == addr) |
176 | ? EXTERN_IP_RETRY_FAILURE | 180 | ? EXTERN_IP_RETRY_FAILURE |
177 | : EXTERN_IP_RETRY_SUCCESS, | 181 | : EXTERN_IP_RETRY_SUCCESS, |
178 | &run_external_ip, | 182 | &run_external_ip, |
179 | NULL); | 183 | NULL); |
180 | switch (result) | 184 | switch (result) |
181 | { | 185 | { |
182 | case GNUNET_NAT_ERROR_SUCCESS: | 186 | case GNUNET_NAT_ERROR_SUCCESS: |
183 | GNUNET_assert(NULL != addr); | 187 | GNUNET_assert (NULL != addr); |
184 | if (addr->s_addr == mini_external_ipv4.s_addr) | 188 | if (addr->s_addr == mini_external_ipv4.s_addr) |
185 | return; /* not change */ | 189 | return; /* not change */ |
186 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 190 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
187 | "Our external IP is now %s\n", | 191 | "Our external IP is now %s\n", |
188 | inet_ntop(AF_INET, | 192 | inet_ntop (AF_INET, |
189 | addr, | 193 | addr, |
190 | buf, | 194 | buf, |
191 | sizeof(buf))); | 195 | sizeof(buf))); |
192 | if (0 != mini_external_ipv4.s_addr) | 196 | if (0 != mini_external_ipv4.s_addr) |
193 | notify_monitors_external_ipv4_change(GNUNET_NO, | 197 | notify_monitors_external_ipv4_change (GNUNET_NO, |
194 | &mini_external_ipv4); | 198 | &mini_external_ipv4); |
195 | mini_external_ipv4 = *addr; | 199 | mini_external_ipv4 = *addr; |
196 | notify_monitors_external_ipv4_change(GNUNET_YES, | 200 | notify_monitors_external_ipv4_change (GNUNET_YES, |
197 | &mini_external_ipv4); | 201 | &mini_external_ipv4); |
198 | break; | 202 | break; |
199 | 203 | ||
200 | default: | 204 | default: |
201 | if (0 != mini_external_ipv4.s_addr) | 205 | if (0 != mini_external_ipv4.s_addr) |
202 | notify_monitors_external_ipv4_change(GNUNET_NO, | 206 | notify_monitors_external_ipv4_change (GNUNET_NO, |
203 | &mini_external_ipv4); | 207 | &mini_external_ipv4); |
204 | mini_external_ipv4.s_addr = 0; | 208 | mini_external_ipv4.s_addr = 0; |
205 | break; | 209 | break; |
206 | } | 210 | } |
207 | } | 211 | } |
208 | 212 | ||
209 | 213 | ||
@@ -214,20 +218,20 @@ handle_external_ip(void *cls, | |||
214 | * @param cls NULL | 218 | * @param cls NULL |
215 | */ | 219 | */ |
216 | static void | 220 | static void |
217 | run_external_ip(void *cls) | 221 | run_external_ip (void *cls) |
218 | { | 222 | { |
219 | probe_external_ip_task | 223 | probe_external_ip_task |
220 | = GNUNET_SCHEDULER_add_delayed(EXTERN_IP_RETRY_TIMEOUT, | 224 | = GNUNET_SCHEDULER_add_delayed (EXTERN_IP_RETRY_TIMEOUT, |
221 | &run_external_ip, | 225 | &run_external_ip, |
222 | NULL); | 226 | NULL); |
223 | if (NULL != probe_external_ip_op) | 227 | if (NULL != probe_external_ip_op) |
224 | { | 228 | { |
225 | GNUNET_NAT_mini_get_external_ipv4_cancel_(probe_external_ip_op); | 229 | GNUNET_NAT_mini_get_external_ipv4_cancel_ (probe_external_ip_op); |
226 | probe_external_ip_op = NULL; | 230 | probe_external_ip_op = NULL; |
227 | } | 231 | } |
228 | probe_external_ip_op | 232 | probe_external_ip_op |
229 | = GNUNET_NAT_mini_get_external_ipv4_(&handle_external_ip, | 233 | = GNUNET_NAT_mini_get_external_ipv4_ (&handle_external_ip, |
230 | NULL); | 234 | NULL); |
231 | } | 235 | } |
232 | 236 | ||
233 | 237 | ||
@@ -238,32 +242,32 @@ run_external_ip(void *cls) | |||
238 | * @param have_nat #GNUNET_YES if we believe we are behind NAT | 242 | * @param have_nat #GNUNET_YES if we believe we are behind NAT |
239 | */ | 243 | */ |
240 | void | 244 | void |
241 | GN_nat_status_changed(int have_nat) | 245 | GN_nat_status_changed (int have_nat) |
242 | { | 246 | { |
243 | if (GNUNET_YES != enable_upnp) | 247 | if (GNUNET_YES != enable_upnp) |
244 | return; | 248 | return; |
245 | if ((GNUNET_YES == have_nat) && | 249 | if ((GNUNET_YES == have_nat) && |
246 | (NULL == probe_external_ip_task) && | 250 | (NULL == probe_external_ip_task) && |
247 | (NULL == probe_external_ip_op)) | 251 | (NULL == probe_external_ip_op)) |
252 | { | ||
253 | probe_external_ip_task | ||
254 | = GNUNET_SCHEDULER_add_now (&run_external_ip, | ||
255 | NULL); | ||
256 | return; | ||
257 | } | ||
258 | if (GNUNET_NO == have_nat) | ||
259 | { | ||
260 | if (NULL != probe_external_ip_task) | ||
248 | { | 261 | { |
249 | probe_external_ip_task | 262 | GNUNET_SCHEDULER_cancel (probe_external_ip_task); |
250 | = GNUNET_SCHEDULER_add_now(&run_external_ip, | 263 | probe_external_ip_task = NULL; |
251 | NULL); | ||
252 | return; | ||
253 | } | 264 | } |
254 | if (GNUNET_NO == have_nat) | 265 | if (NULL != probe_external_ip_op) |
255 | { | 266 | { |
256 | if (NULL != probe_external_ip_task) | 267 | GNUNET_NAT_mini_get_external_ipv4_cancel_ (probe_external_ip_op); |
257 | { | 268 | probe_external_ip_op = NULL; |
258 | GNUNET_SCHEDULER_cancel(probe_external_ip_task); | ||
259 | probe_external_ip_task = NULL; | ||
260 | } | ||
261 | if (NULL != probe_external_ip_op) | ||
262 | { | ||
263 | GNUNET_NAT_mini_get_external_ipv4_cancel_(probe_external_ip_op); | ||
264 | probe_external_ip_op = NULL; | ||
265 | } | ||
266 | } | 269 | } |
270 | } | ||
267 | } | 271 | } |
268 | 272 | ||
269 | 273 | ||
@@ -275,21 +279,21 @@ GN_nat_status_changed(int have_nat) | |||
275 | * @return handle to cancel | 279 | * @return handle to cancel |
276 | */ | 280 | */ |
277 | struct GN_ExternalIPMonitor * | 281 | struct GN_ExternalIPMonitor * |
278 | GN_external_ipv4_monitor_start(GN_NotifyExternalIPv4Change cb, | 282 | GN_external_ipv4_monitor_start (GN_NotifyExternalIPv4Change cb, |
279 | void *cb_cls) | 283 | void *cb_cls) |
280 | { | 284 | { |
281 | struct GN_ExternalIPMonitor *mon; | 285 | struct GN_ExternalIPMonitor *mon; |
282 | 286 | ||
283 | mon = GNUNET_new(struct GN_ExternalIPMonitor); | 287 | mon = GNUNET_new (struct GN_ExternalIPMonitor); |
284 | mon->cb = cb; | 288 | mon->cb = cb; |
285 | mon->cb_cls = cb_cls; | 289 | mon->cb_cls = cb_cls; |
286 | GNUNET_CONTAINER_DLL_insert(mon_head, | 290 | GNUNET_CONTAINER_DLL_insert (mon_head, |
287 | mon_tail, | 291 | mon_tail, |
288 | mon); | 292 | mon); |
289 | if (0 != mini_external_ipv4.s_addr) | 293 | if (0 != mini_external_ipv4.s_addr) |
290 | cb(cb_cls, | 294 | cb (cb_cls, |
291 | &mini_external_ipv4, | 295 | &mini_external_ipv4, |
292 | GNUNET_YES); | 296 | GNUNET_YES); |
293 | return mon; | 297 | return mon; |
294 | } | 298 | } |
295 | 299 | ||
@@ -300,12 +304,12 @@ GN_external_ipv4_monitor_start(GN_NotifyExternalIPv4Change cb, | |||
300 | * @param mon monitor to call | 304 | * @param mon monitor to call |
301 | */ | 305 | */ |
302 | void | 306 | void |
303 | GN_external_ipv4_monitor_stop(struct GN_ExternalIPMonitor *mon) | 307 | GN_external_ipv4_monitor_stop (struct GN_ExternalIPMonitor *mon) |
304 | { | 308 | { |
305 | GNUNET_CONTAINER_DLL_remove(mon_head, | 309 | GNUNET_CONTAINER_DLL_remove (mon_head, |
306 | mon_tail, | 310 | mon_tail, |
307 | mon); | 311 | mon); |
308 | GNUNET_free(mon); | 312 | GNUNET_free (mon); |
309 | } | 313 | } |
310 | 314 | ||
311 | /* end of gnunet-service-nat_externalip.c */ | 315 | /* end of gnunet-service-nat_externalip.c */ |
diff --git a/src/nat/gnunet-service-nat_externalip.h b/src/nat/gnunet-service-nat_externalip.h index 41ab49e2f..6b3467fab 100644 --- a/src/nat/gnunet-service-nat_externalip.h +++ b/src/nat/gnunet-service-nat_externalip.h | |||
@@ -46,7 +46,7 @@ | |||
46 | * @param have_nat #GNUNET_YES if we believe we are behind NAT | 46 | * @param have_nat #GNUNET_YES if we believe we are behind NAT |
47 | */ | 47 | */ |
48 | void | 48 | void |
49 | GN_nat_status_changed(int have_nat); | 49 | GN_nat_status_changed (int have_nat); |
50 | 50 | ||
51 | 51 | ||
52 | /** | 52 | /** |
@@ -76,8 +76,8 @@ struct GN_ExternalIPMonitor; | |||
76 | * @return handle to cancel | 76 | * @return handle to cancel |
77 | */ | 77 | */ |
78 | struct GN_ExternalIPMonitor * | 78 | struct GN_ExternalIPMonitor * |
79 | GN_external_ipv4_monitor_start(GN_NotifyExternalIPv4Change cb, | 79 | GN_external_ipv4_monitor_start (GN_NotifyExternalIPv4Change cb, |
80 | void *cb_cls); | 80 | void *cb_cls); |
81 | 81 | ||
82 | 82 | ||
83 | /** | 83 | /** |
@@ -86,7 +86,7 @@ GN_external_ipv4_monitor_start(GN_NotifyExternalIPv4Change cb, | |||
86 | * @param mon monitor to call | 86 | * @param mon monitor to call |
87 | */ | 87 | */ |
88 | void | 88 | void |
89 | GN_external_ipv4_monitor_stop(struct GN_ExternalIPMonitor *mon); | 89 | GN_external_ipv4_monitor_stop (struct GN_ExternalIPMonitor *mon); |
90 | 90 | ||
91 | 91 | ||
92 | #endif | 92 | #endif |
diff --git a/src/nat/gnunet-service-nat_helper.c b/src/nat/gnunet-service-nat_helper.c index 42612751d..58d7b4c61 100644 --- a/src/nat/gnunet-service-nat_helper.c +++ b/src/nat/gnunet-service-nat_helper.c | |||
@@ -32,7 +32,8 @@ | |||
32 | /** | 32 | /** |
33 | * Information we keep per NAT helper process. | 33 | * Information we keep per NAT helper process. |
34 | */ | 34 | */ |
35 | struct HelperContext { | 35 | struct HelperContext |
36 | { | ||
36 | /** | 37 | /** |
37 | * IP address we pass to the NAT helper. | 38 | * IP address we pass to the NAT helper. |
38 | */ | 39 | */ |
@@ -87,7 +88,7 @@ struct HelperContext { | |||
87 | * @param cls a `struct HelperContext` | 88 | * @param cls a `struct HelperContext` |
88 | */ | 89 | */ |
89 | static void | 90 | static void |
90 | restart_nat_server(void *cls); | 91 | restart_nat_server (void *cls); |
91 | 92 | ||
92 | 93 | ||
93 | /** | 94 | /** |
@@ -96,13 +97,13 @@ restart_nat_server(void *cls); | |||
96 | * @param h context of the helper | 97 | * @param h context of the helper |
97 | */ | 98 | */ |
98 | static void | 99 | static void |
99 | try_again(struct HelperContext *h) | 100 | try_again (struct HelperContext *h) |
100 | { | 101 | { |
101 | GNUNET_assert(NULL == h->server_read_task); | 102 | GNUNET_assert (NULL == h->server_read_task); |
102 | h->server_retry_delay = GNUNET_TIME_STD_BACKOFF(h->server_retry_delay); | 103 | h->server_retry_delay = GNUNET_TIME_STD_BACKOFF (h->server_retry_delay); |
103 | h->server_read_task = GNUNET_SCHEDULER_add_delayed(h->server_retry_delay, | 104 | h->server_read_task = GNUNET_SCHEDULER_add_delayed (h->server_retry_delay, |
104 | &restart_nat_server, | 105 | &restart_nat_server, |
105 | h); | 106 | h); |
106 | } | 107 | } |
107 | 108 | ||
108 | 109 | ||
@@ -114,7 +115,7 @@ try_again(struct HelperContext *h) | |||
114 | * @param cls the `struct HelperContext` | 115 | * @param cls the `struct HelperContext` |
115 | */ | 116 | */ |
116 | static void | 117 | static void |
117 | nat_server_read(void *cls) | 118 | nat_server_read (void *cls) |
118 | { | 119 | { |
119 | struct HelperContext *h = cls; | 120 | struct HelperContext *h = cls; |
120 | char mybuf[40]; | 121 | char mybuf[40]; |
@@ -124,73 +125,73 @@ nat_server_read(void *cls) | |||
124 | struct sockaddr_in sin_addr; | 125 | struct sockaddr_in sin_addr; |
125 | 126 | ||
126 | h->server_read_task = NULL; | 127 | h->server_read_task = NULL; |
127 | memset(mybuf, 0, sizeof(mybuf)); | 128 | memset (mybuf, 0, sizeof(mybuf)); |
128 | bytes = | 129 | bytes = |
129 | GNUNET_DISK_file_read(h->server_stdout_handle, mybuf, sizeof(mybuf)); | 130 | GNUNET_DISK_file_read (h->server_stdout_handle, mybuf, sizeof(mybuf)); |
130 | if (bytes < 1) | 131 | if (bytes < 1) |
131 | { | 132 | { |
132 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 133 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
133 | "Finished reading from server stdout with code: %d\n", | 134 | "Finished reading from server stdout with code: %d\n", |
134 | (int)bytes); | 135 | (int) bytes); |
135 | if (0 != GNUNET_OS_process_kill(h->server_proc, GNUNET_TERM_SIG)) | 136 | if (0 != GNUNET_OS_process_kill (h->server_proc, GNUNET_TERM_SIG)) |
136 | GNUNET_log_from_strerror(GNUNET_ERROR_TYPE_WARNING, "nat", "kill"); | 137 | GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_WARNING, "nat", "kill"); |
137 | GNUNET_OS_process_wait(h->server_proc); | 138 | GNUNET_OS_process_wait (h->server_proc); |
138 | GNUNET_OS_process_destroy(h->server_proc); | 139 | GNUNET_OS_process_destroy (h->server_proc); |
139 | h->server_proc = NULL; | 140 | h->server_proc = NULL; |
140 | GNUNET_DISK_pipe_close(h->server_stdout); | 141 | GNUNET_DISK_pipe_close (h->server_stdout); |
141 | h->server_stdout = NULL; | 142 | h->server_stdout = NULL; |
142 | h->server_stdout_handle = NULL; | 143 | h->server_stdout_handle = NULL; |
143 | try_again(h); | 144 | try_again (h); |
144 | return; | 145 | return; |
145 | } | 146 | } |
146 | 147 | ||
147 | port_start = NULL; | 148 | port_start = NULL; |
148 | for (size_t i = 0; i < sizeof(mybuf); i++) | 149 | for (size_t i = 0; i < sizeof(mybuf); i++) |
150 | { | ||
151 | if (mybuf[i] == '\n') | ||
149 | { | 152 | { |
150 | if (mybuf[i] == '\n') | 153 | mybuf[i] = '\0'; |
151 | { | 154 | break; |
152 | mybuf[i] = '\0'; | ||
153 | break; | ||
154 | } | ||
155 | if ((mybuf[i] == ':') && (i + 1 < sizeof(mybuf))) | ||
156 | { | ||
157 | mybuf[i] = '\0'; | ||
158 | port_start = &mybuf[i + 1]; | ||
159 | } | ||
160 | } | 155 | } |
156 | if ((mybuf[i] == ':') && (i + 1 < sizeof(mybuf))) | ||
157 | { | ||
158 | mybuf[i] = '\0'; | ||
159 | port_start = &mybuf[i + 1]; | ||
160 | } | ||
161 | } | ||
161 | 162 | ||
162 | /* construct socket address of sender */ | 163 | /* construct socket address of sender */ |
163 | memset(&sin_addr, 0, sizeof(sin_addr)); | 164 | memset (&sin_addr, 0, sizeof(sin_addr)); |
164 | sin_addr.sin_family = AF_INET; | 165 | sin_addr.sin_family = AF_INET; |
165 | #if HAVE_SOCKADDR_IN_SIN_LEN | 166 | #if HAVE_SOCKADDR_IN_SIN_LEN |
166 | sin_addr.sin_len = sizeof(sin_addr); | 167 | sin_addr.sin_len = sizeof(sin_addr); |
167 | #endif | 168 | #endif |
168 | if ((NULL == port_start) || (1 != sscanf(port_start, "%d", &port)) || | 169 | if ((NULL == port_start) || (1 != sscanf (port_start, "%d", &port)) || |
169 | (-1 == inet_pton(AF_INET, mybuf, &sin_addr.sin_addr))) | 170 | (-1 == inet_pton (AF_INET, mybuf, &sin_addr.sin_addr))) |
170 | { | 171 | { |
171 | /* should we restart gnunet-helper-nat-server? */ | 172 | /* should we restart gnunet-helper-nat-server? */ |
172 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 173 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
173 | _( | 174 | _ ( |
174 | "gnunet-helper-nat-server generated malformed address `%s'\n"), | 175 | "gnunet-helper-nat-server generated malformed address `%s'\n"), |
175 | mybuf); | 176 | mybuf); |
176 | h->server_read_task = | 177 | h->server_read_task = |
177 | GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, | 178 | GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, |
178 | h->server_stdout_handle, | 179 | h->server_stdout_handle, |
179 | &nat_server_read, | 180 | &nat_server_read, |
180 | h); | 181 | h); |
181 | return; | 182 | return; |
182 | } | 183 | } |
183 | sin_addr.sin_port = htons((uint16_t)port); | 184 | sin_addr.sin_port = htons ((uint16_t) port); |
184 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 185 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
185 | "gnunet-helper-nat-server read: %s:%d\n", | 186 | "gnunet-helper-nat-server read: %s:%d\n", |
186 | mybuf, | 187 | mybuf, |
187 | port); | 188 | port); |
188 | h->cb(h->cb_cls, &sin_addr); | 189 | h->cb (h->cb_cls, &sin_addr); |
189 | h->server_read_task = | 190 | h->server_read_task = |
190 | GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, | 191 | GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, |
191 | h->server_stdout_handle, | 192 | h->server_stdout_handle, |
192 | &nat_server_read, | 193 | &nat_server_read, |
193 | h); | 194 | h); |
194 | } | 195 | } |
195 | 196 | ||
196 | 197 | ||
@@ -201,67 +202,67 @@ nat_server_read(void *cls) | |||
201 | * @param cls a `struct HelperContext` | 202 | * @param cls a `struct HelperContext` |
202 | */ | 203 | */ |
203 | static void | 204 | static void |
204 | restart_nat_server(void *cls) | 205 | restart_nat_server (void *cls) |
205 | { | 206 | { |
206 | struct HelperContext *h = cls; | 207 | struct HelperContext *h = cls; |
207 | char *binary; | 208 | char *binary; |
208 | char ia[INET_ADDRSTRLEN]; | 209 | char ia[INET_ADDRSTRLEN]; |
209 | 210 | ||
210 | h->server_read_task = NULL; | 211 | h->server_read_task = NULL; |
211 | GNUNET_assert(NULL != | 212 | GNUNET_assert (NULL != |
212 | inet_ntop(AF_INET, &h->internal_address, ia, sizeof(ia))); | 213 | inet_ntop (AF_INET, &h->internal_address, ia, sizeof(ia))); |
213 | /* Start the server process */ | 214 | /* Start the server process */ |
214 | binary = GNUNET_OS_get_suid_binary_path(h->cfg, "gnunet-helper-nat-server"); | 215 | binary = GNUNET_OS_get_suid_binary_path (h->cfg, "gnunet-helper-nat-server"); |
215 | if (GNUNET_YES != GNUNET_OS_check_helper_binary(binary, GNUNET_YES, ia)) | 216 | if (GNUNET_YES != GNUNET_OS_check_helper_binary (binary, GNUNET_YES, ia)) |
216 | { | 217 | { |
217 | /* move instantly to max delay, as this is unlikely to be fixed */ | 218 | /* move instantly to max delay, as this is unlikely to be fixed */ |
218 | h->server_retry_delay = GNUNET_TIME_STD_EXPONENTIAL_BACKOFF_THRESHOLD; | 219 | h->server_retry_delay = GNUNET_TIME_STD_EXPONENTIAL_BACKOFF_THRESHOLD; |
219 | GNUNET_free(binary); | 220 | GNUNET_free (binary); |
220 | try_again(h); | 221 | try_again (h); |
221 | return; | 222 | return; |
222 | } | 223 | } |
223 | h->server_stdout = | 224 | h->server_stdout = |
224 | GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES); | 225 | GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES); |
225 | if (NULL == h->server_stdout) | 226 | if (NULL == h->server_stdout) |
226 | { | 227 | { |
227 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "pipe"); | 228 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "pipe"); |
228 | GNUNET_free(binary); | 229 | GNUNET_free (binary); |
229 | try_again(h); | 230 | try_again (h); |
230 | return; | 231 | return; |
231 | } | 232 | } |
232 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 233 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
233 | "Starting `%s' at `%s'\n", | 234 | "Starting `%s' at `%s'\n", |
234 | "gnunet-helper-nat-server", | 235 | "gnunet-helper-nat-server", |
235 | ia); | 236 | ia); |
236 | h->server_proc = GNUNET_OS_start_process(GNUNET_NO, | 237 | h->server_proc = GNUNET_OS_start_process (GNUNET_NO, |
237 | 0, | 238 | 0, |
238 | NULL, | 239 | NULL, |
239 | h->server_stdout, | 240 | h->server_stdout, |
240 | NULL, | 241 | NULL, |
241 | binary, | 242 | binary, |
242 | "gnunet-helper-nat-server", | 243 | "gnunet-helper-nat-server", |
243 | ia, | 244 | ia, |
244 | NULL); | 245 | NULL); |
245 | GNUNET_free(binary); | 246 | GNUNET_free (binary); |
246 | if (NULL == h->server_proc) | 247 | if (NULL == h->server_proc) |
247 | { | 248 | { |
248 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 249 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
249 | _("Failed to start %s\n"), | 250 | _ ("Failed to start %s\n"), |
250 | "gnunet-helper-nat-server"); | 251 | "gnunet-helper-nat-server"); |
251 | GNUNET_DISK_pipe_close(h->server_stdout); | 252 | GNUNET_DISK_pipe_close (h->server_stdout); |
252 | h->server_stdout = NULL; | 253 | h->server_stdout = NULL; |
253 | try_again(h); | 254 | try_again (h); |
254 | return; | 255 | return; |
255 | } | 256 | } |
256 | /* Close the write end of the read pipe */ | 257 | /* Close the write end of the read pipe */ |
257 | GNUNET_DISK_pipe_close_end(h->server_stdout, GNUNET_DISK_PIPE_END_WRITE); | 258 | GNUNET_DISK_pipe_close_end (h->server_stdout, GNUNET_DISK_PIPE_END_WRITE); |
258 | h->server_stdout_handle = | 259 | h->server_stdout_handle = |
259 | GNUNET_DISK_pipe_handle(h->server_stdout, GNUNET_DISK_PIPE_END_READ); | 260 | GNUNET_DISK_pipe_handle (h->server_stdout, GNUNET_DISK_PIPE_END_READ); |
260 | h->server_read_task = | 261 | h->server_read_task = |
261 | GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, | 262 | GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, |
262 | h->server_stdout_handle, | 263 | h->server_stdout_handle, |
263 | &nat_server_read, | 264 | &nat_server_read, |
264 | h); | 265 | h); |
265 | } | 266 | } |
266 | 267 | ||
267 | 268 | ||
@@ -276,24 +277,24 @@ restart_nat_server(void *cls) | |||
276 | * @return NULL on error | 277 | * @return NULL on error |
277 | */ | 278 | */ |
278 | struct HelperContext * | 279 | struct HelperContext * |
279 | GN_start_gnunet_nat_server_(const struct in_addr *internal_address, | 280 | GN_start_gnunet_nat_server_ (const struct in_addr *internal_address, |
280 | GN_ReversalCallback cb, | 281 | GN_ReversalCallback cb, |
281 | void *cb_cls, | 282 | void *cb_cls, |
282 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 283 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
283 | { | 284 | { |
284 | struct HelperContext *h; | 285 | struct HelperContext *h; |
285 | 286 | ||
286 | h = GNUNET_new(struct HelperContext); | 287 | h = GNUNET_new (struct HelperContext); |
287 | h->cb = cb; | 288 | h->cb = cb; |
288 | h->cb_cls = cb_cls; | 289 | h->cb_cls = cb_cls; |
289 | h->internal_address = *internal_address; | 290 | h->internal_address = *internal_address; |
290 | h->cfg = cfg; | 291 | h->cfg = cfg; |
291 | restart_nat_server(h); | 292 | restart_nat_server (h); |
292 | if (NULL == h->server_stdout) | 293 | if (NULL == h->server_stdout) |
293 | { | 294 | { |
294 | GN_stop_gnunet_nat_server_(h); | 295 | GN_stop_gnunet_nat_server_ (h); |
295 | return NULL; | 296 | return NULL; |
296 | } | 297 | } |
297 | return h; | 298 | return h; |
298 | } | 299 | } |
299 | 300 | ||
@@ -305,31 +306,31 @@ GN_start_gnunet_nat_server_(const struct in_addr *internal_address, | |||
305 | * @param h helper context to stop | 306 | * @param h helper context to stop |
306 | */ | 307 | */ |
307 | void | 308 | void |
308 | GN_stop_gnunet_nat_server_(struct HelperContext *h) | 309 | GN_stop_gnunet_nat_server_ (struct HelperContext *h) |
309 | { | 310 | { |
310 | if (NULL != h->server_read_task) | 311 | if (NULL != h->server_read_task) |
311 | { | 312 | { |
312 | GNUNET_SCHEDULER_cancel(h->server_read_task); | 313 | GNUNET_SCHEDULER_cancel (h->server_read_task); |
313 | h->server_read_task = NULL; | 314 | h->server_read_task = NULL; |
314 | } | 315 | } |
315 | if (NULL != h->server_proc) | 316 | if (NULL != h->server_proc) |
316 | { | 317 | { |
317 | if (0 != GNUNET_OS_process_kill(h->server_proc, GNUNET_TERM_SIG)) | 318 | if (0 != GNUNET_OS_process_kill (h->server_proc, GNUNET_TERM_SIG)) |
318 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); | 319 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); |
319 | GNUNET_OS_process_wait(h->server_proc); | 320 | GNUNET_OS_process_wait (h->server_proc); |
320 | GNUNET_OS_process_destroy(h->server_proc); | 321 | GNUNET_OS_process_destroy (h->server_proc); |
321 | h->server_proc = NULL; | 322 | h->server_proc = NULL; |
322 | GNUNET_DISK_pipe_close(h->server_stdout); | 323 | GNUNET_DISK_pipe_close (h->server_stdout); |
323 | h->server_stdout = NULL; | 324 | h->server_stdout = NULL; |
324 | h->server_stdout_handle = NULL; | 325 | h->server_stdout_handle = NULL; |
325 | } | 326 | } |
326 | if (NULL != h->server_stdout) | 327 | if (NULL != h->server_stdout) |
327 | { | 328 | { |
328 | GNUNET_DISK_pipe_close(h->server_stdout); | 329 | GNUNET_DISK_pipe_close (h->server_stdout); |
329 | h->server_stdout = NULL; | 330 | h->server_stdout = NULL; |
330 | h->server_stdout_handle = NULL; | 331 | h->server_stdout_handle = NULL; |
331 | } | 332 | } |
332 | GNUNET_free(h); | 333 | GNUNET_free (h); |
333 | } | 334 | } |
334 | 335 | ||
335 | 336 | ||
@@ -346,10 +347,10 @@ GN_stop_gnunet_nat_server_(struct HelperContext *h) | |||
346 | * #GNUNET_OK otherwise | 347 | * #GNUNET_OK otherwise |
347 | */ | 348 | */ |
348 | int | 349 | int |
349 | GN_request_connection_reversal(const struct in_addr *internal_address, | 350 | GN_request_connection_reversal (const struct in_addr *internal_address, |
350 | uint16_t internal_port, | 351 | uint16_t internal_port, |
351 | const struct in_addr *remote_v4, | 352 | const struct in_addr *remote_v4, |
352 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 353 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
353 | { | 354 | { |
354 | char intv4[INET_ADDRSTRLEN]; | 355 | char intv4[INET_ADDRSTRLEN]; |
355 | char remv4[INET_ADDRSTRLEN]; | 356 | char remv4[INET_ADDRSTRLEN]; |
@@ -357,44 +358,44 @@ GN_request_connection_reversal(const struct in_addr *internal_address, | |||
357 | struct GNUNET_OS_Process *proc; | 358 | struct GNUNET_OS_Process *proc; |
358 | char *binary; | 359 | char *binary; |
359 | 360 | ||
360 | if (NULL == inet_ntop(AF_INET, internal_address, intv4, INET_ADDRSTRLEN)) | 361 | if (NULL == inet_ntop (AF_INET, internal_address, intv4, INET_ADDRSTRLEN)) |
361 | { | 362 | { |
362 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "inet_ntop"); | 363 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop"); |
363 | return GNUNET_SYSERR; | 364 | return GNUNET_SYSERR; |
364 | } | 365 | } |
365 | if (NULL == inet_ntop(AF_INET, remote_v4, remv4, INET_ADDRSTRLEN)) | 366 | if (NULL == inet_ntop (AF_INET, remote_v4, remv4, INET_ADDRSTRLEN)) |
366 | { | 367 | { |
367 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "inet_ntop"); | 368 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop"); |
368 | return GNUNET_SYSERR; | 369 | return GNUNET_SYSERR; |
369 | } | 370 | } |
370 | GNUNET_snprintf(port_as_string, | 371 | GNUNET_snprintf (port_as_string, |
371 | sizeof(port_as_string), | 372 | sizeof(port_as_string), |
372 | "%d", | 373 | "%d", |
373 | internal_port); | 374 | internal_port); |
374 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 375 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
375 | "Running gnunet-helper-nat-client %s %s %u\n", | 376 | "Running gnunet-helper-nat-client %s %s %u\n", |
376 | intv4, | 377 | intv4, |
377 | remv4, | 378 | remv4, |
378 | internal_port); | 379 | internal_port); |
379 | binary = GNUNET_OS_get_suid_binary_path(cfg, "gnunet-helper-nat-client"); | 380 | binary = GNUNET_OS_get_suid_binary_path (cfg, "gnunet-helper-nat-client"); |
380 | proc = GNUNET_OS_start_process(GNUNET_NO, | 381 | proc = GNUNET_OS_start_process (GNUNET_NO, |
381 | 0, | 382 | 0, |
382 | NULL, | 383 | NULL, |
383 | NULL, | 384 | NULL, |
384 | NULL, | 385 | NULL, |
385 | binary, | 386 | binary, |
386 | "gnunet-helper-nat-client", | 387 | "gnunet-helper-nat-client", |
387 | intv4, | 388 | intv4, |
388 | remv4, | 389 | remv4, |
389 | port_as_string, | 390 | port_as_string, |
390 | NULL); | 391 | NULL); |
391 | GNUNET_free(binary); | 392 | GNUNET_free (binary); |
392 | if (NULL == proc) | 393 | if (NULL == proc) |
393 | return GNUNET_SYSERR; | 394 | return GNUNET_SYSERR; |
394 | /* we know that the gnunet-helper-nat-client will terminate virtually | 395 | /* we know that the gnunet-helper-nat-client will terminate virtually |
395 | * instantly */ | 396 | * instantly */ |
396 | GNUNET_OS_process_wait(proc); | 397 | GNUNET_OS_process_wait (proc); |
397 | GNUNET_OS_process_destroy(proc); | 398 | GNUNET_OS_process_destroy (proc); |
398 | return GNUNET_OK; | 399 | return GNUNET_OK; |
399 | } | 400 | } |
400 | 401 | ||
diff --git a/src/nat/gnunet-service-nat_helper.h b/src/nat/gnunet-service-nat_helper.h index e655149bc..dc6b9ae61 100644 --- a/src/nat/gnunet-service-nat_helper.h +++ b/src/nat/gnunet-service-nat_helper.h | |||
@@ -57,10 +57,10 @@ typedef void | |||
57 | * @return NULL on error | 57 | * @return NULL on error |
58 | */ | 58 | */ |
59 | struct HelperContext * | 59 | struct HelperContext * |
60 | GN_start_gnunet_nat_server_(const struct in_addr *internal_address, | 60 | GN_start_gnunet_nat_server_ (const struct in_addr *internal_address, |
61 | GN_ReversalCallback cb, | 61 | GN_ReversalCallback cb, |
62 | void *cb_cls, | 62 | void *cb_cls, |
63 | const struct GNUNET_CONFIGURATION_Handle *cfg); | 63 | const struct GNUNET_CONFIGURATION_Handle *cfg); |
64 | 64 | ||
65 | 65 | ||
66 | /** | 66 | /** |
@@ -70,7 +70,7 @@ GN_start_gnunet_nat_server_(const struct in_addr *internal_address, | |||
70 | * @param h helper context to stop | 70 | * @param h helper context to stop |
71 | */ | 71 | */ |
72 | void | 72 | void |
73 | GN_stop_gnunet_nat_server_(struct HelperContext *h); | 73 | GN_stop_gnunet_nat_server_ (struct HelperContext *h); |
74 | 74 | ||
75 | 75 | ||
76 | /** | 76 | /** |
@@ -86,10 +86,10 @@ GN_stop_gnunet_nat_server_(struct HelperContext *h); | |||
86 | * #GNUNET_OK otherwise | 86 | * #GNUNET_OK otherwise |
87 | */ | 87 | */ |
88 | int | 88 | int |
89 | GN_request_connection_reversal(const struct in_addr *internal_address, | 89 | GN_request_connection_reversal (const struct in_addr *internal_address, |
90 | uint16_t internal_port, | 90 | uint16_t internal_port, |
91 | const struct in_addr *remote_v4, | 91 | const struct in_addr *remote_v4, |
92 | const struct GNUNET_CONFIGURATION_Handle *cfg); | 92 | const struct GNUNET_CONFIGURATION_Handle *cfg); |
93 | 93 | ||
94 | 94 | ||
95 | /* end of gnunet-service-nat_helper.h */ | 95 | /* end of gnunet-service-nat_helper.h */ |
diff --git a/src/nat/gnunet-service-nat_mini.c b/src/nat/gnunet-service-nat_mini.c index 94534e81c..1382010bd 100644 --- a/src/nat/gnunet-service-nat_mini.c +++ b/src/nat/gnunet-service-nat_mini.c | |||
@@ -29,24 +29,24 @@ | |||
29 | #include "gnunet-service-nat_mini.h" | 29 | #include "gnunet-service-nat_mini.h" |
30 | #include "nat.h" | 30 | #include "nat.h" |
31 | 31 | ||
32 | #define LOG(kind, ...) GNUNET_log_from(kind, "nat", __VA_ARGS__) | 32 | #define LOG(kind, ...) GNUNET_log_from (kind, "nat", __VA_ARGS__) |
33 | 33 | ||
34 | /** | 34 | /** |
35 | * How long do we give upnpc to create a mapping? | 35 | * How long do we give upnpc to create a mapping? |
36 | */ | 36 | */ |
37 | #define MAP_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15) | 37 | #define MAP_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15) |
38 | 38 | ||
39 | /** | 39 | /** |
40 | * How long do we give upnpc to remove a mapping? | 40 | * How long do we give upnpc to remove a mapping? |
41 | */ | 41 | */ |
42 | #define UNMAP_TIMEOUT \ | 42 | #define UNMAP_TIMEOUT \ |
43 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1) | 43 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1) |
44 | 44 | ||
45 | /** | 45 | /** |
46 | * How often do we check for changes in the mapping? | 46 | * How often do we check for changes in the mapping? |
47 | */ | 47 | */ |
48 | #define MAP_REFRESH_FREQ \ | 48 | #define MAP_REFRESH_FREQ \ |
49 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5) | 49 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5) |
50 | 50 | ||
51 | 51 | ||
52 | /* ************************* external-ip calling ************************ */ | 52 | /* ************************* external-ip calling ************************ */ |
@@ -54,7 +54,8 @@ | |||
54 | /** | 54 | /** |
55 | * Opaque handle to cancel "GNUNET_NAT_mini_get_external_ipv4" operation. | 55 | * Opaque handle to cancel "GNUNET_NAT_mini_get_external_ipv4" operation. |
56 | */ | 56 | */ |
57 | struct GNUNET_NAT_ExternalHandle { | 57 | struct GNUNET_NAT_ExternalHandle |
58 | { | ||
58 | /** | 59 | /** |
59 | * Function to call with the result. | 60 | * Function to call with the result. |
60 | */ | 61 | */ |
@@ -109,43 +110,43 @@ struct GNUNET_NAT_ExternalHandle { | |||
109 | * @param cls the `struct GNUNET_NAT_ExternalHandle` | 110 | * @param cls the `struct GNUNET_NAT_ExternalHandle` |
110 | */ | 111 | */ |
111 | static void | 112 | static void |
112 | read_external_ipv4(void *cls) | 113 | read_external_ipv4 (void *cls) |
113 | { | 114 | { |
114 | struct GNUNET_NAT_ExternalHandle *eh = cls; | 115 | struct GNUNET_NAT_ExternalHandle *eh = cls; |
115 | ssize_t ret; | 116 | ssize_t ret; |
116 | struct in_addr addr; | 117 | struct in_addr addr; |
117 | 118 | ||
118 | eh->task = NULL; | 119 | eh->task = NULL; |
119 | ret = GNUNET_DISK_file_read(eh->r, | 120 | ret = GNUNET_DISK_file_read (eh->r, |
120 | &eh->buf[eh->off], | 121 | &eh->buf[eh->off], |
121 | sizeof(eh->buf) - eh->off); | 122 | sizeof(eh->buf) - eh->off); |
122 | if (ret > 0) | 123 | if (ret > 0) |
123 | { | 124 | { |
124 | /* try to read more */ | 125 | /* try to read more */ |
125 | eh->off += ret; | 126 | eh->off += ret; |
126 | eh->task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, | 127 | eh->task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, |
127 | eh->r, | 128 | eh->r, |
128 | &read_external_ipv4, | 129 | &read_external_ipv4, |
129 | eh); | 130 | eh); |
130 | return; | 131 | return; |
131 | } | 132 | } |
132 | eh->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID; | 133 | eh->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID; |
133 | if ((eh->off > 7) && (eh->buf[eh->off - 1] == '\n')) | 134 | if ((eh->off > 7) && (eh->buf[eh->off - 1] == '\n')) |
135 | { | ||
136 | eh->buf[eh->off - 1] = '\0'; | ||
137 | if (1 == inet_pton (AF_INET, eh->buf, &addr)) | ||
134 | { | 138 | { |
135 | eh->buf[eh->off - 1] = '\0'; | 139 | if (0 == addr.s_addr) |
136 | if (1 == inet_pton(AF_INET, eh->buf, &addr)) | 140 | eh->ret = |
137 | { | 141 | GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID; /* got 0.0.0.0 */ |
138 | if (0 == addr.s_addr) | 142 | else |
139 | eh->ret = | 143 | eh->ret = GNUNET_NAT_ERROR_SUCCESS; |
140 | GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID; /* got 0.0.0.0 */ | ||
141 | else | ||
142 | eh->ret = GNUNET_NAT_ERROR_SUCCESS; | ||
143 | } | ||
144 | } | 144 | } |
145 | eh->cb(eh->cb_cls, | 145 | } |
146 | (GNUNET_NAT_ERROR_SUCCESS == eh->ret) ? &addr : NULL, | 146 | eh->cb (eh->cb_cls, |
147 | eh->ret); | 147 | (GNUNET_NAT_ERROR_SUCCESS == eh->ret) ? &addr : NULL, |
148 | GNUNET_NAT_mini_get_external_ipv4_cancel_(eh); | 148 | eh->ret); |
149 | GNUNET_NAT_mini_get_external_ipv4_cancel_ (eh); | ||
149 | } | 150 | } |
150 | 151 | ||
151 | 152 | ||
@@ -155,13 +156,13 @@ read_external_ipv4(void *cls) | |||
155 | * @param cls the `struct GNUNET_NAT_ExternalHandle` (freed) | 156 | * @param cls the `struct GNUNET_NAT_ExternalHandle` (freed) |
156 | */ | 157 | */ |
157 | static void | 158 | static void |
158 | signal_external_ip_error(void *cls) | 159 | signal_external_ip_error (void *cls) |
159 | { | 160 | { |
160 | struct GNUNET_NAT_ExternalHandle *eh = cls; | 161 | struct GNUNET_NAT_ExternalHandle *eh = cls; |
161 | 162 | ||
162 | eh->task = NULL; | 163 | eh->task = NULL; |
163 | eh->cb(eh->cb_cls, NULL, eh->ret); | 164 | eh->cb (eh->cb_cls, NULL, eh->ret); |
164 | GNUNET_free(eh); | 165 | GNUNET_free (eh); |
165 | } | 166 | } |
166 | 167 | ||
167 | 168 | ||
@@ -173,52 +174,52 @@ signal_external_ip_error(void *cls) | |||
173 | * @return handle for cancellation (can only be used until @a cb is called), never NULL | 174 | * @return handle for cancellation (can only be used until @a cb is called), never NULL |
174 | */ | 175 | */ |
175 | struct GNUNET_NAT_ExternalHandle * | 176 | struct GNUNET_NAT_ExternalHandle * |
176 | GNUNET_NAT_mini_get_external_ipv4_(GNUNET_NAT_IPCallback cb, void *cb_cls) | 177 | GNUNET_NAT_mini_get_external_ipv4_ (GNUNET_NAT_IPCallback cb, void *cb_cls) |
177 | { | 178 | { |
178 | struct GNUNET_NAT_ExternalHandle *eh; | 179 | struct GNUNET_NAT_ExternalHandle *eh; |
179 | 180 | ||
180 | eh = GNUNET_new(struct GNUNET_NAT_ExternalHandle); | 181 | eh = GNUNET_new (struct GNUNET_NAT_ExternalHandle); |
181 | eh->cb = cb; | 182 | eh->cb = cb; |
182 | eh->cb_cls = cb_cls; | 183 | eh->cb_cls = cb_cls; |
183 | eh->ret = GNUNET_NAT_ERROR_SUCCESS; | 184 | eh->ret = GNUNET_NAT_ERROR_SUCCESS; |
184 | if (GNUNET_SYSERR == | 185 | if (GNUNET_SYSERR == |
185 | GNUNET_OS_check_helper_binary("external-ip", GNUNET_NO, NULL)) | 186 | GNUNET_OS_check_helper_binary ("external-ip", GNUNET_NO, NULL)) |
186 | { | 187 | { |
187 | LOG(GNUNET_ERROR_TYPE_INFO, _("`external-ip' command not found\n")); | 188 | LOG (GNUNET_ERROR_TYPE_INFO, _ ("`external-ip' command not found\n")); |
188 | eh->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND; | 189 | eh->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_NOT_FOUND; |
189 | eh->task = GNUNET_SCHEDULER_add_now(&signal_external_ip_error, eh); | 190 | eh->task = GNUNET_SCHEDULER_add_now (&signal_external_ip_error, eh); |
190 | return eh; | 191 | return eh; |
191 | } | 192 | } |
192 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 193 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
193 | "Running `external-ip' to determine our external IP\n"); | 194 | "Running `external-ip' to determine our external IP\n"); |
194 | eh->opipe = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES); | 195 | eh->opipe = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES); |
195 | if (NULL == eh->opipe) | 196 | if (NULL == eh->opipe) |
196 | { | 197 | { |
197 | eh->ret = GNUNET_NAT_ERROR_IPC_FAILURE; | 198 | eh->ret = GNUNET_NAT_ERROR_IPC_FAILURE; |
198 | eh->task = GNUNET_SCHEDULER_add_now(&signal_external_ip_error, eh); | 199 | eh->task = GNUNET_SCHEDULER_add_now (&signal_external_ip_error, eh); |
199 | return eh; | 200 | return eh; |
200 | } | 201 | } |
201 | eh->eip = GNUNET_OS_start_process(GNUNET_NO, | 202 | eh->eip = GNUNET_OS_start_process (GNUNET_NO, |
202 | 0, | 203 | 0, |
203 | NULL, | 204 | NULL, |
204 | eh->opipe, | 205 | eh->opipe, |
205 | NULL, | 206 | NULL, |
206 | "external-ip", | 207 | "external-ip", |
207 | "external-ip", | 208 | "external-ip", |
208 | NULL); | 209 | NULL); |
209 | if (NULL == eh->eip) | 210 | if (NULL == eh->eip) |
210 | { | 211 | { |
211 | GNUNET_DISK_pipe_close(eh->opipe); | 212 | GNUNET_DISK_pipe_close (eh->opipe); |
212 | eh->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED; | 213 | eh->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED; |
213 | eh->task = GNUNET_SCHEDULER_add_now(&signal_external_ip_error, eh); | 214 | eh->task = GNUNET_SCHEDULER_add_now (&signal_external_ip_error, eh); |
214 | return eh; | 215 | return eh; |
215 | } | 216 | } |
216 | GNUNET_DISK_pipe_close_end(eh->opipe, GNUNET_DISK_PIPE_END_WRITE); | 217 | GNUNET_DISK_pipe_close_end (eh->opipe, GNUNET_DISK_PIPE_END_WRITE); |
217 | eh->r = GNUNET_DISK_pipe_handle(eh->opipe, GNUNET_DISK_PIPE_END_READ); | 218 | eh->r = GNUNET_DISK_pipe_handle (eh->opipe, GNUNET_DISK_PIPE_END_READ); |
218 | eh->task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, | 219 | eh->task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, |
219 | eh->r, | 220 | eh->r, |
220 | &read_external_ipv4, | 221 | &read_external_ipv4, |
221 | eh); | 222 | eh); |
222 | return eh; | 223 | return eh; |
223 | } | 224 | } |
224 | 225 | ||
@@ -229,25 +230,25 @@ GNUNET_NAT_mini_get_external_ipv4_(GNUNET_NAT_IPCallback cb, void *cb_cls) | |||
229 | * @param eh operation to cancel | 230 | * @param eh operation to cancel |
230 | */ | 231 | */ |
231 | void | 232 | void |
232 | GNUNET_NAT_mini_get_external_ipv4_cancel_(struct GNUNET_NAT_ExternalHandle *eh) | 233 | GNUNET_NAT_mini_get_external_ipv4_cancel_ (struct GNUNET_NAT_ExternalHandle *eh) |
233 | { | 234 | { |
234 | if (NULL != eh->eip) | 235 | if (NULL != eh->eip) |
235 | { | 236 | { |
236 | (void)GNUNET_OS_process_kill(eh->eip, SIGKILL); | 237 | (void) GNUNET_OS_process_kill (eh->eip, SIGKILL); |
237 | GNUNET_break(GNUNET_OK == GNUNET_OS_process_wait(eh->eip)); | 238 | GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (eh->eip)); |
238 | GNUNET_OS_process_destroy(eh->eip); | 239 | GNUNET_OS_process_destroy (eh->eip); |
239 | } | 240 | } |
240 | if (NULL != eh->opipe) | 241 | if (NULL != eh->opipe) |
241 | { | 242 | { |
242 | GNUNET_DISK_pipe_close(eh->opipe); | 243 | GNUNET_DISK_pipe_close (eh->opipe); |
243 | eh->opipe = NULL; | 244 | eh->opipe = NULL; |
244 | } | 245 | } |
245 | if (NULL != eh->task) | 246 | if (NULL != eh->task) |
246 | { | 247 | { |
247 | GNUNET_SCHEDULER_cancel(eh->task); | 248 | GNUNET_SCHEDULER_cancel (eh->task); |
248 | eh->task = NULL; | 249 | eh->task = NULL; |
249 | } | 250 | } |
250 | GNUNET_free(eh); | 251 | GNUNET_free (eh); |
251 | } | 252 | } |
252 | 253 | ||
253 | 254 | ||
@@ -257,7 +258,8 @@ GNUNET_NAT_mini_get_external_ipv4_cancel_(struct GNUNET_NAT_ExternalHandle *eh) | |||
257 | /** | 258 | /** |
258 | * Handle to a mapping created with upnpc. | 259 | * Handle to a mapping created with upnpc. |
259 | */ | 260 | */ |
260 | struct GNUNET_NAT_MiniHandle { | 261 | struct GNUNET_NAT_MiniHandle |
262 | { | ||
261 | /** | 263 | /** |
262 | * Function to call on mapping changes. | 264 | * Function to call on mapping changes. |
263 | */ | 265 | */ |
@@ -322,7 +324,7 @@ struct GNUNET_NAT_MiniHandle { | |||
322 | * @param cls the `struct GNUNET_NAT_MiniHandle` | 324 | * @param cls the `struct GNUNET_NAT_MiniHandle` |
323 | */ | 325 | */ |
324 | static void | 326 | static void |
325 | do_refresh(void *cls); | 327 | do_refresh (void *cls); |
326 | 328 | ||
327 | 329 | ||
328 | /** | 330 | /** |
@@ -332,7 +334,7 @@ do_refresh(void *cls); | |||
332 | * @param line line of output, NULL at the end | 334 | * @param line line of output, NULL at the end |
333 | */ | 335 | */ |
334 | static void | 336 | static void |
335 | process_map_output(void *cls, const char *line); | 337 | process_map_output (void *cls, const char *line); |
336 | 338 | ||
337 | 339 | ||
338 | /** | 340 | /** |
@@ -341,29 +343,29 @@ process_map_output(void *cls, const char *line); | |||
341 | * @param mini our handle | 343 | * @param mini our handle |
342 | */ | 344 | */ |
343 | static void | 345 | static void |
344 | run_upnpc_r(struct GNUNET_NAT_MiniHandle *mini) | 346 | run_upnpc_r (struct GNUNET_NAT_MiniHandle *mini) |
345 | { | 347 | { |
346 | char pstr[6]; | 348 | char pstr[6]; |
347 | 349 | ||
348 | GNUNET_snprintf(pstr, sizeof(pstr), "%u", (unsigned int)mini->port); | 350 | GNUNET_snprintf (pstr, sizeof(pstr), "%u", (unsigned int) mini->port); |
349 | mini->map_cmd = GNUNET_OS_command_run(&process_map_output, | 351 | mini->map_cmd = GNUNET_OS_command_run (&process_map_output, |
350 | mini, | 352 | mini, |
351 | MAP_TIMEOUT, | 353 | MAP_TIMEOUT, |
352 | "upnpc", | 354 | "upnpc", |
353 | "upnpc", | 355 | "upnpc", |
354 | "-r", | 356 | "-r", |
355 | pstr, | 357 | pstr, |
356 | mini->is_tcp ? "tcp" : "udp", | 358 | mini->is_tcp ? "tcp" : "udp", |
357 | NULL); | 359 | NULL); |
358 | if (NULL == mini->map_cmd) | 360 | if (NULL == mini->map_cmd) |
359 | { | 361 | { |
360 | mini->ac(mini->ac_cls, | 362 | mini->ac (mini->ac_cls, |
361 | GNUNET_SYSERR, | 363 | GNUNET_SYSERR, |
362 | NULL, | 364 | NULL, |
363 | 0, | 365 | 0, |
364 | GNUNET_NAT_ERROR_UPNPC_FAILED); | 366 | GNUNET_NAT_ERROR_UPNPC_FAILED); |
365 | return; | 367 | return; |
366 | } | 368 | } |
367 | } | 369 | } |
368 | 370 | ||
369 | 371 | ||
@@ -375,7 +377,7 @@ run_upnpc_r(struct GNUNET_NAT_MiniHandle *mini) | |||
375 | * @param line line of output, NULL at the end | 377 | * @param line line of output, NULL at the end |
376 | */ | 378 | */ |
377 | static void | 379 | static void |
378 | process_refresh_output(void *cls, const char *line) | 380 | process_refresh_output (void *cls, const char *line) |
379 | { | 381 | { |
380 | struct GNUNET_NAT_MiniHandle *mini = cls; | 382 | struct GNUNET_NAT_MiniHandle *mini = cls; |
381 | char pstr[9]; | 383 | char pstr[9]; |
@@ -384,53 +386,53 @@ process_refresh_output(void *cls, const char *line) | |||
384 | struct in_addr exip; | 386 | struct in_addr exip; |
385 | 387 | ||
386 | if (NULL == line) | 388 | if (NULL == line) |
389 | { | ||
390 | GNUNET_OS_command_stop (mini->refresh_cmd); | ||
391 | mini->refresh_cmd = NULL; | ||
392 | if (GNUNET_NO == mini->found) | ||
387 | { | 393 | { |
388 | GNUNET_OS_command_stop(mini->refresh_cmd); | 394 | /* mapping disappeared, try to re-create */ |
389 | mini->refresh_cmd = NULL; | 395 | if (GNUNET_YES == mini->did_map) |
390 | if (GNUNET_NO == mini->found) | 396 | { |
391 | { | 397 | mini->ac (mini->ac_cls, |
392 | /* mapping disappeared, try to re-create */ | 398 | GNUNET_NO, |
393 | if (GNUNET_YES == mini->did_map) | 399 | (const struct sockaddr *) &mini->current_addr, |
394 | { | 400 | sizeof(mini->current_addr), |
395 | mini->ac(mini->ac_cls, | 401 | GNUNET_NAT_ERROR_SUCCESS); |
396 | GNUNET_NO, | 402 | mini->did_map = GNUNET_NO; |
397 | (const struct sockaddr *)&mini->current_addr, | 403 | } |
398 | sizeof(mini->current_addr), | 404 | run_upnpc_r (mini); |
399 | GNUNET_NAT_ERROR_SUCCESS); | ||
400 | mini->did_map = GNUNET_NO; | ||
401 | } | ||
402 | run_upnpc_r(mini); | ||
403 | } | ||
404 | return; | ||
405 | } | 405 | } |
406 | if (!mini->did_map) | 406 | return; |
407 | } | ||
408 | if (! mini->did_map) | ||
407 | return; /* never mapped, won't find our mapping anyway */ | 409 | return; /* never mapped, won't find our mapping anyway */ |
408 | 410 | ||
409 | /* we're looking for output of the form: | 411 | /* we're looking for output of the form: |
410 | * "ExternalIPAddress = 12.134.41.124" */ | 412 | * "ExternalIPAddress = 12.134.41.124" */ |
411 | 413 | ||
412 | s = strstr(line, "ExternalIPAddress = "); | 414 | s = strstr (line, "ExternalIPAddress = "); |
413 | if (NULL != s) | 415 | if (NULL != s) |
414 | { | 416 | { |
415 | s += strlen("ExternalIPAddress = "); | 417 | s += strlen ("ExternalIPAddress = "); |
416 | if (1 != inet_pton(AF_INET, s, &exip)) | 418 | if (1 != inet_pton (AF_INET, s, &exip)) |
417 | return; /* skip */ | 419 | return; /* skip */ |
418 | if (exip.s_addr == mini->current_addr.sin_addr.s_addr) | 420 | if (exip.s_addr == mini->current_addr.sin_addr.s_addr) |
419 | return; /* no change */ | 421 | return; /* no change */ |
420 | /* update mapping */ | 422 | /* update mapping */ |
421 | mini->ac(mini->ac_cls, | 423 | mini->ac (mini->ac_cls, |
422 | GNUNET_NO, | 424 | GNUNET_NO, |
423 | (const struct sockaddr *)&mini->current_addr, | 425 | (const struct sockaddr *) &mini->current_addr, |
424 | sizeof(mini->current_addr), | 426 | sizeof(mini->current_addr), |
425 | GNUNET_NAT_ERROR_SUCCESS); | 427 | GNUNET_NAT_ERROR_SUCCESS); |
426 | mini->current_addr.sin_addr = exip; | 428 | mini->current_addr.sin_addr = exip; |
427 | mini->ac(mini->ac_cls, | 429 | mini->ac (mini->ac_cls, |
428 | GNUNET_YES, | 430 | GNUNET_YES, |
429 | (const struct sockaddr *)&mini->current_addr, | 431 | (const struct sockaddr *) &mini->current_addr, |
430 | sizeof(mini->current_addr), | 432 | sizeof(mini->current_addr), |
431 | GNUNET_NAT_ERROR_SUCCESS); | 433 | GNUNET_NAT_ERROR_SUCCESS); |
432 | return; | 434 | return; |
433 | } | 435 | } |
434 | /* | 436 | /* |
435 | * we're looking for output of the form: | 437 | * we're looking for output of the form: |
436 | * | 438 | * |
@@ -442,32 +444,32 @@ process_refresh_output(void *cls, const char *line) | |||
442 | * "%s TCP PORT->STRING:OURPORT *" or | 444 | * "%s TCP PORT->STRING:OURPORT *" or |
443 | * "%s UDP PORT->STRING:OURPORT *" | 445 | * "%s UDP PORT->STRING:OURPORT *" |
444 | */ | 446 | */ |
445 | GNUNET_snprintf(pstr, sizeof(pstr), ":%u ", mini->port); | 447 | GNUNET_snprintf (pstr, sizeof(pstr), ":%u ", mini->port); |
446 | if (NULL == (s = strstr(line, "->"))) | 448 | if (NULL == (s = strstr (line, "->"))) |
447 | return; /* skip */ | 449 | return; /* skip */ |
448 | if (NULL == strstr(s, pstr)) | 450 | if (NULL == strstr (s, pstr)) |
449 | return; /* skip */ | 451 | return; /* skip */ |
450 | if (1 != sscanf(line, | 452 | if (1 != sscanf (line, |
451 | (mini->is_tcp) ? "%*u TCP %u->%*s:%*u %*s" | 453 | (mini->is_tcp) ? "%*u TCP %u->%*s:%*u %*s" |
452 | : "%*u UDP %u->%*s:%*u %*s", | 454 | : "%*u UDP %u->%*s:%*u %*s", |
453 | &nport)) | 455 | &nport)) |
454 | return; /* skip */ | 456 | return; /* skip */ |
455 | mini->found = GNUNET_YES; | 457 | mini->found = GNUNET_YES; |
456 | if (nport == ntohs(mini->current_addr.sin_port)) | 458 | if (nport == ntohs (mini->current_addr.sin_port)) |
457 | return; /* no change */ | 459 | return; /* no change */ |
458 | 460 | ||
459 | /* external port changed, update mapping */ | 461 | /* external port changed, update mapping */ |
460 | mini->ac(mini->ac_cls, | 462 | mini->ac (mini->ac_cls, |
461 | GNUNET_NO, | 463 | GNUNET_NO, |
462 | (const struct sockaddr *)&mini->current_addr, | 464 | (const struct sockaddr *) &mini->current_addr, |
463 | sizeof(mini->current_addr), | 465 | sizeof(mini->current_addr), |
464 | GNUNET_NAT_ERROR_SUCCESS); | 466 | GNUNET_NAT_ERROR_SUCCESS); |
465 | mini->current_addr.sin_port = htons((uint16_t)nport); | 467 | mini->current_addr.sin_port = htons ((uint16_t) nport); |
466 | mini->ac(mini->ac_cls, | 468 | mini->ac (mini->ac_cls, |
467 | GNUNET_YES, | 469 | GNUNET_YES, |
468 | (const struct sockaddr *)&mini->current_addr, | 470 | (const struct sockaddr *) &mini->current_addr, |
469 | sizeof(mini->current_addr), | 471 | sizeof(mini->current_addr), |
470 | GNUNET_NAT_ERROR_SUCCESS); | 472 | GNUNET_NAT_ERROR_SUCCESS); |
471 | } | 473 | } |
472 | 474 | ||
473 | 475 | ||
@@ -477,44 +479,44 @@ process_refresh_output(void *cls, const char *line) | |||
477 | * @param cls the 'struct GNUNET_NAT_MiniHandle' | 479 | * @param cls the 'struct GNUNET_NAT_MiniHandle' |
478 | */ | 480 | */ |
479 | static void | 481 | static void |
480 | do_refresh(void *cls) | 482 | do_refresh (void *cls) |
481 | { | 483 | { |
482 | struct GNUNET_NAT_MiniHandle *mini = cls; | 484 | struct GNUNET_NAT_MiniHandle *mini = cls; |
483 | int ac; | 485 | int ac; |
484 | 486 | ||
485 | mini->refresh_task = | 487 | mini->refresh_task = |
486 | GNUNET_SCHEDULER_add_delayed(MAP_REFRESH_FREQ, &do_refresh, mini); | 488 | GNUNET_SCHEDULER_add_delayed (MAP_REFRESH_FREQ, &do_refresh, mini); |
487 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 489 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
488 | "Running `upnpc' to check if our mapping still exists\n"); | 490 | "Running `upnpc' to check if our mapping still exists\n"); |
489 | mini->found = GNUNET_NO; | 491 | mini->found = GNUNET_NO; |
490 | ac = GNUNET_NO; | 492 | ac = GNUNET_NO; |
491 | if (NULL != mini->map_cmd) | 493 | if (NULL != mini->map_cmd) |
492 | { | 494 | { |
493 | /* took way too long, abort it! */ | 495 | /* took way too long, abort it! */ |
494 | GNUNET_OS_command_stop(mini->map_cmd); | 496 | GNUNET_OS_command_stop (mini->map_cmd); |
495 | mini->map_cmd = NULL; | 497 | mini->map_cmd = NULL; |
496 | ac = GNUNET_YES; | 498 | ac = GNUNET_YES; |
497 | } | 499 | } |
498 | if (NULL != mini->refresh_cmd) | 500 | if (NULL != mini->refresh_cmd) |
499 | { | 501 | { |
500 | /* took way too long, abort it! */ | 502 | /* took way too long, abort it! */ |
501 | GNUNET_OS_command_stop(mini->refresh_cmd); | 503 | GNUNET_OS_command_stop (mini->refresh_cmd); |
502 | mini->refresh_cmd = NULL; | 504 | mini->refresh_cmd = NULL; |
503 | ac = GNUNET_YES; | 505 | ac = GNUNET_YES; |
504 | } | 506 | } |
505 | mini->refresh_cmd = GNUNET_OS_command_run(&process_refresh_output, | 507 | mini->refresh_cmd = GNUNET_OS_command_run (&process_refresh_output, |
506 | mini, | 508 | mini, |
507 | MAP_TIMEOUT, | 509 | MAP_TIMEOUT, |
508 | "upnpc", | 510 | "upnpc", |
509 | "upnpc", | 511 | "upnpc", |
510 | "-l", | 512 | "-l", |
511 | NULL); | 513 | NULL); |
512 | if (GNUNET_YES == ac) | 514 | if (GNUNET_YES == ac) |
513 | mini->ac(mini->ac_cls, | 515 | mini->ac (mini->ac_cls, |
514 | GNUNET_SYSERR, | 516 | GNUNET_SYSERR, |
515 | NULL, | 517 | NULL, |
516 | 0, | 518 | 0, |
517 | GNUNET_NAT_ERROR_UPNPC_TIMEOUT); | 519 | GNUNET_NAT_ERROR_UPNPC_TIMEOUT); |
518 | } | 520 | } |
519 | 521 | ||
520 | 522 | ||
@@ -525,7 +527,7 @@ do_refresh(void *cls) | |||
525 | * @param line line of output, NULL at the end | 527 | * @param line line of output, NULL at the end |
526 | */ | 528 | */ |
527 | static void | 529 | static void |
528 | process_map_output(void *cls, const char *line) | 530 | process_map_output (void *cls, const char *line) |
529 | { | 531 | { |
530 | struct GNUNET_NAT_MiniHandle *mini = cls; | 532 | struct GNUNET_NAT_MiniHandle *mini = cls; |
531 | const char *ipaddr; | 533 | const char *ipaddr; |
@@ -534,51 +536,51 @@ process_map_output(void *cls, const char *line) | |||
534 | unsigned int port; | 536 | unsigned int port; |
535 | 537 | ||
536 | if (NULL == line) | 538 | if (NULL == line) |
537 | { | 539 | { |
538 | GNUNET_OS_command_stop(mini->map_cmd); | 540 | GNUNET_OS_command_stop (mini->map_cmd); |
539 | mini->map_cmd = NULL; | 541 | mini->map_cmd = NULL; |
540 | if (GNUNET_YES != mini->did_map) | 542 | if (GNUNET_YES != mini->did_map) |
541 | mini->ac(mini->ac_cls, | 543 | mini->ac (mini->ac_cls, |
542 | GNUNET_SYSERR, | 544 | GNUNET_SYSERR, |
543 | NULL, | 545 | NULL, |
544 | 0, | 546 | 0, |
545 | GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED); | 547 | GNUNET_NAT_ERROR_UPNPC_PORTMAP_FAILED); |
546 | if (NULL == mini->refresh_task) | 548 | if (NULL == mini->refresh_task) |
547 | mini->refresh_task = | 549 | mini->refresh_task = |
548 | GNUNET_SCHEDULER_add_delayed(MAP_REFRESH_FREQ, &do_refresh, mini); | 550 | GNUNET_SCHEDULER_add_delayed (MAP_REFRESH_FREQ, &do_refresh, mini); |
549 | return; | 551 | return; |
550 | } | 552 | } |
551 | /* | 553 | /* |
552 | * The upnpc output we're after looks like this: | 554 | * The upnpc output we're after looks like this: |
553 | * | 555 | * |
554 | * "external 87.123.42.204:3000 TCP is redirected to internal 192.168.2.150:3000" | 556 | * "external 87.123.42.204:3000 TCP is redirected to internal 192.168.2.150:3000" |
555 | */ | 557 | */ |
556 | if ((NULL == (ipaddr = strstr(line, " "))) || | 558 | if ((NULL == (ipaddr = strstr (line, " "))) || |
557 | (NULL == (pstr = strstr(ipaddr, ":"))) || | 559 | (NULL == (pstr = strstr (ipaddr, ":"))) || |
558 | (1 != sscanf(pstr + 1, "%u", &port))) | 560 | (1 != sscanf (pstr + 1, "%u", &port))) |
559 | { | 561 | { |
560 | return; /* skip line */ | 562 | return; /* skip line */ |
561 | } | 563 | } |
562 | ipa = GNUNET_strdup(ipaddr + 1); | 564 | ipa = GNUNET_strdup (ipaddr + 1); |
563 | strstr(ipa, ":")[0] = '\0'; | 565 | strstr (ipa, ":")[0] = '\0'; |
564 | if (1 != inet_pton(AF_INET, ipa, &mini->current_addr.sin_addr)) | 566 | if (1 != inet_pton (AF_INET, ipa, &mini->current_addr.sin_addr)) |
565 | { | 567 | { |
566 | GNUNET_free(ipa); | 568 | GNUNET_free (ipa); |
567 | return; /* skip line */ | 569 | return; /* skip line */ |
568 | } | 570 | } |
569 | GNUNET_free(ipa); | 571 | GNUNET_free (ipa); |
570 | 572 | ||
571 | mini->current_addr.sin_port = htons(port); | 573 | mini->current_addr.sin_port = htons (port); |
572 | mini->current_addr.sin_family = AF_INET; | 574 | mini->current_addr.sin_family = AF_INET; |
573 | #if HAVE_SOCKADDR_IN_SIN_LEN | 575 | #if HAVE_SOCKADDR_IN_SIN_LEN |
574 | mini->current_addr.sin_len = sizeof(struct sockaddr_in); | 576 | mini->current_addr.sin_len = sizeof(struct sockaddr_in); |
575 | #endif | 577 | #endif |
576 | mini->did_map = GNUNET_YES; | 578 | mini->did_map = GNUNET_YES; |
577 | mini->ac(mini->ac_cls, | 579 | mini->ac (mini->ac_cls, |
578 | GNUNET_YES, | 580 | GNUNET_YES, |
579 | (const struct sockaddr *)&mini->current_addr, | 581 | (const struct sockaddr *) &mini->current_addr, |
580 | sizeof(mini->current_addr), | 582 | sizeof(mini->current_addr), |
581 | GNUNET_NAT_ERROR_SUCCESS); | 583 | GNUNET_NAT_ERROR_SUCCESS); |
582 | } | 584 | } |
583 | 585 | ||
584 | 586 | ||
@@ -596,28 +598,28 @@ process_map_output(void *cls, const char *line) | |||
596 | * @return NULL on error (no 'upnpc' installed) | 598 | * @return NULL on error (no 'upnpc' installed) |
597 | */ | 599 | */ |
598 | struct GNUNET_NAT_MiniHandle * | 600 | struct GNUNET_NAT_MiniHandle * |
599 | GNUNET_NAT_mini_map_start(uint16_t port, | 601 | GNUNET_NAT_mini_map_start (uint16_t port, |
600 | int is_tcp, | 602 | int is_tcp, |
601 | GNUNET_NAT_MiniAddressCallback ac, | 603 | GNUNET_NAT_MiniAddressCallback ac, |
602 | void *ac_cls) | 604 | void *ac_cls) |
603 | { | 605 | { |
604 | struct GNUNET_NAT_MiniHandle *ret; | 606 | struct GNUNET_NAT_MiniHandle *ret; |
605 | 607 | ||
606 | if (GNUNET_SYSERR == GNUNET_OS_check_helper_binary("upnpc", GNUNET_NO, NULL)) | 608 | if (GNUNET_SYSERR == GNUNET_OS_check_helper_binary ("upnpc", GNUNET_NO, NULL)) |
607 | { | 609 | { |
608 | LOG(GNUNET_ERROR_TYPE_INFO, _("`upnpc' command not found\n")); | 610 | LOG (GNUNET_ERROR_TYPE_INFO, _ ("`upnpc' command not found\n")); |
609 | ac(ac_cls, GNUNET_SYSERR, NULL, 0, GNUNET_NAT_ERROR_UPNPC_NOT_FOUND); | 611 | ac (ac_cls, GNUNET_SYSERR, NULL, 0, GNUNET_NAT_ERROR_UPNPC_NOT_FOUND); |
610 | return NULL; | 612 | return NULL; |
611 | } | 613 | } |
612 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Running `upnpc' to install mapping\n"); | 614 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Running `upnpc' to install mapping\n"); |
613 | ret = GNUNET_new(struct GNUNET_NAT_MiniHandle); | 615 | ret = GNUNET_new (struct GNUNET_NAT_MiniHandle); |
614 | ret->ac = ac; | 616 | ret->ac = ac; |
615 | ret->ac_cls = ac_cls; | 617 | ret->ac_cls = ac_cls; |
616 | ret->is_tcp = is_tcp; | 618 | ret->is_tcp = is_tcp; |
617 | ret->port = port; | 619 | ret->port = port; |
618 | ret->refresh_task = | 620 | ret->refresh_task = |
619 | GNUNET_SCHEDULER_add_delayed(MAP_REFRESH_FREQ, &do_refresh, ret); | 621 | GNUNET_SCHEDULER_add_delayed (MAP_REFRESH_FREQ, &do_refresh, ret); |
620 | run_upnpc_r(ret); | 622 | run_upnpc_r (ret); |
621 | return ret; | 623 | return ret; |
622 | } | 624 | } |
623 | 625 | ||
@@ -629,18 +631,18 @@ GNUNET_NAT_mini_map_start(uint16_t port, | |||
629 | * @param line line of output, NULL at the end | 631 | * @param line line of output, NULL at the end |
630 | */ | 632 | */ |
631 | static void | 633 | static void |
632 | process_unmap_output(void *cls, const char *line) | 634 | process_unmap_output (void *cls, const char *line) |
633 | { | 635 | { |
634 | struct GNUNET_NAT_MiniHandle *mini = cls; | 636 | struct GNUNET_NAT_MiniHandle *mini = cls; |
635 | 637 | ||
636 | if (NULL == line) | 638 | if (NULL == line) |
637 | { | 639 | { |
638 | LOG(GNUNET_ERROR_TYPE_DEBUG, "UPnP unmap done\n"); | 640 | LOG (GNUNET_ERROR_TYPE_DEBUG, "UPnP unmap done\n"); |
639 | GNUNET_OS_command_stop(mini->unmap_cmd); | 641 | GNUNET_OS_command_stop (mini->unmap_cmd); |
640 | mini->unmap_cmd = NULL; | 642 | mini->unmap_cmd = NULL; |
641 | GNUNET_free(mini); | 643 | GNUNET_free (mini); |
642 | return; | 644 | return; |
643 | } | 645 | } |
644 | /* we don't really care about the output... */ | 646 | /* we don't really care about the output... */ |
645 | } | 647 | } |
646 | 648 | ||
@@ -654,54 +656,54 @@ process_unmap_output(void *cls, const char *line) | |||
654 | * @param mini the handle | 656 | * @param mini the handle |
655 | */ | 657 | */ |
656 | void | 658 | void |
657 | GNUNET_NAT_mini_map_stop(struct GNUNET_NAT_MiniHandle *mini) | 659 | GNUNET_NAT_mini_map_stop (struct GNUNET_NAT_MiniHandle *mini) |
658 | { | 660 | { |
659 | char pstr[6]; | 661 | char pstr[6]; |
660 | 662 | ||
661 | if (NULL != mini->refresh_task) | 663 | if (NULL != mini->refresh_task) |
662 | { | 664 | { |
663 | GNUNET_SCHEDULER_cancel(mini->refresh_task); | 665 | GNUNET_SCHEDULER_cancel (mini->refresh_task); |
664 | mini->refresh_task = NULL; | 666 | mini->refresh_task = NULL; |
665 | } | 667 | } |
666 | if (NULL != mini->refresh_cmd) | 668 | if (NULL != mini->refresh_cmd) |
667 | { | 669 | { |
668 | GNUNET_OS_command_stop(mini->refresh_cmd); | 670 | GNUNET_OS_command_stop (mini->refresh_cmd); |
669 | mini->refresh_cmd = NULL; | 671 | mini->refresh_cmd = NULL; |
670 | } | 672 | } |
671 | if (NULL != mini->map_cmd) | 673 | if (NULL != mini->map_cmd) |
672 | { | 674 | { |
673 | GNUNET_OS_command_stop(mini->map_cmd); | 675 | GNUNET_OS_command_stop (mini->map_cmd); |
674 | mini->map_cmd = NULL; | 676 | mini->map_cmd = NULL; |
675 | } | 677 | } |
676 | if (GNUNET_NO == mini->did_map) | 678 | if (GNUNET_NO == mini->did_map) |
677 | { | 679 | { |
678 | GNUNET_free(mini); | 680 | GNUNET_free (mini); |
679 | return; | 681 | return; |
680 | } | 682 | } |
681 | mini->ac(mini->ac_cls, | 683 | mini->ac (mini->ac_cls, |
682 | GNUNET_NO, | 684 | GNUNET_NO, |
683 | (const struct sockaddr *)&mini->current_addr, | 685 | (const struct sockaddr *) &mini->current_addr, |
684 | sizeof(mini->current_addr), | 686 | sizeof(mini->current_addr), |
685 | GNUNET_NAT_ERROR_SUCCESS); | 687 | GNUNET_NAT_ERROR_SUCCESS); |
686 | /* Note: oddly enough, deletion uses the external port whereas | 688 | /* Note: oddly enough, deletion uses the external port whereas |
687 | * addition uses the internal port; this rarely matters since they | 689 | * addition uses the internal port; this rarely matters since they |
688 | * often are the same, but it might... */ | 690 | * often are the same, but it might... */ |
689 | GNUNET_snprintf(pstr, | 691 | GNUNET_snprintf (pstr, |
690 | sizeof(pstr), | 692 | sizeof(pstr), |
691 | "%u", | 693 | "%u", |
692 | (unsigned int)ntohs(mini->current_addr.sin_port)); | 694 | (unsigned int) ntohs (mini->current_addr.sin_port)); |
693 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 695 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
694 | "Unmapping port %u with UPnP\n", | 696 | "Unmapping port %u with UPnP\n", |
695 | ntohs(mini->current_addr.sin_port)); | 697 | ntohs (mini->current_addr.sin_port)); |
696 | mini->unmap_cmd = GNUNET_OS_command_run(&process_unmap_output, | 698 | mini->unmap_cmd = GNUNET_OS_command_run (&process_unmap_output, |
697 | mini, | 699 | mini, |
698 | UNMAP_TIMEOUT, | 700 | UNMAP_TIMEOUT, |
699 | "upnpc", | 701 | "upnpc", |
700 | "upnpc", | 702 | "upnpc", |
701 | "-d", | 703 | "-d", |
702 | pstr, | 704 | pstr, |
703 | mini->is_tcp ? "tcp" : "udp", | 705 | mini->is_tcp ? "tcp" : "udp", |
704 | NULL); | 706 | NULL); |
705 | } | 707 | } |
706 | 708 | ||
707 | 709 | ||
diff --git a/src/nat/gnunet-service-nat_mini.h b/src/nat/gnunet-service-nat_mini.h index 031b8e935..dffc9758a 100644 --- a/src/nat/gnunet-service-nat_mini.h +++ b/src/nat/gnunet-service-nat_mini.h | |||
@@ -54,8 +54,8 @@ struct GNUNET_NAT_ExternalHandle; | |||
54 | * @return handle for cancellation (can only be used until @a cb is called), NULL on error | 54 | * @return handle for cancellation (can only be used until @a cb is called), NULL on error |
55 | */ | 55 | */ |
56 | struct GNUNET_NAT_ExternalHandle * | 56 | struct GNUNET_NAT_ExternalHandle * |
57 | GNUNET_NAT_mini_get_external_ipv4_(GNUNET_NAT_IPCallback cb, | 57 | GNUNET_NAT_mini_get_external_ipv4_ (GNUNET_NAT_IPCallback cb, |
58 | void *cb_cls); | 58 | void *cb_cls); |
59 | 59 | ||
60 | 60 | ||
61 | /** | 61 | /** |
@@ -64,7 +64,8 @@ GNUNET_NAT_mini_get_external_ipv4_(GNUNET_NAT_IPCallback cb, | |||
64 | * @param eh operation to cancel | 64 | * @param eh operation to cancel |
65 | */ | 65 | */ |
66 | void | 66 | void |
67 | GNUNET_NAT_mini_get_external_ipv4_cancel_(struct GNUNET_NAT_ExternalHandle *eh); | 67 | GNUNET_NAT_mini_get_external_ipv4_cancel_ (struct |
68 | GNUNET_NAT_ExternalHandle *eh); | ||
68 | 69 | ||
69 | 70 | ||
70 | /** | 71 | /** |
@@ -106,10 +107,10 @@ typedef void | |||
106 | * @return NULL on error | 107 | * @return NULL on error |
107 | */ | 108 | */ |
108 | struct GNUNET_NAT_MiniHandle * | 109 | struct GNUNET_NAT_MiniHandle * |
109 | GNUNET_NAT_mini_map_start(uint16_t port, | 110 | GNUNET_NAT_mini_map_start (uint16_t port, |
110 | int is_tcp, | 111 | int is_tcp, |
111 | GNUNET_NAT_MiniAddressCallback ac, | 112 | GNUNET_NAT_MiniAddressCallback ac, |
112 | void *ac_cls); | 113 | void *ac_cls); |
113 | 114 | ||
114 | 115 | ||
115 | /** | 116 | /** |
@@ -121,7 +122,7 @@ GNUNET_NAT_mini_map_start(uint16_t port, | |||
121 | * @param mini the handle | 122 | * @param mini the handle |
122 | */ | 123 | */ |
123 | void | 124 | void |
124 | GNUNET_NAT_mini_map_stop(struct GNUNET_NAT_MiniHandle *mini); | 125 | GNUNET_NAT_mini_map_stop (struct GNUNET_NAT_MiniHandle *mini); |
125 | 126 | ||
126 | 127 | ||
127 | #endif | 128 | #endif |
diff --git a/src/nat/gnunet-service-nat_stun.c b/src/nat/gnunet-service-nat_stun.c index d8b791d0a..8a5311254 100644 --- a/src/nat/gnunet-service-nat_stun.c +++ b/src/nat/gnunet-service-nat_stun.c | |||
@@ -40,14 +40,15 @@ | |||
40 | #include "gnunet_util_lib.h" | 40 | #include "gnunet_util_lib.h" |
41 | #include "nat_stun.h" | 41 | #include "nat_stun.h" |
42 | 42 | ||
43 | #define LOG(kind, ...) GNUNET_log_from(kind, "stun", __VA_ARGS__) | 43 | #define LOG(kind, ...) GNUNET_log_from (kind, "stun", __VA_ARGS__) |
44 | 44 | ||
45 | 45 | ||
46 | /** | 46 | /** |
47 | * Context for #stun_get_mapped(). | 47 | * Context for #stun_get_mapped(). |
48 | * Used to store state across processing attributes. | 48 | * Used to store state across processing attributes. |
49 | */ | 49 | */ |
50 | struct StunState { | 50 | struct StunState |
51 | { | ||
51 | uint16_t attr; | 52 | uint16_t attr; |
52 | }; | 53 | }; |
53 | 54 | ||
@@ -64,44 +65,44 @@ struct StunState { | |||
64 | * @return #GNUNET_OK if @a arg was initialized | 65 | * @return #GNUNET_OK if @a arg was initialized |
65 | */ | 66 | */ |
66 | static int | 67 | static int |
67 | stun_get_mapped(struct StunState *st, | 68 | stun_get_mapped (struct StunState *st, |
68 | const struct stun_attr *attr, | 69 | const struct stun_attr *attr, |
69 | uint32_t magic, | 70 | uint32_t magic, |
70 | struct sockaddr_in *arg) | 71 | struct sockaddr_in *arg) |
71 | { | 72 | { |
72 | const struct stun_addr *returned_addr; | 73 | const struct stun_addr *returned_addr; |
73 | struct sockaddr_in *sa = (struct sockaddr_in *)arg; | 74 | struct sockaddr_in *sa = (struct sockaddr_in *) arg; |
74 | uint16_t type = ntohs(attr->attr); | 75 | uint16_t type = ntohs (attr->attr); |
75 | 76 | ||
76 | switch (type) | 77 | switch (type) |
77 | { | 78 | { |
78 | case STUN_MAPPED_ADDRESS: | 79 | case STUN_MAPPED_ADDRESS: |
79 | if ((st->attr == STUN_XOR_MAPPED_ADDRESS) || | 80 | if ((st->attr == STUN_XOR_MAPPED_ADDRESS) || |
80 | (st->attr == STUN_MS_XOR_MAPPED_ADDRESS)) | 81 | (st->attr == STUN_MS_XOR_MAPPED_ADDRESS)) |
81 | return GNUNET_NO; | 82 | return GNUNET_NO; |
82 | magic = 0; | 83 | magic = 0; |
83 | break; | 84 | break; |
84 | 85 | ||
85 | case STUN_MS_XOR_MAPPED_ADDRESS: | 86 | case STUN_MS_XOR_MAPPED_ADDRESS: |
86 | if (st->attr == STUN_XOR_MAPPED_ADDRESS) | 87 | if (st->attr == STUN_XOR_MAPPED_ADDRESS) |
87 | return GNUNET_NO; | 88 | return GNUNET_NO; |
88 | break; | 89 | break; |
89 | 90 | ||
90 | case STUN_XOR_MAPPED_ADDRESS: | 91 | case STUN_XOR_MAPPED_ADDRESS: |
91 | break; | 92 | break; |
92 | 93 | ||
93 | default: | 94 | default: |
94 | return GNUNET_NO; | 95 | return GNUNET_NO; |
95 | } | 96 | } |
96 | 97 | ||
97 | if (ntohs(attr->len) < sizeof(struct stun_addr)) | 98 | if (ntohs (attr->len) < sizeof(struct stun_addr)) |
98 | return GNUNET_NO; | 99 | return GNUNET_NO; |
99 | returned_addr = (const struct stun_addr *)(attr + 1); | 100 | returned_addr = (const struct stun_addr *) (attr + 1); |
100 | if (AF_INET != returned_addr->family) | 101 | if (AF_INET != returned_addr->family) |
101 | return GNUNET_NO; | 102 | return GNUNET_NO; |
102 | st->attr = type; | 103 | st->attr = type; |
103 | sa->sin_family = AF_INET; | 104 | sa->sin_family = AF_INET; |
104 | sa->sin_port = returned_addr->port ^ htons(ntohl(magic) >> 16); | 105 | sa->sin_port = returned_addr->port ^ htons (ntohl (magic) >> 16); |
105 | sa->sin_addr.s_addr = returned_addr->addr ^ magic; | 106 | sa->sin_addr.s_addr = returned_addr->addr ^ magic; |
106 | return GNUNET_OK; | 107 | return GNUNET_OK; |
107 | } | 108 | } |
@@ -121,9 +122,9 @@ stun_get_mapped(struct StunState *st, | |||
121 | * #GNUNET_NO if the packet is invalid (not a stun packet) | 122 | * #GNUNET_NO if the packet is invalid (not a stun packet) |
122 | */ | 123 | */ |
123 | int | 124 | int |
124 | GNUNET_NAT_stun_handle_packet_(const void *data, | 125 | GNUNET_NAT_stun_handle_packet_ (const void *data, |
125 | size_t len, | 126 | size_t len, |
126 | struct sockaddr_in *arg) | 127 | struct sockaddr_in *arg) |
127 | { | 128 | { |
128 | const struct stun_header *hdr; | 129 | const struct stun_header *hdr; |
129 | const struct stun_attr *attr; | 130 | const struct stun_attr *attr; |
@@ -137,76 +138,76 @@ GNUNET_NAT_stun_handle_packet_(const void *data, | |||
137 | * while 'data' is advanced accordingly. | 138 | * while 'data' is advanced accordingly. |
138 | */ | 139 | */ |
139 | if (len < sizeof(struct stun_header)) | 140 | if (len < sizeof(struct stun_header)) |
140 | { | 141 | { |
141 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 142 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
142 | "Packet too short to be a STUN packet\n"); | 143 | "Packet too short to be a STUN packet\n"); |
143 | return GNUNET_NO; | 144 | return GNUNET_NO; |
144 | } | 145 | } |
145 | hdr = data; | 146 | hdr = data; |
146 | /* Skip header as it is already in hdr */ | 147 | /* Skip header as it is already in hdr */ |
147 | len -= sizeof(struct stun_header); | 148 | len -= sizeof(struct stun_header); |
148 | data += sizeof(struct stun_header); | 149 | data += sizeof(struct stun_header); |
149 | 150 | ||
150 | /* len as advertised in the message */ | 151 | /* len as advertised in the message */ |
151 | advertised_message_size = ntohs(hdr->msglen); | 152 | advertised_message_size = ntohs (hdr->msglen); |
152 | message_magic_cookie = ntohl(hdr->magic); | 153 | message_magic_cookie = ntohl (hdr->magic); |
153 | /* Compare if the cookie match */ | 154 | /* Compare if the cookie match */ |
154 | if (STUN_MAGIC_COOKIE != message_magic_cookie) | 155 | if (STUN_MAGIC_COOKIE != message_magic_cookie) |
155 | { | 156 | { |
156 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 157 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
157 | "Invalid magic cookie for STUN packet\n"); | 158 | "Invalid magic cookie for STUN packet\n"); |
158 | return GNUNET_NO; | 159 | return GNUNET_NO; |
159 | } | 160 | } |
160 | 161 | ||
161 | LOG(GNUNET_ERROR_TYPE_INFO, | 162 | LOG (GNUNET_ERROR_TYPE_INFO, |
162 | "STUN Packet, msg %s (%04x), length: %d\n", | 163 | "STUN Packet, msg %s (%04x), length: %d\n", |
163 | stun_msg2str(ntohs(hdr->msgtype)), | 164 | stun_msg2str (ntohs (hdr->msgtype)), |
164 | ntohs(hdr->msgtype), | 165 | ntohs (hdr->msgtype), |
165 | advertised_message_size); | 166 | advertised_message_size); |
166 | if (advertised_message_size > len) | 167 | if (advertised_message_size > len) |
167 | { | 168 | { |
168 | LOG(GNUNET_ERROR_TYPE_INFO, | 169 | LOG (GNUNET_ERROR_TYPE_INFO, |
169 | "Scrambled STUN packet length (got %d, expecting %d)\n", | 170 | "Scrambled STUN packet length (got %d, expecting %d)\n", |
170 | advertised_message_size, | 171 | advertised_message_size, |
171 | (int)len); | 172 | (int) len); |
172 | return GNUNET_NO; | 173 | return GNUNET_NO; |
173 | } | 174 | } |
174 | len = advertised_message_size; | 175 | len = advertised_message_size; |
175 | memset(&st, 0, sizeof(st)); | 176 | memset (&st, 0, sizeof(st)); |
176 | 177 | ||
177 | while (len > 0) | 178 | while (len > 0) |
179 | { | ||
180 | if (len < sizeof(struct stun_attr)) | ||
178 | { | 181 | { |
179 | if (len < sizeof(struct stun_attr)) | 182 | LOG (GNUNET_ERROR_TYPE_INFO, |
180 | { | 183 | "Attribute too short (got %d, expecting %d)\n", |
181 | LOG(GNUNET_ERROR_TYPE_INFO, | 184 | (int) len, |
182 | "Attribute too short (got %d, expecting %d)\n", | 185 | (int) sizeof(struct stun_attr)); |
183 | (int)len, | 186 | break; |
184 | (int)sizeof(struct stun_attr)); | 187 | } |
185 | break; | 188 | attr = (const struct stun_attr *) data; |
186 | } | 189 | |
187 | attr = (const struct stun_attr *)data; | 190 | /* compute total attribute length */ |
188 | 191 | advertised_message_size = ntohs (attr->len) + sizeof(struct stun_attr); | |
189 | /* compute total attribute length */ | 192 | |
190 | advertised_message_size = ntohs(attr->len) + sizeof(struct stun_attr); | 193 | /* Check if we still have space in our buffer */ |
191 | 194 | if (advertised_message_size > len) | |
192 | /* Check if we still have space in our buffer */ | 195 | { |
193 | if (advertised_message_size > len) | 196 | LOG (GNUNET_ERROR_TYPE_INFO, |
194 | { | 197 | "Inconsistent attribute (length %d exceeds remaining msg len %d)\n", |
195 | LOG(GNUNET_ERROR_TYPE_INFO, | 198 | advertised_message_size, |
196 | "Inconsistent attribute (length %d exceeds remaining msg len %d)\n", | 199 | (int) len); |
197 | advertised_message_size, | 200 | break; |
198 | (int)len); | ||
199 | break; | ||
200 | } | ||
201 | if (GNUNET_OK == | ||
202 | stun_get_mapped(&st, | ||
203 | attr, | ||
204 | hdr->magic, | ||
205 | arg)) | ||
206 | ret = GNUNET_OK; | ||
207 | data += advertised_message_size; | ||
208 | len -= advertised_message_size; | ||
209 | } | 201 | } |
202 | if (GNUNET_OK == | ||
203 | stun_get_mapped (&st, | ||
204 | attr, | ||
205 | hdr->magic, | ||
206 | arg)) | ||
207 | ret = GNUNET_OK; | ||
208 | data += advertised_message_size; | ||
209 | len -= advertised_message_size; | ||
210 | } | ||
210 | return ret; | 211 | return ret; |
211 | } | 212 | } |
212 | 213 | ||
diff --git a/src/nat/gnunet-service-nat_stun.h b/src/nat/gnunet-service-nat_stun.h index af6520fbf..912fc3b46 100644 --- a/src/nat/gnunet-service-nat_stun.h +++ b/src/nat/gnunet-service-nat_stun.h | |||
@@ -54,8 +54,8 @@ | |||
54 | * #GNUNET_NO if the packet is invalid (not a stun packet) | 54 | * #GNUNET_NO if the packet is invalid (not a stun packet) |
55 | */ | 55 | */ |
56 | int | 56 | int |
57 | GNUNET_NAT_stun_handle_packet_(const void *data, | 57 | GNUNET_NAT_stun_handle_packet_ (const void *data, |
58 | size_t len, | 58 | size_t len, |
59 | struct sockaddr_in *arg); | 59 | struct sockaddr_in *arg); |
60 | 60 | ||
61 | #endif | 61 | #endif |
diff --git a/src/nat/nat.h b/src/nat/nat.h index 62377435a..aac8db64c 100644 --- a/src/nat/nat.h +++ b/src/nat/nat.h | |||
@@ -36,7 +36,8 @@ GNUNET_NETWORK_STRUCT_BEGIN | |||
36 | * Request to test NAT traversal, sent to the gnunet-nat-server | 36 | * Request to test NAT traversal, sent to the gnunet-nat-server |
37 | * (not the service!). | 37 | * (not the service!). |
38 | */ | 38 | */ |
39 | struct GNUNET_NAT_TestMessage { | 39 | struct GNUNET_NAT_TestMessage |
40 | { | ||
40 | /** | 41 | /** |
41 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_TEST | 42 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_TEST |
42 | */ | 43 | */ |
@@ -68,7 +69,8 @@ struct GNUNET_NAT_TestMessage { | |||
68 | * Flags specifying the events this client would be | 69 | * Flags specifying the events this client would be |
69 | * interested in being told about. | 70 | * interested in being told about. |
70 | */ | 71 | */ |
71 | enum GNUNET_NAT_RegisterFlags { | 72 | enum GNUNET_NAT_RegisterFlags |
73 | { | ||
72 | /** | 74 | /** |
73 | * This client does not want any notifications. | 75 | * This client does not want any notifications. |
74 | */ | 76 | */ |
@@ -90,7 +92,8 @@ enum GNUNET_NAT_RegisterFlags { | |||
90 | /** | 92 | /** |
91 | * Message sent by a client to register with its addresses. | 93 | * Message sent by a client to register with its addresses. |
92 | */ | 94 | */ |
93 | struct GNUNET_NAT_RegisterMessage { | 95 | struct GNUNET_NAT_RegisterMessage |
96 | { | ||
94 | /** | 97 | /** |
95 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_REGISTER | 98 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_REGISTER |
96 | */ | 99 | */ |
@@ -129,7 +132,8 @@ struct GNUNET_NAT_RegisterMessage { | |||
129 | /** | 132 | /** |
130 | * Client telling the service to (possibly) handle a STUN message. | 133 | * Client telling the service to (possibly) handle a STUN message. |
131 | */ | 134 | */ |
132 | struct GNUNET_NAT_HandleStunMessage { | 135 | struct GNUNET_NAT_HandleStunMessage |
136 | { | ||
133 | /** | 137 | /** |
134 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_HANDLE_STUN | 138 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_HANDLE_STUN |
135 | */ | 139 | */ |
@@ -154,7 +158,8 @@ struct GNUNET_NAT_HandleStunMessage { | |||
154 | /** | 158 | /** |
155 | * Client asking the service to initiate connection reversal. | 159 | * Client asking the service to initiate connection reversal. |
156 | */ | 160 | */ |
157 | struct GNUNET_NAT_RequestConnectionReversalMessage { | 161 | struct GNUNET_NAT_RequestConnectionReversalMessage |
162 | { | ||
158 | /** | 163 | /** |
159 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL | 164 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL |
160 | */ | 165 | */ |
@@ -179,7 +184,8 @@ struct GNUNET_NAT_RequestConnectionReversalMessage { | |||
179 | /** | 184 | /** |
180 | * Service telling a client that connection reversal was requested. | 185 | * Service telling a client that connection reversal was requested. |
181 | */ | 186 | */ |
182 | struct GNUNET_NAT_ConnectionReversalRequestedMessage { | 187 | struct GNUNET_NAT_ConnectionReversalRequestedMessage |
188 | { | ||
183 | /** | 189 | /** |
184 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_CONNECTION_REVERSAL_REQUESTED | 190 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_CONNECTION_REVERSAL_REQUESTED |
185 | */ | 191 | */ |
@@ -193,7 +199,8 @@ struct GNUNET_NAT_ConnectionReversalRequestedMessage { | |||
193 | * Service notifying the client about changes in the set of | 199 | * Service notifying the client about changes in the set of |
194 | * addresses it has. | 200 | * addresses it has. |
195 | */ | 201 | */ |
196 | struct GNUNET_NAT_AddressChangeNotificationMessage { | 202 | struct GNUNET_NAT_AddressChangeNotificationMessage |
203 | { | ||
197 | /** | 204 | /** |
198 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE | 205 | * Header with type #GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE |
199 | */ | 206 | */ |
diff --git a/src/nat/nat_api.c b/src/nat/nat_api.c index 877589d85..c1125dc75 100644 --- a/src/nat/nat_api.c +++ b/src/nat/nat_api.c | |||
@@ -35,7 +35,8 @@ | |||
35 | /** | 35 | /** |
36 | * Entry in DLL of addresses of this peer. | 36 | * Entry in DLL of addresses of this peer. |
37 | */ | 37 | */ |
38 | struct AddrEntry { | 38 | struct AddrEntry |
39 | { | ||
39 | /** | 40 | /** |
40 | * DLL. | 41 | * DLL. |
41 | */ | 42 | */ |
@@ -67,7 +68,8 @@ struct AddrEntry { | |||
67 | /** | 68 | /** |
68 | * Handle for active NAT registrations. | 69 | * Handle for active NAT registrations. |
69 | */ | 70 | */ |
70 | struct GNUNET_NAT_Handle { | 71 | struct GNUNET_NAT_Handle |
72 | { | ||
71 | /** | 73 | /** |
72 | * Configuration we use. | 74 | * Configuration we use. |
73 | */ | 75 | */ |
@@ -126,7 +128,7 @@ struct GNUNET_NAT_Handle { | |||
126 | * @param cls our `struct GNUNET_NAT_Handle *` | 128 | * @param cls our `struct GNUNET_NAT_Handle *` |
127 | */ | 129 | */ |
128 | static void | 130 | static void |
129 | do_connect(void *cls); | 131 | do_connect (void *cls); |
130 | 132 | ||
131 | 133 | ||
132 | /** | 134 | /** |
@@ -135,29 +137,29 @@ do_connect(void *cls); | |||
135 | * @param nh handle to reconnect | 137 | * @param nh handle to reconnect |
136 | */ | 138 | */ |
137 | static void | 139 | static void |
138 | reconnect(struct GNUNET_NAT_Handle *nh) | 140 | reconnect (struct GNUNET_NAT_Handle *nh) |
139 | { | 141 | { |
140 | struct AddrEntry *ae; | 142 | struct AddrEntry *ae; |
141 | 143 | ||
142 | if (NULL != nh->mq) | 144 | if (NULL != nh->mq) |
143 | { | 145 | { |
144 | GNUNET_MQ_destroy(nh->mq); | 146 | GNUNET_MQ_destroy (nh->mq); |
145 | nh->mq = NULL; | 147 | nh->mq = NULL; |
146 | } | 148 | } |
147 | while (NULL != (ae = nh->ae_head)) | 149 | while (NULL != (ae = nh->ae_head)) |
148 | { | 150 | { |
149 | GNUNET_CONTAINER_DLL_remove(nh->ae_head, nh->ae_tail, ae); | 151 | GNUNET_CONTAINER_DLL_remove (nh->ae_head, nh->ae_tail, ae); |
150 | nh->address_callback(nh->callback_cls, | 152 | nh->address_callback (nh->callback_cls, |
151 | &ae->app_ctx, | 153 | &ae->app_ctx, |
152 | GNUNET_NO, | 154 | GNUNET_NO, |
153 | ae->ac, | 155 | ae->ac, |
154 | (const struct sockaddr *)&ae[1], | 156 | (const struct sockaddr *) &ae[1], |
155 | ae->addrlen); | 157 | ae->addrlen); |
156 | GNUNET_free(ae); | 158 | GNUNET_free (ae); |
157 | } | 159 | } |
158 | nh->reconnect_delay = GNUNET_TIME_STD_BACKOFF(nh->reconnect_delay); | 160 | nh->reconnect_delay = GNUNET_TIME_STD_BACKOFF (nh->reconnect_delay); |
159 | nh->reconnect_task = | 161 | nh->reconnect_task = |
160 | GNUNET_SCHEDULER_add_delayed(nh->reconnect_delay, &do_connect, nh); | 162 | GNUNET_SCHEDULER_add_delayed (nh->reconnect_delay, &do_connect, nh); |
161 | } | 163 | } |
162 | 164 | ||
163 | 165 | ||
@@ -169,15 +171,15 @@ reconnect(struct GNUNET_NAT_Handle *nh) | |||
169 | * @return #GNUNET_OK if @a crm is well-formed | 171 | * @return #GNUNET_OK if @a crm is well-formed |
170 | */ | 172 | */ |
171 | static int | 173 | static int |
172 | check_connection_reversal_request( | 174 | check_connection_reversal_request ( |
173 | void *cls, | 175 | void *cls, |
174 | const struct GNUNET_NAT_ConnectionReversalRequestedMessage *crm) | 176 | const struct GNUNET_NAT_ConnectionReversalRequestedMessage *crm) |
175 | { | 177 | { |
176 | if (ntohs(crm->header.size) != sizeof(*crm) + sizeof(struct sockaddr_in)) | 178 | if (ntohs (crm->header.size) != sizeof(*crm) + sizeof(struct sockaddr_in)) |
177 | { | 179 | { |
178 | GNUNET_break(0); | 180 | GNUNET_break (0); |
179 | return GNUNET_SYSERR; | 181 | return GNUNET_SYSERR; |
180 | } | 182 | } |
181 | return GNUNET_OK; | 183 | return GNUNET_OK; |
182 | } | 184 | } |
183 | 185 | ||
@@ -189,15 +191,15 @@ check_connection_reversal_request( | |||
189 | * @param crm the message | 191 | * @param crm the message |
190 | */ | 192 | */ |
191 | static void | 193 | static void |
192 | handle_connection_reversal_request( | 194 | handle_connection_reversal_request ( |
193 | void *cls, | 195 | void *cls, |
194 | const struct GNUNET_NAT_ConnectionReversalRequestedMessage *crm) | 196 | const struct GNUNET_NAT_ConnectionReversalRequestedMessage *crm) |
195 | { | 197 | { |
196 | struct GNUNET_NAT_Handle *nh = cls; | 198 | struct GNUNET_NAT_Handle *nh = cls; |
197 | 199 | ||
198 | nh->reversal_callback(nh->callback_cls, | 200 | nh->reversal_callback (nh->callback_cls, |
199 | (const struct sockaddr *)&crm[1], | 201 | (const struct sockaddr *) &crm[1], |
200 | sizeof(struct sockaddr_in)); | 202 | sizeof(struct sockaddr_in)); |
201 | } | 203 | } |
202 | 204 | ||
203 | 205 | ||
@@ -209,38 +211,38 @@ handle_connection_reversal_request( | |||
209 | * @return #GNUNET_OK if @a crm is well-formed | 211 | * @return #GNUNET_OK if @a crm is well-formed |
210 | */ | 212 | */ |
211 | static int | 213 | static int |
212 | check_address_change_notification( | 214 | check_address_change_notification ( |
213 | void *cls, | 215 | void *cls, |
214 | const struct GNUNET_NAT_AddressChangeNotificationMessage *acn) | 216 | const struct GNUNET_NAT_AddressChangeNotificationMessage *acn) |
215 | { | 217 | { |
216 | size_t alen = ntohs(acn->header.size) - sizeof(*acn); | 218 | size_t alen = ntohs (acn->header.size) - sizeof(*acn); |
217 | 219 | ||
218 | switch (alen) | 220 | switch (alen) |
219 | { | 221 | { |
220 | case sizeof(struct sockaddr_in): { | 222 | case sizeof(struct sockaddr_in): { |
221 | const struct sockaddr_in *s4 = (const struct sockaddr_in *)&acn[1]; | 223 | const struct sockaddr_in *s4 = (const struct sockaddr_in *) &acn[1]; |
222 | if (AF_INET != s4->sin_family) | 224 | if (AF_INET != s4->sin_family) |
223 | { | 225 | { |
224 | GNUNET_break(0); | 226 | GNUNET_break (0); |
225 | return GNUNET_SYSERR; | 227 | return GNUNET_SYSERR; |
226 | } | 228 | } |
227 | } | 229 | } |
228 | break; | 230 | break; |
229 | 231 | ||
230 | case sizeof(struct sockaddr_in6): { | 232 | case sizeof(struct sockaddr_in6): { |
231 | const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *)&acn[1]; | 233 | const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) &acn[1]; |
232 | if (AF_INET6 != s6->sin6_family) | 234 | if (AF_INET6 != s6->sin6_family) |
233 | { | 235 | { |
234 | GNUNET_break(0); | 236 | GNUNET_break (0); |
235 | return GNUNET_SYSERR; | 237 | return GNUNET_SYSERR; |
236 | } | 238 | } |
237 | } | 239 | } |
238 | break; | 240 | break; |
239 | 241 | ||
240 | default: | 242 | default: |
241 | GNUNET_break(0); | 243 | GNUNET_break (0); |
242 | return GNUNET_SYSERR; | 244 | return GNUNET_SYSERR; |
243 | } | 245 | } |
244 | return GNUNET_OK; | 246 | return GNUNET_OK; |
245 | } | 247 | } |
246 | 248 | ||
@@ -252,53 +254,53 @@ check_address_change_notification( | |||
252 | * @param acn the message | 254 | * @param acn the message |
253 | */ | 255 | */ |
254 | static void | 256 | static void |
255 | handle_address_change_notification( | 257 | handle_address_change_notification ( |
256 | void *cls, | 258 | void *cls, |
257 | const struct GNUNET_NAT_AddressChangeNotificationMessage *acn) | 259 | const struct GNUNET_NAT_AddressChangeNotificationMessage *acn) |
258 | { | 260 | { |
259 | struct GNUNET_NAT_Handle *nh = cls; | 261 | struct GNUNET_NAT_Handle *nh = cls; |
260 | size_t alen = ntohs(acn->header.size) - sizeof(*acn); | 262 | size_t alen = ntohs (acn->header.size) - sizeof(*acn); |
261 | const struct sockaddr *sa = (const struct sockaddr *)&acn[1]; | 263 | const struct sockaddr *sa = (const struct sockaddr *) &acn[1]; |
262 | enum GNUNET_NAT_AddressClass ac; | 264 | enum GNUNET_NAT_AddressClass ac; |
263 | struct AddrEntry *ae; | 265 | struct AddrEntry *ae; |
264 | 266 | ||
265 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 267 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
266 | "Received address change notification\n"); | 268 | "Received address change notification\n"); |
267 | ac = (enum GNUNET_NAT_AddressClass)ntohl(acn->addr_class); | 269 | ac = (enum GNUNET_NAT_AddressClass) ntohl (acn->addr_class); |
268 | if (GNUNET_YES == ntohl(acn->add_remove)) | 270 | if (GNUNET_YES == ntohl (acn->add_remove)) |
269 | { | 271 | { |
270 | ae = GNUNET_malloc(sizeof(*ae) + alen); | 272 | ae = GNUNET_malloc (sizeof(*ae) + alen); |
271 | ae->ac = ac; | 273 | ae->ac = ac; |
272 | ae->addrlen = alen; | 274 | ae->addrlen = alen; |
273 | GNUNET_memcpy(&ae[1], sa, alen); | 275 | GNUNET_memcpy (&ae[1], sa, alen); |
274 | GNUNET_CONTAINER_DLL_insert(nh->ae_head, nh->ae_tail, ae); | 276 | GNUNET_CONTAINER_DLL_insert (nh->ae_head, nh->ae_tail, ae); |
275 | nh->address_callback(nh->callback_cls, | 277 | nh->address_callback (nh->callback_cls, |
276 | &ae->app_ctx, | 278 | &ae->app_ctx, |
277 | ntohl(acn->add_remove), | 279 | ntohl (acn->add_remove), |
278 | ac, | 280 | ac, |
279 | sa, | 281 | sa, |
280 | alen); | 282 | alen); |
281 | } | 283 | } |
282 | else | 284 | else |
285 | { | ||
286 | for (ae = nh->ae_head; NULL != ae; ae = ae->next) | ||
287 | if ((ae->addrlen == alen) && (0 == memcmp (&ae[1], sa, alen))) | ||
288 | break; | ||
289 | if (NULL == ae) | ||
283 | { | 290 | { |
284 | for (ae = nh->ae_head; NULL != ae; ae = ae->next) | 291 | GNUNET_break (0); |
285 | if ((ae->addrlen == alen) && (0 == memcmp(&ae[1], sa, alen))) | 292 | reconnect (nh); |
286 | break; | 293 | return; |
287 | if (NULL == ae) | ||
288 | { | ||
289 | GNUNET_break(0); | ||
290 | reconnect(nh); | ||
291 | return; | ||
292 | } | ||
293 | GNUNET_CONTAINER_DLL_remove(nh->ae_head, nh->ae_tail, ae); | ||
294 | nh->address_callback(nh->callback_cls, | ||
295 | &ae->app_ctx, | ||
296 | ntohl(acn->add_remove), | ||
297 | ac, | ||
298 | sa, | ||
299 | alen); | ||
300 | GNUNET_free(ae); | ||
301 | } | 294 | } |
295 | GNUNET_CONTAINER_DLL_remove (nh->ae_head, nh->ae_tail, ae); | ||
296 | nh->address_callback (nh->callback_cls, | ||
297 | &ae->app_ctx, | ||
298 | ntohl (acn->add_remove), | ||
299 | ac, | ||
300 | sa, | ||
301 | alen); | ||
302 | GNUNET_free (ae); | ||
303 | } | ||
302 | } | 304 | } |
303 | 305 | ||
304 | 306 | ||
@@ -309,11 +311,11 @@ handle_address_change_notification( | |||
309 | * @param error details about the error | 311 | * @param error details about the error |
310 | */ | 312 | */ |
311 | static void | 313 | static void |
312 | mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | 314 | mq_error_handler (void *cls, enum GNUNET_MQ_Error error) |
313 | { | 315 | { |
314 | struct GNUNET_NAT_Handle *nh = cls; | 316 | struct GNUNET_NAT_Handle *nh = cls; |
315 | 317 | ||
316 | reconnect(nh); | 318 | reconnect (nh); |
317 | } | 319 | } |
318 | 320 | ||
319 | 321 | ||
@@ -323,32 +325,32 @@ mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | |||
323 | * @param cls our `struct GNUNET_NAT_Handle *` | 325 | * @param cls our `struct GNUNET_NAT_Handle *` |
324 | */ | 326 | */ |
325 | static void | 327 | static void |
326 | do_connect(void *cls) | 328 | do_connect (void *cls) |
327 | { | 329 | { |
328 | struct GNUNET_NAT_Handle *nh = cls; | 330 | struct GNUNET_NAT_Handle *nh = cls; |
329 | struct GNUNET_MQ_MessageHandler handlers[] = | 331 | struct GNUNET_MQ_MessageHandler handlers[] = |
330 | { GNUNET_MQ_hd_var_size(connection_reversal_request, | 332 | { GNUNET_MQ_hd_var_size (connection_reversal_request, |
331 | GNUNET_MESSAGE_TYPE_NAT_CONNECTION_REVERSAL_REQUESTED, | 333 | GNUNET_MESSAGE_TYPE_NAT_CONNECTION_REVERSAL_REQUESTED, |
332 | struct | 334 | struct |
333 | GNUNET_NAT_ConnectionReversalRequestedMessage, | 335 | GNUNET_NAT_ConnectionReversalRequestedMessage, |
334 | nh), | 336 | nh), |
335 | GNUNET_MQ_hd_var_size(address_change_notification, | 337 | GNUNET_MQ_hd_var_size (address_change_notification, |
336 | GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE, | 338 | GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE, |
337 | struct GNUNET_NAT_AddressChangeNotificationMessage, | 339 | struct GNUNET_NAT_AddressChangeNotificationMessage, |
338 | nh), | 340 | nh), |
339 | GNUNET_MQ_handler_end() }; | 341 | GNUNET_MQ_handler_end () }; |
340 | struct GNUNET_MQ_Envelope *env; | 342 | struct GNUNET_MQ_Envelope *env; |
341 | 343 | ||
342 | nh->reconnect_task = NULL; | 344 | nh->reconnect_task = NULL; |
343 | nh->mq = | 345 | nh->mq = |
344 | GNUNET_CLIENT_connect(nh->cfg, "nat", handlers, &mq_error_handler, nh); | 346 | GNUNET_CLIENT_connect (nh->cfg, "nat", handlers, &mq_error_handler, nh); |
345 | if (NULL == nh->mq) | 347 | if (NULL == nh->mq) |
346 | { | 348 | { |
347 | reconnect(nh); | 349 | reconnect (nh); |
348 | return; | 350 | return; |
349 | } | 351 | } |
350 | env = GNUNET_MQ_msg_copy(nh->reg); | 352 | env = GNUNET_MQ_msg_copy (nh->reg); |
351 | GNUNET_MQ_send(nh->mq, env); | 353 | GNUNET_MQ_send (nh->mq, env); |
352 | } | 354 | } |
353 | 355 | ||
354 | 356 | ||
@@ -373,15 +375,15 @@ do_connect(void *cls) | |||
373 | * @return NULL on error, otherwise handle that can be used to unregister | 375 | * @return NULL on error, otherwise handle that can be used to unregister |
374 | */ | 376 | */ |
375 | struct GNUNET_NAT_Handle * | 377 | struct GNUNET_NAT_Handle * |
376 | GNUNET_NAT_register(const struct GNUNET_CONFIGURATION_Handle *cfg, | 378 | GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg, |
377 | const char *config_section, | 379 | const char *config_section, |
378 | uint8_t proto, | 380 | uint8_t proto, |
379 | unsigned int num_addrs, | 381 | unsigned int num_addrs, |
380 | const struct sockaddr **addrs, | 382 | const struct sockaddr **addrs, |
381 | const socklen_t *addrlens, | 383 | const socklen_t *addrlens, |
382 | GNUNET_NAT_AddressCallback address_callback, | 384 | GNUNET_NAT_AddressCallback address_callback, |
383 | GNUNET_NAT_ReversalCallback reversal_callback, | 385 | GNUNET_NAT_ReversalCallback reversal_callback, |
384 | void *callback_cls) | 386 | void *callback_cls) |
385 | { | 387 | { |
386 | struct GNUNET_NAT_Handle *nh; | 388 | struct GNUNET_NAT_Handle *nh; |
387 | struct GNUNET_NAT_RegisterMessage *rm; | 389 | struct GNUNET_NAT_RegisterMessage *rm; |
@@ -392,75 +394,75 @@ GNUNET_NAT_register(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
392 | len = 0; | 394 | len = 0; |
393 | for (unsigned int i = 0; i < num_addrs; i++) | 395 | for (unsigned int i = 0; i < num_addrs; i++) |
394 | len += addrlens[i]; | 396 | len += addrlens[i]; |
395 | str_len = strlen(config_section) + 1; | 397 | str_len = strlen (config_section) + 1; |
396 | len += str_len; | 398 | len += str_len; |
397 | if ((len > GNUNET_MAX_MESSAGE_SIZE - sizeof(*rm)) || | 399 | if ((len > GNUNET_MAX_MESSAGE_SIZE - sizeof(*rm)) || |
398 | (num_addrs > UINT16_MAX)) | 400 | (num_addrs > UINT16_MAX)) |
399 | { | 401 | { |
400 | GNUNET_break(0); | 402 | GNUNET_break (0); |
401 | return NULL; | 403 | return NULL; |
402 | } | 404 | } |
403 | rm = GNUNET_malloc(sizeof(*rm) + len); | 405 | rm = GNUNET_malloc (sizeof(*rm) + len); |
404 | rm->header.size = htons(sizeof(*rm) + len); | 406 | rm->header.size = htons (sizeof(*rm) + len); |
405 | rm->header.type = htons(GNUNET_MESSAGE_TYPE_NAT_REGISTER); | 407 | rm->header.type = htons (GNUNET_MESSAGE_TYPE_NAT_REGISTER); |
406 | rm->flags = GNUNET_NAT_RF_NONE; | 408 | rm->flags = GNUNET_NAT_RF_NONE; |
407 | if (NULL != address_callback) | 409 | if (NULL != address_callback) |
408 | rm->flags |= GNUNET_NAT_RF_ADDRESSES; | 410 | rm->flags |= GNUNET_NAT_RF_ADDRESSES; |
409 | if (NULL != reversal_callback) | 411 | if (NULL != reversal_callback) |
410 | rm->flags |= GNUNET_NAT_RF_REVERSAL; | 412 | rm->flags |= GNUNET_NAT_RF_REVERSAL; |
411 | rm->proto = proto; | 413 | rm->proto = proto; |
412 | rm->str_len = htons(str_len); | 414 | rm->str_len = htons (str_len); |
413 | rm->num_addrs = htons((uint16_t)num_addrs); | 415 | rm->num_addrs = htons ((uint16_t) num_addrs); |
414 | off = (char *)&rm[1]; | 416 | off = (char *) &rm[1]; |
415 | for (unsigned int i = 0; i < num_addrs; i++) | 417 | for (unsigned int i = 0; i < num_addrs; i++) |
418 | { | ||
419 | switch (addrs[i]->sa_family) | ||
416 | { | 420 | { |
417 | switch (addrs[i]->sa_family) | 421 | case AF_INET: |
418 | { | 422 | if (sizeof(struct sockaddr_in) != addrlens[i]) |
419 | case AF_INET: | 423 | { |
420 | if (sizeof(struct sockaddr_in) != addrlens[i]) | 424 | GNUNET_break (0); |
421 | { | 425 | GNUNET_free (rm); |
422 | GNUNET_break(0); | 426 | return NULL; |
423 | GNUNET_free(rm); | 427 | } |
424 | return NULL; | 428 | break; |
425 | } | 429 | |
426 | break; | 430 | case AF_INET6: |
427 | 431 | if (sizeof(struct sockaddr_in6) != addrlens[i]) | |
428 | case AF_INET6: | 432 | { |
429 | if (sizeof(struct sockaddr_in6) != addrlens[i]) | 433 | GNUNET_break (0); |
430 | { | 434 | GNUNET_free (rm); |
431 | GNUNET_break(0); | 435 | return NULL; |
432 | GNUNET_free(rm); | 436 | } |
433 | return NULL; | 437 | break; |
434 | } | ||
435 | break; | ||
436 | 438 | ||
437 | #if AF_UNIX | 439 | #if AF_UNIX |
438 | case AF_UNIX: | 440 | case AF_UNIX: |
439 | if (sizeof(struct sockaddr_un) != addrlens[i]) | 441 | if (sizeof(struct sockaddr_un) != addrlens[i]) |
440 | { | 442 | { |
441 | GNUNET_break(0); | 443 | GNUNET_break (0); |
442 | GNUNET_free(rm); | 444 | GNUNET_free (rm); |
443 | return NULL; | 445 | return NULL; |
444 | } | 446 | } |
445 | break; | 447 | break; |
446 | #endif | 448 | #endif |
447 | default: | 449 | default: |
448 | GNUNET_break(0); | 450 | GNUNET_break (0); |
449 | GNUNET_free(rm); | 451 | GNUNET_free (rm); |
450 | return NULL; | 452 | return NULL; |
451 | } | ||
452 | GNUNET_memcpy(off, addrs[i], addrlens[i]); | ||
453 | off += addrlens[i]; | ||
454 | } | 453 | } |
455 | GNUNET_memcpy(off, config_section, str_len); | 454 | GNUNET_memcpy (off, addrs[i], addrlens[i]); |
455 | off += addrlens[i]; | ||
456 | } | ||
457 | GNUNET_memcpy (off, config_section, str_len); | ||
456 | 458 | ||
457 | nh = GNUNET_new(struct GNUNET_NAT_Handle); | 459 | nh = GNUNET_new (struct GNUNET_NAT_Handle); |
458 | nh->reg = &rm->header; | 460 | nh->reg = &rm->header; |
459 | nh->cfg = cfg; | 461 | nh->cfg = cfg; |
460 | nh->address_callback = address_callback; | 462 | nh->address_callback = address_callback; |
461 | nh->reversal_callback = reversal_callback; | 463 | nh->reversal_callback = reversal_callback; |
462 | nh->callback_cls = callback_cls; | 464 | nh->callback_cls = callback_cls; |
463 | do_connect(nh); | 465 | do_connect (nh); |
464 | return nh; | 466 | return nh; |
465 | } | 467 | } |
466 | 468 | ||
@@ -474,7 +476,7 @@ GNUNET_NAT_register(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
474 | * #GNUNET_NO if the packet is invalid (not a stun packet) | 476 | * #GNUNET_NO if the packet is invalid (not a stun packet) |
475 | */ | 477 | */ |
476 | static int | 478 | static int |
477 | test_stun_packet(const void *data, size_t len) | 479 | test_stun_packet (const void *data, size_t len) |
478 | { | 480 | { |
479 | const struct stun_header *hdr; | 481 | const struct stun_header *hdr; |
480 | const struct stun_attr *attr; | 482 | const struct stun_attr *attr; |
@@ -486,70 +488,70 @@ test_stun_packet(const void *data, size_t len) | |||
486 | * while 'data' is advanced accordingly. | 488 | * while 'data' is advanced accordingly. |
487 | */ | 489 | */ |
488 | if (len < sizeof(struct stun_header)) | 490 | if (len < sizeof(struct stun_header)) |
489 | { | 491 | { |
490 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 492 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
491 | "STUN packet too short (only %d, wanting at least %d)\n", | 493 | "STUN packet too short (only %d, wanting at least %d)\n", |
492 | (int)len, | 494 | (int) len, |
493 | (int)sizeof(struct stun_header)); | 495 | (int) sizeof(struct stun_header)); |
494 | return GNUNET_NO; | 496 | return GNUNET_NO; |
495 | } | 497 | } |
496 | hdr = (const struct stun_header *)data; | 498 | hdr = (const struct stun_header *) data; |
497 | /* Skip header as it is already in hdr */ | 499 | /* Skip header as it is already in hdr */ |
498 | len -= sizeof(struct stun_header); | 500 | len -= sizeof(struct stun_header); |
499 | data += sizeof(struct stun_header); | 501 | data += sizeof(struct stun_header); |
500 | 502 | ||
501 | /* len as advertised in the message */ | 503 | /* len as advertised in the message */ |
502 | advertised_message_size = ntohs(hdr->msglen); | 504 | advertised_message_size = ntohs (hdr->msglen); |
503 | 505 | ||
504 | message_magic_cookie = ntohl(hdr->magic); | 506 | message_magic_cookie = ntohl (hdr->magic); |
505 | /* Compare if the cookie match */ | 507 | /* Compare if the cookie match */ |
506 | if (STUN_MAGIC_COOKIE != message_magic_cookie) | 508 | if (STUN_MAGIC_COOKIE != message_magic_cookie) |
507 | { | 509 | { |
508 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Invalid magic cookie for STUN\n"); | 510 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Invalid magic cookie for STUN\n"); |
509 | return GNUNET_NO; | 511 | return GNUNET_NO; |
510 | } | 512 | } |
511 | 513 | ||
512 | if (advertised_message_size > len) | 514 | if (advertised_message_size > len) |
515 | { | ||
516 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
517 | "Scrambled STUN packet length (got %d, expecting %d)\n", | ||
518 | advertised_message_size, | ||
519 | (int) len); | ||
520 | return GNUNET_NO; | ||
521 | } | ||
522 | len = advertised_message_size; | ||
523 | while (len > 0) | ||
524 | { | ||
525 | if (len < sizeof(struct stun_attr)) | ||
513 | { | 526 | { |
514 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 527 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
515 | "Scrambled STUN packet length (got %d, expecting %d)\n", | 528 | "Attribute too short in STUN packet (got %d, expecting %d)\n", |
516 | advertised_message_size, | 529 | (int) len, |
517 | (int)len); | 530 | (int) sizeof(struct stun_attr)); |
518 | return GNUNET_NO; | 531 | return GNUNET_NO; |
519 | } | 532 | } |
520 | len = advertised_message_size; | 533 | attr = (const struct stun_attr *) data; |
521 | while (len > 0) | 534 | |
535 | /* compute total attribute length */ | ||
536 | advertised_message_size = ntohs (attr->len) + sizeof(struct stun_attr); | ||
537 | |||
538 | /* Check if we still have space in our buffer */ | ||
539 | if (advertised_message_size > len) | ||
522 | { | 540 | { |
523 | if (len < sizeof(struct stun_attr)) | 541 | GNUNET_log ( |
524 | { | 542 | GNUNET_ERROR_TYPE_DEBUG, |
525 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 543 | "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", |
526 | "Attribute too short in STUN packet (got %d, expecting %d)\n", | 544 | advertised_message_size, |
527 | (int)len, | 545 | (int) len); |
528 | (int)sizeof(struct stun_attr)); | 546 | return GNUNET_NO; |
529 | return GNUNET_NO; | ||
530 | } | ||
531 | attr = (const struct stun_attr *)data; | ||
532 | |||
533 | /* compute total attribute length */ | ||
534 | advertised_message_size = ntohs(attr->len) + sizeof(struct stun_attr); | ||
535 | |||
536 | /* Check if we still have space in our buffer */ | ||
537 | if (advertised_message_size > len) | ||
538 | { | ||
539 | GNUNET_log( | ||
540 | GNUNET_ERROR_TYPE_DEBUG, | ||
541 | "Inconsistent Attribute (length %d exceeds remaining msg len %d)\n", | ||
542 | advertised_message_size, | ||
543 | (int)len); | ||
544 | return GNUNET_NO; | ||
545 | } | ||
546 | data += advertised_message_size; | ||
547 | len -= advertised_message_size; | ||
548 | } | 547 | } |
549 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 548 | data += advertised_message_size; |
550 | "STUN Packet, msg %04x, length: %d\n", | 549 | len -= advertised_message_size; |
551 | ntohs(hdr->msgtype), | 550 | } |
552 | advertised_message_size); | 551 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
552 | "STUN Packet, msg %04x, length: %d\n", | ||
553 | ntohs (hdr->msgtype), | ||
554 | advertised_message_size); | ||
553 | return GNUNET_OK; | 555 | return GNUNET_OK; |
554 | } | 556 | } |
555 | 557 | ||
@@ -578,30 +580,30 @@ test_stun_packet(const void *data, size_t len) | |||
578 | * #GNUNET_SYSERR on internal error handling the packet | 580 | * #GNUNET_SYSERR on internal error handling the packet |
579 | */ | 581 | */ |
580 | int | 582 | int |
581 | GNUNET_NAT_stun_handle_packet(struct GNUNET_NAT_Handle *nh, | 583 | GNUNET_NAT_stun_handle_packet (struct GNUNET_NAT_Handle *nh, |
582 | const struct sockaddr *sender_addr, | 584 | const struct sockaddr *sender_addr, |
583 | size_t sender_addr_len, | 585 | size_t sender_addr_len, |
584 | const void *data, | 586 | const void *data, |
585 | size_t data_size) | 587 | size_t data_size) |
586 | { | 588 | { |
587 | struct GNUNET_MQ_Envelope *env; | 589 | struct GNUNET_MQ_Envelope *env; |
588 | struct GNUNET_NAT_HandleStunMessage *hsn; | 590 | struct GNUNET_NAT_HandleStunMessage *hsn; |
589 | char *buf; | 591 | char *buf; |
590 | 592 | ||
591 | if (GNUNET_YES != test_stun_packet(data, data_size)) | 593 | if (GNUNET_YES != test_stun_packet (data, data_size)) |
592 | return GNUNET_NO; | 594 | return GNUNET_NO; |
593 | if (NULL == nh->mq) | 595 | if (NULL == nh->mq) |
594 | return GNUNET_SYSERR; | 596 | return GNUNET_SYSERR; |
595 | env = GNUNET_MQ_msg_extra(hsn, | 597 | env = GNUNET_MQ_msg_extra (hsn, |
596 | data_size + sender_addr_len, | 598 | data_size + sender_addr_len, |
597 | GNUNET_MESSAGE_TYPE_NAT_HANDLE_STUN); | 599 | GNUNET_MESSAGE_TYPE_NAT_HANDLE_STUN); |
598 | hsn->sender_addr_size = htons((uint16_t)sender_addr_len); | 600 | hsn->sender_addr_size = htons ((uint16_t) sender_addr_len); |
599 | hsn->payload_size = htons((uint16_t)data_size); | 601 | hsn->payload_size = htons ((uint16_t) data_size); |
600 | buf = (char *)&hsn[1]; | 602 | buf = (char *) &hsn[1]; |
601 | GNUNET_memcpy(buf, sender_addr, sender_addr_len); | 603 | GNUNET_memcpy (buf, sender_addr, sender_addr_len); |
602 | buf += sender_addr_len; | 604 | buf += sender_addr_len; |
603 | GNUNET_memcpy(buf, data, data_size); | 605 | GNUNET_memcpy (buf, data, data_size); |
604 | GNUNET_MQ_send(nh->mq, env); | 606 | GNUNET_MQ_send (nh->mq, env); |
605 | return GNUNET_OK; | 607 | return GNUNET_OK; |
606 | } | 608 | } |
607 | 609 | ||
@@ -620,20 +622,20 @@ GNUNET_NAT_stun_handle_packet(struct GNUNET_NAT_Handle *nh, | |||
620 | * #GNUNET_SYSERR if the address is malformed | 622 | * #GNUNET_SYSERR if the address is malformed |
621 | */ | 623 | */ |
622 | int | 624 | int |
623 | GNUNET_NAT_test_address(struct GNUNET_NAT_Handle *nh, | 625 | GNUNET_NAT_test_address (struct GNUNET_NAT_Handle *nh, |
624 | const void *addr, | 626 | const void *addr, |
625 | socklen_t addrlen) | 627 | socklen_t addrlen) |
626 | { | 628 | { |
627 | struct AddrEntry *ae; | 629 | struct AddrEntry *ae; |
628 | 630 | ||
629 | if ((addrlen != sizeof(struct sockaddr_in)) && | 631 | if ((addrlen != sizeof(struct sockaddr_in)) && |
630 | (addrlen != sizeof(struct sockaddr_in6))) | 632 | (addrlen != sizeof(struct sockaddr_in6))) |
631 | { | 633 | { |
632 | GNUNET_break(0); | 634 | GNUNET_break (0); |
633 | return GNUNET_SYSERR; | 635 | return GNUNET_SYSERR; |
634 | } | 636 | } |
635 | for (ae = nh->ae_head; NULL != ae; ae = ae->next) | 637 | for (ae = nh->ae_head; NULL != ae; ae = ae->next) |
636 | if ((addrlen == ae->addrlen) && (0 == memcmp(addr, &ae[1], addrlen))) | 638 | if ((addrlen == ae->addrlen) && (0 == memcmp (addr, &ae[1], addrlen))) |
637 | return GNUNET_YES; | 639 | return GNUNET_YES; |
638 | return GNUNET_NO; | 640 | return GNUNET_NO; |
639 | } | 641 | } |
@@ -652,9 +654,9 @@ GNUNET_NAT_test_address(struct GNUNET_NAT_Handle *nh, | |||
652 | * #GNUNET_OK otherwise (presumably in progress) | 654 | * #GNUNET_OK otherwise (presumably in progress) |
653 | */ | 655 | */ |
654 | int | 656 | int |
655 | GNUNET_NAT_request_reversal(struct GNUNET_NAT_Handle *nh, | 657 | GNUNET_NAT_request_reversal (struct GNUNET_NAT_Handle *nh, |
656 | const struct sockaddr_in *local_sa, | 658 | const struct sockaddr_in *local_sa, |
657 | const struct sockaddr_in *remote_sa) | 659 | const struct sockaddr_in *remote_sa) |
658 | { | 660 | { |
659 | struct GNUNET_MQ_Envelope *env; | 661 | struct GNUNET_MQ_Envelope *env; |
660 | struct GNUNET_NAT_RequestConnectionReversalMessage *req; | 662 | struct GNUNET_NAT_RequestConnectionReversalMessage *req; |
@@ -662,19 +664,19 @@ GNUNET_NAT_request_reversal(struct GNUNET_NAT_Handle *nh, | |||
662 | 664 | ||
663 | if (NULL == nh->mq) | 665 | if (NULL == nh->mq) |
664 | return GNUNET_SYSERR; | 666 | return GNUNET_SYSERR; |
665 | GNUNET_break(AF_INET == local_sa->sin_family); | 667 | GNUNET_break (AF_INET == local_sa->sin_family); |
666 | GNUNET_break(AF_INET == remote_sa->sin_family); | 668 | GNUNET_break (AF_INET == remote_sa->sin_family); |
667 | env = | 669 | env = |
668 | GNUNET_MQ_msg_extra(req, | 670 | GNUNET_MQ_msg_extra (req, |
669 | 2 * sizeof(struct sockaddr_in), | 671 | 2 * sizeof(struct sockaddr_in), |
670 | GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL); | 672 | GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL); |
671 | req->local_addr_size = htons(sizeof(struct sockaddr_in)); | 673 | req->local_addr_size = htons (sizeof(struct sockaddr_in)); |
672 | req->remote_addr_size = htons(sizeof(struct sockaddr_in)); | 674 | req->remote_addr_size = htons (sizeof(struct sockaddr_in)); |
673 | buf = (char *)&req[1]; | 675 | buf = (char *) &req[1]; |
674 | GNUNET_memcpy(buf, local_sa, sizeof(struct sockaddr_in)); | 676 | GNUNET_memcpy (buf, local_sa, sizeof(struct sockaddr_in)); |
675 | buf += sizeof(struct sockaddr_in); | 677 | buf += sizeof(struct sockaddr_in); |
676 | GNUNET_memcpy(buf, remote_sa, sizeof(struct sockaddr_in)); | 678 | GNUNET_memcpy (buf, remote_sa, sizeof(struct sockaddr_in)); |
677 | GNUNET_MQ_send(nh->mq, env); | 679 | GNUNET_MQ_send (nh->mq, env); |
678 | return GNUNET_OK; | 680 | return GNUNET_OK; |
679 | } | 681 | } |
680 | 682 | ||
@@ -687,20 +689,20 @@ GNUNET_NAT_request_reversal(struct GNUNET_NAT_Handle *nh, | |||
687 | * @param nh the handle to stop | 689 | * @param nh the handle to stop |
688 | */ | 690 | */ |
689 | void | 691 | void |
690 | GNUNET_NAT_unregister(struct GNUNET_NAT_Handle *nh) | 692 | GNUNET_NAT_unregister (struct GNUNET_NAT_Handle *nh) |
691 | { | 693 | { |
692 | if (NULL != nh->mq) | 694 | if (NULL != nh->mq) |
693 | { | 695 | { |
694 | GNUNET_MQ_destroy(nh->mq); | 696 | GNUNET_MQ_destroy (nh->mq); |
695 | nh->mq = NULL; | 697 | nh->mq = NULL; |
696 | } | 698 | } |
697 | if (NULL != nh->reconnect_task) | 699 | if (NULL != nh->reconnect_task) |
698 | { | 700 | { |
699 | GNUNET_SCHEDULER_cancel(nh->reconnect_task); | 701 | GNUNET_SCHEDULER_cancel (nh->reconnect_task); |
700 | nh->reconnect_task = NULL; | 702 | nh->reconnect_task = NULL; |
701 | } | 703 | } |
702 | GNUNET_free(nh->reg); | 704 | GNUNET_free (nh->reg); |
703 | GNUNET_free(nh); | 705 | GNUNET_free (nh); |
704 | } | 706 | } |
705 | 707 | ||
706 | 708 | ||
diff --git a/src/nat/nat_api_stun.c b/src/nat/nat_api_stun.c index 0f8694867..461dae1f5 100644 --- a/src/nat/nat_api_stun.c +++ b/src/nat/nat_api_stun.c | |||
@@ -43,9 +43,9 @@ | |||
43 | 43 | ||
44 | #include "nat_stun.h" | 44 | #include "nat_stun.h" |
45 | 45 | ||
46 | #define LOG(kind, ...) GNUNET_log_from(kind, "stun", __VA_ARGS__) | 46 | #define LOG(kind, ...) GNUNET_log_from (kind, "stun", __VA_ARGS__) |
47 | 47 | ||
48 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15) | 48 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15) |
49 | 49 | ||
50 | 50 | ||
51 | /** | 51 | /** |
@@ -53,7 +53,8 @@ | |||
53 | * the request prior to the timeout or successful execution. Also | 53 | * the request prior to the timeout or successful execution. Also |
54 | * used to track our internal state for the request. | 54 | * used to track our internal state for the request. |
55 | */ | 55 | */ |
56 | struct GNUNET_NAT_STUN_Handle { | 56 | struct GNUNET_NAT_STUN_Handle |
57 | { | ||
57 | /** | 58 | /** |
58 | * Handle to a pending DNS lookup request. | 59 | * Handle to a pending DNS lookup request. |
59 | */ | 60 | */ |
@@ -99,11 +100,12 @@ struct GNUNET_NAT_STUN_Handle { | |||
99 | * @return message in a STUN compatible format | 100 | * @return message in a STUN compatible format |
100 | */ | 101 | */ |
101 | static int | 102 | static int |
102 | encode_message(enum StunClasses msg_class, | 103 | encode_message (enum StunClasses msg_class, |
103 | enum StunMethods method) | 104 | enum StunMethods method) |
104 | { | 105 | { |
105 | return ((msg_class & 1) << 4) | ((msg_class & 2) << 7) | | 106 | return ((msg_class & 1) << 4) | ((msg_class & 2) << 7) |
106 | (method & 0x000f) | ((method & 0x0070) << 1) | ((method & 0x0f800) << 2); | 107 | | (method & 0x000f) | ((method & 0x0070) << 1) | ((method & 0x0f800) |
108 | << 2); | ||
107 | } | 109 | } |
108 | 110 | ||
109 | 111 | ||
@@ -113,12 +115,12 @@ encode_message(enum StunClasses msg_class, | |||
113 | * @param req, stun header to be filled | 115 | * @param req, stun header to be filled |
114 | */ | 116 | */ |
115 | static void | 117 | static void |
116 | generate_request_id(struct stun_header *req) | 118 | generate_request_id (struct stun_header *req) |
117 | { | 119 | { |
118 | req->magic = htonl(STUN_MAGIC_COOKIE); | 120 | req->magic = htonl (STUN_MAGIC_COOKIE); |
119 | for (unsigned int x = 0; x < 3; x++) | 121 | for (unsigned int x = 0; x < 3; x++) |
120 | req->id.id[x] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, | 122 | req->id.id[x] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, |
121 | UINT32_MAX); | 123 | UINT32_MAX); |
122 | } | 124 | } |
123 | 125 | ||
124 | 126 | ||
@@ -130,67 +132,67 @@ generate_request_id(struct stun_header *req) | |||
130 | * @param addrlen length of @a addr | 132 | * @param addrlen length of @a addr |
131 | */ | 133 | */ |
132 | static void | 134 | static void |
133 | stun_dns_callback(void *cls, | 135 | stun_dns_callback (void *cls, |
134 | const struct sockaddr *addr, | 136 | const struct sockaddr *addr, |
135 | socklen_t addrlen) | 137 | socklen_t addrlen) |
136 | { | 138 | { |
137 | struct GNUNET_NAT_STUN_Handle *rh = cls; | 139 | struct GNUNET_NAT_STUN_Handle *rh = cls; |
138 | struct stun_header req; | 140 | struct stun_header req; |
139 | struct sockaddr_in server; | 141 | struct sockaddr_in server; |
140 | 142 | ||
141 | if (NULL == addr) | 143 | if (NULL == addr) |
144 | { | ||
145 | rh->dns_active = NULL; | ||
146 | if (GNUNET_NO == rh->dns_success) | ||
147 | { | ||
148 | LOG (GNUNET_ERROR_TYPE_INFO, | ||
149 | "Error resolving host %s\n", | ||
150 | rh->stun_server); | ||
151 | rh->cb (rh->cb_cls, | ||
152 | GNUNET_NAT_ERROR_NOT_ONLINE); | ||
153 | } | ||
154 | else if (GNUNET_SYSERR == rh->dns_success) | ||
142 | { | 155 | { |
143 | rh->dns_active = NULL; | 156 | rh->cb (rh->cb_cls, |
144 | if (GNUNET_NO == rh->dns_success) | 157 | GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR); |
145 | { | ||
146 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
147 | "Error resolving host %s\n", | ||
148 | rh->stun_server); | ||
149 | rh->cb(rh->cb_cls, | ||
150 | GNUNET_NAT_ERROR_NOT_ONLINE); | ||
151 | } | ||
152 | else if (GNUNET_SYSERR == rh->dns_success) | ||
153 | { | ||
154 | rh->cb(rh->cb_cls, | ||
155 | GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR); | ||
156 | } | ||
157 | else | ||
158 | { | ||
159 | rh->cb(rh->cb_cls, | ||
160 | GNUNET_NAT_ERROR_SUCCESS); | ||
161 | } | ||
162 | GNUNET_NAT_stun_make_request_cancel(rh); | ||
163 | return; | ||
164 | } | 158 | } |
159 | else | ||
160 | { | ||
161 | rh->cb (rh->cb_cls, | ||
162 | GNUNET_NAT_ERROR_SUCCESS); | ||
163 | } | ||
164 | GNUNET_NAT_stun_make_request_cancel (rh); | ||
165 | return; | ||
166 | } | ||
165 | 167 | ||
166 | rh->dns_success = GNUNET_YES; | 168 | rh->dns_success = GNUNET_YES; |
167 | memset(&server, 0, sizeof(server)); | 169 | memset (&server, 0, sizeof(server)); |
168 | server.sin_family = AF_INET; | 170 | server.sin_family = AF_INET; |
169 | server.sin_addr = ((struct sockaddr_in *)addr)->sin_addr; | 171 | server.sin_addr = ((struct sockaddr_in *) addr)->sin_addr; |
170 | server.sin_port = htons(rh->stun_port); | 172 | server.sin_port = htons (rh->stun_port); |
171 | #if HAVE_SOCKADDR_IN_SIN_LEN | 173 | #if HAVE_SOCKADDR_IN_SIN_LEN |
172 | server.sin_len = (u_char)sizeof(struct sockaddr_in); | 174 | server.sin_len = (u_char) sizeof(struct sockaddr_in); |
173 | #endif | 175 | #endif |
174 | 176 | ||
175 | /* Craft the simplest possible STUN packet. A request binding */ | 177 | /* Craft the simplest possible STUN packet. A request binding */ |
176 | generate_request_id(&req); | 178 | generate_request_id (&req); |
177 | req.msglen = htons(0); | 179 | req.msglen = htons (0); |
178 | req.msgtype = htons(encode_message(STUN_REQUEST, | 180 | req.msgtype = htons (encode_message (STUN_REQUEST, |
179 | STUN_BINDING)); | 181 | STUN_BINDING)); |
180 | 182 | ||
181 | /* Send the packet */ | 183 | /* Send the packet */ |
182 | if (-1 == | 184 | if (-1 == |
183 | GNUNET_NETWORK_socket_sendto(rh->sock, | 185 | GNUNET_NETWORK_socket_sendto (rh->sock, |
184 | &req, | 186 | &req, |
185 | sizeof(req), | 187 | sizeof(req), |
186 | (const struct sockaddr *)&server, | 188 | (const struct sockaddr *) &server, |
187 | sizeof(server))) | 189 | sizeof(server))) |
188 | { | 190 | { |
189 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, | 191 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, |
190 | "sendto"); | 192 | "sendto"); |
191 | rh->dns_success = GNUNET_SYSERR; | 193 | rh->dns_success = GNUNET_SYSERR; |
192 | return; | 194 | return; |
193 | } | 195 | } |
194 | } | 196 | } |
195 | 197 | ||
196 | 198 | ||
@@ -206,31 +208,31 @@ stun_dns_callback(void *cls, | |||
206 | * @return NULL on error | 208 | * @return NULL on error |
207 | */ | 209 | */ |
208 | struct GNUNET_NAT_STUN_Handle * | 210 | struct GNUNET_NAT_STUN_Handle * |
209 | GNUNET_NAT_stun_make_request(const char *server, | 211 | GNUNET_NAT_stun_make_request (const char *server, |
210 | uint16_t port, | 212 | uint16_t port, |
211 | struct GNUNET_NETWORK_Handle *sock, | 213 | struct GNUNET_NETWORK_Handle *sock, |
212 | GNUNET_NAT_TestCallback cb, | 214 | GNUNET_NAT_TestCallback cb, |
213 | void *cb_cls) | 215 | void *cb_cls) |
214 | { | 216 | { |
215 | struct GNUNET_NAT_STUN_Handle *rh; | 217 | struct GNUNET_NAT_STUN_Handle *rh; |
216 | 218 | ||
217 | rh = GNUNET_new(struct GNUNET_NAT_STUN_Handle); | 219 | rh = GNUNET_new (struct GNUNET_NAT_STUN_Handle); |
218 | rh->sock = sock; | 220 | rh->sock = sock; |
219 | rh->cb = cb; | 221 | rh->cb = cb; |
220 | rh->cb_cls = cb_cls; | 222 | rh->cb_cls = cb_cls; |
221 | rh->stun_server = GNUNET_strdup(server); | 223 | rh->stun_server = GNUNET_strdup (server); |
222 | rh->stun_port = port; | 224 | rh->stun_port = port; |
223 | rh->dns_success = GNUNET_NO; | 225 | rh->dns_success = GNUNET_NO; |
224 | rh->dns_active = GNUNET_RESOLVER_ip_get(rh->stun_server, | 226 | rh->dns_active = GNUNET_RESOLVER_ip_get (rh->stun_server, |
225 | AF_INET, | 227 | AF_INET, |
226 | TIMEOUT, | 228 | TIMEOUT, |
227 | &stun_dns_callback, | 229 | &stun_dns_callback, |
228 | rh); | 230 | rh); |
229 | if (NULL == rh->dns_active) | 231 | if (NULL == rh->dns_active) |
230 | { | 232 | { |
231 | GNUNET_NAT_stun_make_request_cancel(rh); | 233 | GNUNET_NAT_stun_make_request_cancel (rh); |
232 | return NULL; | 234 | return NULL; |
233 | } | 235 | } |
234 | return rh; | 236 | return rh; |
235 | } | 237 | } |
236 | 238 | ||
@@ -242,15 +244,15 @@ GNUNET_NAT_stun_make_request(const char *server, | |||
242 | * @param rh request to cancel | 244 | * @param rh request to cancel |
243 | */ | 245 | */ |
244 | void | 246 | void |
245 | GNUNET_NAT_stun_make_request_cancel(struct GNUNET_NAT_STUN_Handle *rh) | 247 | GNUNET_NAT_stun_make_request_cancel (struct GNUNET_NAT_STUN_Handle *rh) |
246 | { | 248 | { |
247 | if (NULL != rh->dns_active) | 249 | if (NULL != rh->dns_active) |
248 | { | 250 | { |
249 | GNUNET_RESOLVER_request_cancel(rh->dns_active); | 251 | GNUNET_RESOLVER_request_cancel (rh->dns_active); |
250 | rh->dns_active = NULL; | 252 | rh->dns_active = NULL; |
251 | } | 253 | } |
252 | GNUNET_free(rh->stun_server); | 254 | GNUNET_free (rh->stun_server); |
253 | GNUNET_free(rh); | 255 | GNUNET_free (rh); |
254 | } | 256 | } |
255 | 257 | ||
256 | 258 | ||
diff --git a/src/nat/nat_stun.h b/src/nat/nat_stun.h index 85b177271..86b4bd0cb 100644 --- a/src/nat/nat_stun.h +++ b/src/nat/nat_stun.h | |||
@@ -33,12 +33,14 @@ | |||
33 | 33 | ||
34 | #define STUN_MAGIC_COOKIE 0x2112A442 | 34 | #define STUN_MAGIC_COOKIE 0x2112A442 |
35 | 35 | ||
36 | typedef struct { | 36 | typedef struct |
37 | { | ||
37 | uint32_t id[3]; | 38 | uint32_t id[3]; |
38 | } GNUNET_PACKED stun_trans_id; | 39 | } GNUNET_PACKED stun_trans_id; |
39 | 40 | ||
40 | 41 | ||
41 | struct stun_header { | 42 | struct stun_header |
43 | { | ||
42 | uint16_t msgtype; | 44 | uint16_t msgtype; |
43 | uint16_t msglen; | 45 | uint16_t msglen; |
44 | uint32_t magic; | 46 | uint32_t magic; |
@@ -46,7 +48,8 @@ struct stun_header { | |||
46 | } GNUNET_PACKED; | 48 | } GNUNET_PACKED; |
47 | 49 | ||
48 | 50 | ||
49 | struct stun_attr { | 51 | struct stun_attr |
52 | { | ||
50 | uint16_t attr; | 53 | uint16_t attr; |
51 | uint16_t len; | 54 | uint16_t len; |
52 | } GNUNET_PACKED; | 55 | } GNUNET_PACKED; |
@@ -55,7 +58,8 @@ struct stun_attr { | |||
55 | /** | 58 | /** |
56 | * The format normally used for addresses carried by STUN messages. | 59 | * The format normally used for addresses carried by STUN messages. |
57 | */ | 60 | */ |
58 | struct stun_addr { | 61 | struct stun_addr |
62 | { | ||
59 | uint8_t unused; | 63 | uint8_t unused; |
60 | 64 | ||
61 | /** | 65 | /** |
@@ -78,7 +82,8 @@ struct stun_addr { | |||
78 | /** | 82 | /** |
79 | * STUN message classes | 83 | * STUN message classes |
80 | */ | 84 | */ |
81 | enum StunClasses { | 85 | enum StunClasses |
86 | { | ||
82 | INVALID_CLASS = 0, | 87 | INVALID_CLASS = 0, |
83 | STUN_REQUEST = 0x0000, | 88 | STUN_REQUEST = 0x0000, |
84 | STUN_INDICATION = 0x0001, | 89 | STUN_INDICATION = 0x0001, |
@@ -86,7 +91,8 @@ enum StunClasses { | |||
86 | STUN_ERROR_RESPONSE = 0x0003 | 91 | STUN_ERROR_RESPONSE = 0x0003 |
87 | }; | 92 | }; |
88 | 93 | ||
89 | enum StunMethods { | 94 | enum StunMethods |
95 | { | ||
90 | INVALID_METHOD = 0, | 96 | INVALID_METHOD = 0, |
91 | STUN_BINDING = 0x0001, | 97 | STUN_BINDING = 0x0001, |
92 | STUN_SHARED_SECRET = 0x0002, | 98 | STUN_SHARED_SECRET = 0x0002, |
@@ -103,7 +109,8 @@ enum StunMethods { | |||
103 | * Basic attribute types in stun messages. | 109 | * Basic attribute types in stun messages. |
104 | * Messages can also contain custom attributes (codes above 0x7fff) | 110 | * Messages can also contain custom attributes (codes above 0x7fff) |
105 | */ | 111 | */ |
106 | enum StunAttributes { | 112 | enum StunAttributes |
113 | { | ||
107 | STUN_MAPPED_ADDRESS = 0x0001, | 114 | STUN_MAPPED_ADDRESS = 0x0001, |
108 | STUN_RESPONSE_ADDRESS = 0x0002, | 115 | STUN_RESPONSE_ADDRESS = 0x0002, |
109 | STUN_CHANGE_ADDRESS = 0x0003, | 116 | STUN_CHANGE_ADDRESS = 0x0003, |
@@ -133,10 +140,10 @@ enum StunAttributes { | |||
133 | * @return the converted StunClass | 140 | * @return the converted StunClass |
134 | */ | 141 | */ |
135 | static enum StunClasses | 142 | static enum StunClasses |
136 | decode_class(int msg) | 143 | decode_class (int msg) |
137 | { | 144 | { |
138 | /* Sorry for the magic, but this maps the class according to rfc5245 */ | 145 | /* Sorry for the magic, but this maps the class according to rfc5245 */ |
139 | return (enum StunClasses)((msg & 0x0010) >> 4) | ((msg & 0x0100) >> 7); | 146 | return (enum StunClasses) ((msg & 0x0010) >> 4) | ((msg & 0x0100) >> 7); |
140 | } | 147 | } |
141 | 148 | ||
142 | 149 | ||
@@ -147,9 +154,11 @@ decode_class(int msg) | |||
147 | * @return the converted StunMethod | 154 | * @return the converted StunMethod |
148 | */ | 155 | */ |
149 | static enum StunMethods | 156 | static enum StunMethods |
150 | decode_method(int msg) | 157 | decode_method (int msg) |
151 | { | 158 | { |
152 | return (enum StunMethods)(msg & 0x000f) | ((msg & 0x00e0) >> 1) | ((msg & 0x3e00) >> 2); | 159 | return (enum StunMethods) (msg & 0x000f) | ((msg & 0x00e0) >> 1) | ((msg |
160 | & 0x3e00) | ||
161 | >> 2); | ||
153 | } | 162 | } |
154 | 163 | ||
155 | 164 | ||
@@ -161,9 +170,10 @@ decode_method(int msg) | |||
161 | */ | 170 | */ |
162 | GNUNET_UNUSED | 171 | GNUNET_UNUSED |
163 | static const char * | 172 | static const char * |
164 | stun_msg2str(int msg) | 173 | stun_msg2str (int msg) |
165 | { | 174 | { |
166 | static const struct { | 175 | static const struct |
176 | { | ||
167 | enum StunClasses value; | 177 | enum StunClasses value; |
168 | const char *name; | 178 | const char *name; |
169 | } classes[] = { | 179 | } classes[] = { |
@@ -173,7 +183,8 @@ stun_msg2str(int msg) | |||
173 | { STUN_ERROR_RESPONSE, "Error Response" }, | 183 | { STUN_ERROR_RESPONSE, "Error Response" }, |
174 | { INVALID_CLASS, NULL } | 184 | { INVALID_CLASS, NULL } |
175 | }; | 185 | }; |
176 | static const struct { | 186 | static const struct |
187 | { | ||
177 | enum StunMethods value; | 188 | enum StunMethods value; |
178 | const char *name; | 189 | const char *name; |
179 | } methods[] = { | 190 | } methods[] = { |
@@ -186,25 +197,25 @@ stun_msg2str(int msg) | |||
186 | enum StunClasses cvalue; | 197 | enum StunClasses cvalue; |
187 | enum StunMethods mvalue; | 198 | enum StunMethods mvalue; |
188 | 199 | ||
189 | cvalue = decode_class(msg); | 200 | cvalue = decode_class (msg); |
190 | for (unsigned int i = 0; classes[i].name; i++) | 201 | for (unsigned int i = 0; classes[i].name; i++) |
191 | if (classes[i].value == cvalue) | 202 | if (classes[i].value == cvalue) |
192 | { | 203 | { |
193 | msg_class = classes[i].name; | 204 | msg_class = classes[i].name; |
194 | break; | 205 | break; |
195 | } | 206 | } |
196 | mvalue = decode_method(msg); | 207 | mvalue = decode_method (msg); |
197 | for (unsigned int i = 0; methods[i].name; i++) | 208 | for (unsigned int i = 0; methods[i].name; i++) |
198 | if (methods[i].value == mvalue) | 209 | if (methods[i].value == mvalue) |
199 | { | 210 | { |
200 | method = methods[i].name; | 211 | method = methods[i].name; |
201 | break; | 212 | break; |
202 | } | 213 | } |
203 | GNUNET_snprintf(result, | 214 | GNUNET_snprintf (result, |
204 | sizeof(result), | 215 | sizeof(result), |
205 | "%s %s", | 216 | "%s %s", |
206 | method ? : "Unknown Method", | 217 | method ? : "Unknown Method", |
207 | msg_class ? : "Unknown Class Message"); | 218 | msg_class ? : "Unknown Class Message"); |
208 | return result; | 219 | return result; |
209 | } | 220 | } |
210 | 221 | ||
@@ -217,9 +228,10 @@ stun_msg2str(int msg) | |||
217 | */ | 228 | */ |
218 | GNUNET_UNUSED | 229 | GNUNET_UNUSED |
219 | static const char * | 230 | static const char * |
220 | stun_attr2str(enum StunAttributes msg) | 231 | stun_attr2str (enum StunAttributes msg) |
221 | { | 232 | { |
222 | static const struct { | 233 | static const struct |
234 | { | ||
223 | enum StunAttributes value; | 235 | enum StunAttributes value; |
224 | const char *name; | 236 | const char *name; |
225 | } attrs[] = { | 237 | } attrs[] = { |
diff --git a/src/nat/test_nat.c b/src/nat/test_nat.c index 5758f63b9..f04cf5669 100644 --- a/src/nat/test_nat.c +++ b/src/nat/test_nat.c | |||
@@ -43,7 +43,7 @@ | |||
43 | /** | 43 | /** |
44 | * Time to wait before stopping NAT, in seconds | 44 | * Time to wait before stopping NAT, in seconds |
45 | */ | 45 | */ |
46 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5) | 46 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) |
47 | 47 | ||
48 | 48 | ||
49 | /** | 49 | /** |
@@ -51,15 +51,15 @@ | |||
51 | * believes to be valid for the transport. | 51 | * believes to be valid for the transport. |
52 | */ | 52 | */ |
53 | static void | 53 | static void |
54 | addr_callback(void *cls, int add_remove, const struct sockaddr *addr, | 54 | addr_callback (void *cls, int add_remove, const struct sockaddr *addr, |
55 | socklen_t addrlen) | 55 | socklen_t addrlen) |
56 | { | 56 | { |
57 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 57 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
58 | "Address changed: %s `%s' (%u bytes)\n", | 58 | "Address changed: %s `%s' (%u bytes)\n", |
59 | add_remove == GNUNET_YES ? "added" : "removed", | 59 | add_remove == GNUNET_YES ? "added" : "removed", |
60 | GNUNET_a2s(addr, | 60 | GNUNET_a2s (addr, |
61 | addrlen), | 61 | addrlen), |
62 | (unsigned int)addrlen); | 62 | (unsigned int) addrlen); |
63 | } | 63 | } |
64 | 64 | ||
65 | 65 | ||
@@ -67,17 +67,18 @@ addr_callback(void *cls, int add_remove, const struct sockaddr *addr, | |||
67 | * Function that terminates the test. | 67 | * Function that terminates the test. |
68 | */ | 68 | */ |
69 | static void | 69 | static void |
70 | stop(void *cls) | 70 | stop (void *cls) |
71 | { | 71 | { |
72 | struct GNUNET_NAT_Handle *nat = cls; | 72 | struct GNUNET_NAT_Handle *nat = cls; |
73 | 73 | ||
74 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 74 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
75 | "Stopping NAT and quitting...\n"); | 75 | "Stopping NAT and quitting...\n"); |
76 | GNUNET_NAT_unregister(nat); | 76 | GNUNET_NAT_unregister (nat); |
77 | } | 77 | } |
78 | 78 | ||
79 | 79 | ||
80 | struct addr_cls { | 80 | struct addr_cls |
81 | { | ||
81 | struct sockaddr *addr; | 82 | struct sockaddr *addr; |
82 | socklen_t addrlen; | 83 | socklen_t addrlen; |
83 | }; | 84 | }; |
@@ -95,21 +96,21 @@ struct addr_cls { | |||
95 | * @return #GNUNET_OK to continue iterating | 96 | * @return #GNUNET_OK to continue iterating |
96 | */ | 97 | */ |
97 | static int | 98 | static int |
98 | process_if(void *cls, | 99 | process_if (void *cls, |
99 | const char *name, | 100 | const char *name, |
100 | int isDefault, | 101 | int isDefault, |
101 | const struct sockaddr *addr, | 102 | const struct sockaddr *addr, |
102 | const struct sockaddr *broadcast_addr, | 103 | const struct sockaddr *broadcast_addr, |
103 | const struct sockaddr *netmask, | 104 | const struct sockaddr *netmask, |
104 | socklen_t addrlen) | 105 | socklen_t addrlen) |
105 | { | 106 | { |
106 | struct addr_cls *data = cls; | 107 | struct addr_cls *data = cls; |
107 | 108 | ||
108 | if (addr == NULL) | 109 | if (addr == NULL) |
109 | return GNUNET_OK; | 110 | return GNUNET_OK; |
110 | GNUNET_free_non_null(data->addr); | 111 | GNUNET_free_non_null (data->addr); |
111 | data->addr = GNUNET_malloc(addrlen); | 112 | data->addr = GNUNET_malloc (addrlen); |
112 | GNUNET_memcpy(data->addr, addr, addrlen); | 113 | GNUNET_memcpy (data->addr, addr, addrlen); |
113 | data->addrlen = addrlen; | 114 | data->addrlen = addrlen; |
114 | if (isDefault) | 115 | if (isDefault) |
115 | return GNUNET_SYSERR; | 116 | return GNUNET_SYSERR; |
@@ -121,44 +122,44 @@ process_if(void *cls, | |||
121 | * Main function run with scheduler. | 122 | * Main function run with scheduler. |
122 | */ | 123 | */ |
123 | static void | 124 | static void |
124 | run(void *cls, | 125 | run (void *cls, |
125 | char *const *args, | 126 | char *const *args, |
126 | const char *cfgfile, | 127 | const char *cfgfile, |
127 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 128 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
128 | { | 129 | { |
129 | struct GNUNET_NAT_Handle *nat; | 130 | struct GNUNET_NAT_Handle *nat; |
130 | struct addr_cls data; | 131 | struct addr_cls data; |
131 | struct sockaddr *addr; | 132 | struct sockaddr *addr; |
132 | 133 | ||
133 | data.addr = NULL; | 134 | data.addr = NULL; |
134 | GNUNET_OS_network_interfaces_list(process_if, &data); | 135 | GNUNET_OS_network_interfaces_list (process_if, &data); |
135 | if (NULL == data.addr) | 136 | if (NULL == data.addr) |
136 | { | 137 | { |
137 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 138 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
138 | "Could not find a valid interface address!\n"); | 139 | "Could not find a valid interface address!\n"); |
139 | exit(77); /* marks test as skipped */ | 140 | exit (77); /* marks test as skipped */ |
140 | } | 141 | } |
141 | addr = data.addr; | 142 | addr = data.addr; |
142 | GNUNET_assert(addr->sa_family == AF_INET || addr->sa_family == AF_INET6); | 143 | GNUNET_assert (addr->sa_family == AF_INET || addr->sa_family == AF_INET6); |
143 | if (addr->sa_family == AF_INET) | 144 | if (addr->sa_family == AF_INET) |
144 | ((struct sockaddr_in *)addr)->sin_port = htons(2086); | 145 | ((struct sockaddr_in *) addr)->sin_port = htons (2086); |
145 | else | 146 | else |
146 | ((struct sockaddr_in6 *)addr)->sin6_port = htons(2086); | 147 | ((struct sockaddr_in6 *) addr)->sin6_port = htons (2086); |
147 | 148 | ||
148 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 149 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
149 | "Requesting NAT redirection from address %s...\n", | 150 | "Requesting NAT redirection from address %s...\n", |
150 | GNUNET_a2s(addr, data.addrlen)); | 151 | GNUNET_a2s (addr, data.addrlen)); |
151 | 152 | ||
152 | nat = GNUNET_NAT_register(cfg, GNUNET_YES /* tcp */, | 153 | nat = GNUNET_NAT_register (cfg, GNUNET_YES /* tcp */, |
153 | 2086, 1, (const struct sockaddr **)&addr, | 154 | 2086, 1, (const struct sockaddr **) &addr, |
154 | &data.addrlen, &addr_callback, NULL, NULL, NULL); | 155 | &data.addrlen, &addr_callback, NULL, NULL, NULL); |
155 | GNUNET_free(addr); | 156 | GNUNET_free (addr); |
156 | GNUNET_SCHEDULER_add_delayed(TIMEOUT, &stop, nat); | 157 | GNUNET_SCHEDULER_add_delayed (TIMEOUT, &stop, nat); |
157 | } | 158 | } |
158 | 159 | ||
159 | 160 | ||
160 | int | 161 | int |
161 | main(int argc, char *const argv[]) | 162 | main (int argc, char *const argv[]) |
162 | { | 163 | { |
163 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 164 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
164 | GNUNET_GETOPT_OPTION_END | 165 | GNUNET_GETOPT_OPTION_END |
@@ -171,19 +172,19 @@ main(int argc, char *const argv[]) | |||
171 | NULL | 172 | NULL |
172 | }; | 173 | }; |
173 | 174 | ||
174 | GNUNET_log_setup("test-nat", | 175 | GNUNET_log_setup ("test-nat", |
175 | "WARNING", | 176 | "WARNING", |
176 | NULL); | 177 | NULL); |
177 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 178 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
178 | "Testing NAT library, timeout set to %s\n", | 179 | "Testing NAT library, timeout set to %s\n", |
179 | GNUNET_STRINGS_relative_time_to_string(TIMEOUT, | 180 | GNUNET_STRINGS_relative_time_to_string (TIMEOUT, |
180 | GNUNET_YES)); | 181 | GNUNET_YES)); |
181 | GNUNET_PROGRAM_run(3, | 182 | GNUNET_PROGRAM_run (3, |
182 | argv_prog, | 183 | argv_prog, |
183 | "test-nat", | 184 | "test-nat", |
184 | "nohelp", | 185 | "nohelp", |
185 | options, | 186 | options, |
186 | &run, NULL); | 187 | &run, NULL); |
187 | return 0; | 188 | return 0; |
188 | } | 189 | } |
189 | 190 | ||
diff --git a/src/nat/test_nat_mini.c b/src/nat/test_nat_mini.c index 09231d8ec..49c801571 100644 --- a/src/nat/test_nat_mini.c +++ b/src/nat/test_nat_mini.c | |||
@@ -35,31 +35,31 @@ | |||
35 | #include "gnunet_nat_lib.h" | 35 | #include "gnunet_nat_lib.h" |
36 | 36 | ||
37 | /* Time to wait before stopping NAT, in seconds */ | 37 | /* Time to wait before stopping NAT, in seconds */ |
38 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5) | 38 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) |
39 | 39 | ||
40 | /** | 40 | /** |
41 | * Function called on each address that the NAT service | 41 | * Function called on each address that the NAT service |
42 | * believes to be valid for the transport. | 42 | * believes to be valid for the transport. |
43 | */ | 43 | */ |
44 | static void | 44 | static void |
45 | addr_callback(void *cls, int add_remove, | 45 | addr_callback (void *cls, int add_remove, |
46 | const struct sockaddr *addr, | 46 | const struct sockaddr *addr, |
47 | socklen_t addrlen, | 47 | socklen_t addrlen, |
48 | enum GNUNET_NAT_StatusCode ret) | 48 | enum GNUNET_NAT_StatusCode ret) |
49 | { | 49 | { |
50 | if (GNUNET_NAT_ERROR_SUCCESS == ret) | 50 | if (GNUNET_NAT_ERROR_SUCCESS == ret) |
51 | { | 51 | { |
52 | fprintf(stderr, | 52 | fprintf (stderr, |
53 | "Address changed: %s `%s' (%u bytes)\n", | 53 | "Address changed: %s `%s' (%u bytes)\n", |
54 | add_remove == GNUNET_YES | 54 | add_remove == GNUNET_YES |
55 | ? "added" : "removed", | 55 | ? "added" : "removed", |
56 | GNUNET_a2s(addr, | 56 | GNUNET_a2s (addr, |
57 | addrlen), | 57 | addrlen), |
58 | (unsigned int)addrlen); | 58 | (unsigned int) addrlen); |
59 | } | 59 | } |
60 | else | 60 | else |
61 | ; | 61 | ; |
62 | //TODO: proper error handling! | 62 | // TODO: proper error handling! |
63 | } | 63 | } |
64 | 64 | ||
65 | 65 | ||
@@ -67,12 +67,12 @@ addr_callback(void *cls, int add_remove, | |||
67 | * Function that terminates the test. | 67 | * Function that terminates the test. |
68 | */ | 68 | */ |
69 | static void | 69 | static void |
70 | stop(void *cls) | 70 | stop (void *cls) |
71 | { | 71 | { |
72 | struct GNUNET_NAT_MiniHandle *mini = cls; | 72 | struct GNUNET_NAT_MiniHandle *mini = cls; |
73 | 73 | ||
74 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Stopping NAT and quitting...\n"); | 74 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping NAT and quitting...\n"); |
75 | GNUNET_NAT_mini_map_stop(mini); | 75 | GNUNET_NAT_mini_map_stop (mini); |
76 | } | 76 | } |
77 | 77 | ||
78 | #define PORT 10000 | 78 | #define PORT 10000 |
@@ -81,27 +81,27 @@ stop(void *cls) | |||
81 | * Main function run with scheduler. | 81 | * Main function run with scheduler. |
82 | */ | 82 | */ |
83 | static void | 83 | static void |
84 | run(void *cls, char *const *args, const char *cfgfile, | 84 | run (void *cls, char *const *args, const char *cfgfile, |
85 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 85 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
86 | { | 86 | { |
87 | struct GNUNET_NAT_MiniHandle *mini; | 87 | struct GNUNET_NAT_MiniHandle *mini; |
88 | 88 | ||
89 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 89 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
90 | "Requesting NAT redirection for port %u...\n", | 90 | "Requesting NAT redirection for port %u...\n", |
91 | PORT); | 91 | PORT); |
92 | mini = GNUNET_NAT_mini_map_start(PORT, GNUNET_YES /* tcp */, | 92 | mini = GNUNET_NAT_mini_map_start (PORT, GNUNET_YES /* tcp */, |
93 | &addr_callback, NULL); | 93 | &addr_callback, NULL); |
94 | if (NULL == mini) | 94 | if (NULL == mini) |
95 | { | 95 | { |
96 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Could not start UPnP interaction\n"); | 96 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Could not start UPnP interaction\n"); |
97 | return; | 97 | return; |
98 | } | 98 | } |
99 | GNUNET_SCHEDULER_add_delayed(TIMEOUT, &stop, mini); | 99 | GNUNET_SCHEDULER_add_delayed (TIMEOUT, &stop, mini); |
100 | } | 100 | } |
101 | 101 | ||
102 | 102 | ||
103 | int | 103 | int |
104 | main(int argc, char *const argv[]) | 104 | main (int argc, char *const argv[]) |
105 | { | 105 | { |
106 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 106 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
107 | GNUNET_GETOPT_OPTION_END | 107 | GNUNET_GETOPT_OPTION_END |
@@ -116,16 +116,16 @@ main(int argc, char *const argv[]) | |||
116 | NULL | 116 | NULL |
117 | }; | 117 | }; |
118 | 118 | ||
119 | GNUNET_log_setup("test-nat-mini", | 119 | GNUNET_log_setup ("test-nat-mini", |
120 | "WARNING", | 120 | "WARNING", |
121 | NULL); | 121 | NULL); |
122 | 122 | ||
123 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 123 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
124 | "UPnP test for NAT library, timeout set to %s\n", | 124 | "UPnP test for NAT library, timeout set to %s\n", |
125 | GNUNET_STRINGS_relative_time_to_string(TIMEOUT, | 125 | GNUNET_STRINGS_relative_time_to_string (TIMEOUT, |
126 | GNUNET_YES)); | 126 | GNUNET_YES)); |
127 | GNUNET_PROGRAM_run(5, argv_prog, "test-nat-mini", "nohelp", options, &run, | 127 | GNUNET_PROGRAM_run (5, argv_prog, "test-nat-mini", "nohelp", options, &run, |
128 | NULL); | 128 | NULL); |
129 | return 0; | 129 | return 0; |
130 | } | 130 | } |
131 | 131 | ||
diff --git a/src/nat/test_nat_test.c b/src/nat/test_nat_test.c index e217c1d29..1eabab50c 100644 --- a/src/nat/test_nat_test.c +++ b/src/nat/test_nat_test.c | |||
@@ -29,43 +29,43 @@ | |||
29 | /** | 29 | /** |
30 | * Time to wait before stopping NAT test, in seconds | 30 | * Time to wait before stopping NAT test, in seconds |
31 | */ | 31 | */ |
32 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 15) | 32 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15) |
33 | 33 | ||
34 | 34 | ||
35 | static int ret = 1; | 35 | static int ret = 1; |
36 | 36 | ||
37 | static struct GNUNET_NAT_Test *tst; | 37 | static struct GNUNET_NAT_Test *tst; |
38 | 38 | ||
39 | static struct GNUNET_SCHEDULER_Task * tsk; | 39 | static struct GNUNET_SCHEDULER_Task *tsk; |
40 | 40 | ||
41 | 41 | ||
42 | static void | 42 | static void |
43 | report_result(void *cls, | 43 | report_result (void *cls, |
44 | enum GNUNET_NAT_StatusCode aret) | 44 | enum GNUNET_NAT_StatusCode aret) |
45 | { | 45 | { |
46 | if (GNUNET_NAT_ERROR_TIMEOUT == aret) | 46 | if (GNUNET_NAT_ERROR_TIMEOUT == aret) |
47 | fprintf(stderr, | 47 | fprintf (stderr, |
48 | "NAT test timed out\n"); | 48 | "NAT test timed out\n"); |
49 | else if (GNUNET_NAT_ERROR_SUCCESS != aret) | 49 | else if (GNUNET_NAT_ERROR_SUCCESS != aret) |
50 | fprintf(stderr, | 50 | fprintf (stderr, |
51 | "NAT test reported error %d\n", aret); | 51 | "NAT test reported error %d\n", aret); |
52 | else | 52 | else |
53 | ret = 0; | 53 | ret = 0; |
54 | GNUNET_NAT_test_stop(tst); | 54 | GNUNET_NAT_test_stop (tst); |
55 | tst = NULL; | 55 | tst = NULL; |
56 | GNUNET_SCHEDULER_cancel(tsk); | 56 | GNUNET_SCHEDULER_cancel (tsk); |
57 | tsk = NULL; | 57 | tsk = NULL; |
58 | } | 58 | } |
59 | 59 | ||
60 | 60 | ||
61 | static void | 61 | static void |
62 | failed_timeout(void *cls) | 62 | failed_timeout (void *cls) |
63 | { | 63 | { |
64 | tsk = NULL; | 64 | tsk = NULL; |
65 | fprintf(stderr, | 65 | fprintf (stderr, |
66 | "NAT test failed to terminate on timeout\n"); | 66 | "NAT test failed to terminate on timeout\n"); |
67 | ret = 2; | 67 | ret = 2; |
68 | GNUNET_NAT_test_stop(tst); | 68 | GNUNET_NAT_test_stop (tst); |
69 | tst = NULL; | 69 | tst = NULL; |
70 | } | 70 | } |
71 | 71 | ||
@@ -74,22 +74,22 @@ failed_timeout(void *cls) | |||
74 | * Main function run with scheduler. | 74 | * Main function run with scheduler. |
75 | */ | 75 | */ |
76 | static void | 76 | static void |
77 | run(void *cls, char *const *args, const char *cfgfile, | 77 | run (void *cls, char *const *args, const char *cfgfile, |
78 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 78 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
79 | { | 79 | { |
80 | tst = | 80 | tst = |
81 | GNUNET_NAT_test_start(cfg, GNUNET_YES, 1285, 1285, TIMEOUT, | 81 | GNUNET_NAT_test_start (cfg, GNUNET_YES, 1285, 1285, TIMEOUT, |
82 | &report_result, | 82 | &report_result, |
83 | NULL); | 83 | NULL); |
84 | tsk = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(TIMEOUT, | 84 | tsk = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (TIMEOUT, |
85 | 2), | 85 | 2), |
86 | &failed_timeout, | 86 | &failed_timeout, |
87 | NULL); | 87 | NULL); |
88 | } | 88 | } |
89 | 89 | ||
90 | 90 | ||
91 | int | 91 | int |
92 | main(int argc, char *const argv[]) | 92 | main (int argc, char *const argv[]) |
93 | { | 93 | { |
94 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 94 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
95 | GNUNET_GETOPT_OPTION_END | 95 | GNUNET_GETOPT_OPTION_END |
@@ -103,37 +103,38 @@ main(int argc, char *const argv[]) | |||
103 | NULL | 103 | NULL |
104 | }; | 104 | }; |
105 | 105 | ||
106 | GNUNET_log_setup("test-nat-test", | 106 | GNUNET_log_setup ("test-nat-test", |
107 | "WARNING", | 107 | "WARNING", |
108 | NULL); | 108 | NULL); |
109 | 109 | ||
110 | nat_res = GNUNET_OS_check_helper_binary("gnunet-nat-server", GNUNET_NO, NULL); | 110 | nat_res = GNUNET_OS_check_helper_binary ("gnunet-nat-server", GNUNET_NO, |
111 | NULL); | ||
111 | if (GNUNET_SYSERR == nat_res) | 112 | if (GNUNET_SYSERR == nat_res) |
112 | { | 113 | { |
113 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 114 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
114 | "Cannot run NAT test: `%s' file not found\n", | 115 | "Cannot run NAT test: `%s' file not found\n", |
115 | "gnunet-nat-server"); | 116 | "gnunet-nat-server"); |
116 | return 0; | 117 | return 0; |
117 | } | 118 | } |
118 | 119 | ||
119 | gns = GNUNET_OS_start_process(GNUNET_YES, | 120 | gns = GNUNET_OS_start_process (GNUNET_YES, |
120 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 121 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
121 | NULL, NULL, NULL, | 122 | NULL, NULL, NULL, |
122 | "gnunet-nat-server", | 123 | "gnunet-nat-server", |
123 | "gnunet-nat-server", | 124 | "gnunet-nat-server", |
124 | "-c", "test_nat_test_data.conf", | 125 | "-c", "test_nat_test_data.conf", |
125 | "12345", NULL); | 126 | "12345", NULL); |
126 | GNUNET_assert(NULL != gns); | 127 | GNUNET_assert (NULL != gns); |
127 | GNUNET_PROGRAM_run(3, argv_prog, | 128 | GNUNET_PROGRAM_run (3, argv_prog, |
128 | "test-nat-test", "nohelp", | 129 | "test-nat-test", "nohelp", |
129 | options, &run, | 130 | options, &run, |
130 | NULL); | 131 | NULL); |
131 | GNUNET_break(0 == GNUNET_OS_process_kill(gns, GNUNET_TERM_SIG)); | 132 | GNUNET_break (0 == GNUNET_OS_process_kill (gns, GNUNET_TERM_SIG)); |
132 | GNUNET_break(GNUNET_OK == GNUNET_OS_process_wait(gns)); | 133 | GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (gns)); |
133 | GNUNET_OS_process_destroy(gns); | 134 | GNUNET_OS_process_destroy (gns); |
134 | if (0 != ret) | 135 | if (0 != ret) |
135 | fprintf(stderr, | 136 | fprintf (stderr, |
136 | "NAT test failed to report success\n"); | 137 | "NAT test failed to report success\n"); |
137 | return ret; | 138 | return ret; |
138 | } | 139 | } |
139 | 140 | ||
diff --git a/src/nat/test_stun.c b/src/nat/test_stun.c index ee755905e..41e962ea0 100644 --- a/src/nat/test_stun.c +++ b/src/nat/test_stun.c | |||
@@ -36,12 +36,12 @@ | |||
36 | 36 | ||
37 | 37 | ||
38 | 38 | ||
39 | #define LOG(kind, ...) GNUNET_log_from(kind, "test-stun", __VA_ARGS__) | 39 | #define LOG(kind, ...) GNUNET_log_from (kind, "test-stun", __VA_ARGS__) |
40 | 40 | ||
41 | /** | 41 | /** |
42 | * Time to wait before stopping NAT, in seconds | 42 | * Time to wait before stopping NAT, in seconds |
43 | */ | 43 | */ |
44 | #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5) | 44 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) |
45 | 45 | ||
46 | 46 | ||
47 | /** | 47 | /** |
@@ -72,12 +72,12 @@ static struct GNUNET_NAT_STUN_Handle *rh; | |||
72 | 72 | ||
73 | 73 | ||
74 | static void | 74 | static void |
75 | print_answer(struct sockaddr_in* answer) | 75 | print_answer (struct sockaddr_in*answer) |
76 | { | 76 | { |
77 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 77 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
78 | "External IP is: %s , with port %d\n", | 78 | "External IP is: %s , with port %d\n", |
79 | inet_ntoa(answer->sin_addr), | 79 | inet_ntoa (answer->sin_addr), |
80 | ntohs(answer->sin_port)); | 80 | ntohs (answer->sin_port)); |
81 | } | 81 | } |
82 | 82 | ||
83 | 83 | ||
@@ -85,25 +85,25 @@ print_answer(struct sockaddr_in* answer) | |||
85 | * Function that terminates the test. | 85 | * Function that terminates the test. |
86 | */ | 86 | */ |
87 | static void | 87 | static void |
88 | stop() | 88 | stop () |
89 | { | 89 | { |
90 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 90 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
91 | "Stopping NAT and quitting...\n"); | 91 | "Stopping NAT and quitting...\n"); |
92 | if (NULL != ltask4) | 92 | if (NULL != ltask4) |
93 | { | 93 | { |
94 | GNUNET_SCHEDULER_cancel(ltask4); | 94 | GNUNET_SCHEDULER_cancel (ltask4); |
95 | ltask4 = NULL; | 95 | ltask4 = NULL; |
96 | } | 96 | } |
97 | if (NULL != lsock4) | 97 | if (NULL != lsock4) |
98 | { | 98 | { |
99 | GNUNET_NETWORK_socket_close(lsock4); | 99 | GNUNET_NETWORK_socket_close (lsock4); |
100 | lsock4 = NULL; | 100 | lsock4 = NULL; |
101 | } | 101 | } |
102 | if (NULL != rh) | 102 | if (NULL != rh) |
103 | { | 103 | { |
104 | GNUNET_NAT_stun_make_request_cancel(rh); | 104 | GNUNET_NAT_stun_make_request_cancel (rh); |
105 | rh = NULL; | 105 | rh = NULL; |
106 | } | 106 | } |
107 | } | 107 | } |
108 | 108 | ||
109 | 109 | ||
@@ -114,45 +114,45 @@ stop() | |||
114 | * @param cls | 114 | * @param cls |
115 | */ | 115 | */ |
116 | static void | 116 | static void |
117 | do_udp_read(void *cls) | 117 | do_udp_read (void *cls) |
118 | { | 118 | { |
119 | //struct GNUNET_NAT_Test *tst = cls; | 119 | // struct GNUNET_NAT_Test *tst = cls; |
120 | unsigned char reply_buf[1024]; | 120 | unsigned char reply_buf[1024]; |
121 | ssize_t rlen; | 121 | ssize_t rlen; |
122 | struct sockaddr_in answer; | 122 | struct sockaddr_in answer; |
123 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 123 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
124 | 124 | ||
125 | ltask4 = NULL; | 125 | ltask4 = NULL; |
126 | tc = GNUNET_SCHEDULER_get_task_context(); | 126 | tc = GNUNET_SCHEDULER_get_task_context (); |
127 | if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) || | 127 | if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) || |
128 | (!GNUNET_NETWORK_fdset_isset(tc->read_ready, | 128 | (! GNUNET_NETWORK_fdset_isset (tc->read_ready, |
129 | lsock4))) | 129 | lsock4))) |
130 | { | 130 | { |
131 | fprintf(stderr, | 131 | fprintf (stderr, |
132 | "Timeout waiting for STUN response\n"); | 132 | "Timeout waiting for STUN response\n"); |
133 | stop(); | 133 | stop (); |
134 | } | 134 | } |
135 | rlen = GNUNET_NETWORK_socket_recv(lsock4, | 135 | rlen = GNUNET_NETWORK_socket_recv (lsock4, |
136 | reply_buf, | 136 | reply_buf, |
137 | sizeof(reply_buf)); | 137 | sizeof(reply_buf)); |
138 | memset(&answer, | 138 | memset (&answer, |
139 | 0, | 139 | 0, |
140 | sizeof(struct sockaddr_in)); | 140 | sizeof(struct sockaddr_in)); |
141 | if (GNUNET_OK != | 141 | if (GNUNET_OK != |
142 | GNUNET_NAT_stun_handle_packet(reply_buf, | 142 | GNUNET_NAT_stun_handle_packet (reply_buf, |
143 | rlen, | 143 | rlen, |
144 | &answer)) | 144 | &answer)) |
145 | { | 145 | { |
146 | fprintf(stderr, | 146 | fprintf (stderr, |
147 | "Unexpected UDP packet, trying to read more\n"); | 147 | "Unexpected UDP packet, trying to read more\n"); |
148 | ltask4 = GNUNET_SCHEDULER_add_read_net(TIMEOUT, | 148 | ltask4 = GNUNET_SCHEDULER_add_read_net (TIMEOUT, |
149 | lsock4, | 149 | lsock4, |
150 | &do_udp_read, NULL); | 150 | &do_udp_read, NULL); |
151 | return; | 151 | return; |
152 | } | 152 | } |
153 | ret = 0; | 153 | ret = 0; |
154 | print_answer(&answer); | 154 | print_answer (&answer); |
155 | stop(); | 155 | stop (); |
156 | } | 156 | } |
157 | 157 | ||
158 | 158 | ||
@@ -162,33 +162,33 @@ do_udp_read(void *cls) | |||
162 | * @return NULL on error | 162 | * @return NULL on error |
163 | */ | 163 | */ |
164 | static struct GNUNET_NETWORK_Handle * | 164 | static struct GNUNET_NETWORK_Handle * |
165 | bind_v4() | 165 | bind_v4 () |
166 | { | 166 | { |
167 | struct GNUNET_NETWORK_Handle *ls; | 167 | struct GNUNET_NETWORK_Handle *ls; |
168 | struct sockaddr_in sa4; | 168 | struct sockaddr_in sa4; |
169 | int eno; | 169 | int eno; |
170 | 170 | ||
171 | memset(&sa4, 0, sizeof(sa4)); | 171 | memset (&sa4, 0, sizeof(sa4)); |
172 | sa4.sin_family = AF_INET; | 172 | sa4.sin_family = AF_INET; |
173 | sa4.sin_port = htons(port); | 173 | sa4.sin_port = htons (port); |
174 | #if HAVE_SOCKADDR_IN_SIN_LEN | 174 | #if HAVE_SOCKADDR_IN_SIN_LEN |
175 | sa4.sin_len = sizeof(sa4); | 175 | sa4.sin_len = sizeof(sa4); |
176 | #endif | 176 | #endif |
177 | ls = GNUNET_NETWORK_socket_create(AF_INET, | 177 | ls = GNUNET_NETWORK_socket_create (AF_INET, |
178 | SOCK_DGRAM, | 178 | SOCK_DGRAM, |
179 | 0); | 179 | 0); |
180 | if (NULL == ls) | 180 | if (NULL == ls) |
181 | return NULL; | 181 | return NULL; |
182 | if (GNUNET_OK != | 182 | if (GNUNET_OK != |
183 | GNUNET_NETWORK_socket_bind(ls, | 183 | GNUNET_NETWORK_socket_bind (ls, |
184 | (const struct sockaddr *)&sa4, | 184 | (const struct sockaddr *) &sa4, |
185 | sizeof(sa4))) | 185 | sizeof(sa4))) |
186 | { | 186 | { |
187 | eno = errno; | 187 | eno = errno; |
188 | GNUNET_NETWORK_socket_close(ls); | 188 | GNUNET_NETWORK_socket_close (ls); |
189 | errno = eno; | 189 | errno = eno; |
190 | return NULL; | 190 | return NULL; |
191 | } | 191 | } |
192 | return ls; | 192 | return ls; |
193 | } | 193 | } |
194 | 194 | ||
@@ -200,30 +200,30 @@ bind_v4() | |||
200 | * @param error status code from STUN | 200 | * @param error status code from STUN |
201 | */ | 201 | */ |
202 | static void | 202 | static void |
203 | request_callback(void *cls, | 203 | request_callback (void *cls, |
204 | enum GNUNET_NAT_StatusCode error) | 204 | enum GNUNET_NAT_StatusCode error) |
205 | { | 205 | { |
206 | rh = NULL; | 206 | rh = NULL; |
207 | if (GNUNET_NAT_ERROR_SUCCESS == error) | 207 | if (GNUNET_NAT_ERROR_SUCCESS == error) |
208 | { | 208 | { |
209 | /* all good, start to receive */ | 209 | /* all good, start to receive */ |
210 | ltask4 = GNUNET_SCHEDULER_add_read_net(TIMEOUT, | 210 | ltask4 = GNUNET_SCHEDULER_add_read_net (TIMEOUT, |
211 | lsock4, | 211 | lsock4, |
212 | &do_udp_read, | 212 | &do_udp_read, |
213 | NULL); | 213 | NULL); |
214 | return; | 214 | return; |
215 | } | 215 | } |
216 | if (error == GNUNET_NAT_ERROR_NOT_ONLINE) | 216 | if (error == GNUNET_NAT_ERROR_NOT_ONLINE) |
217 | { | 217 | { |
218 | ret = 77; /* report 'skip' */ | 218 | ret = 77; /* report 'skip' */ |
219 | fprintf(stderr, | 219 | fprintf (stderr, |
220 | "System is offline, cannot test STUN request.\n"); | 220 | "System is offline, cannot test STUN request.\n"); |
221 | } | 221 | } |
222 | else | 222 | else |
223 | { | 223 | { |
224 | ret = error; | 224 | ret = error; |
225 | } | 225 | } |
226 | stop(); | 226 | stop (); |
227 | } | 227 | } |
228 | 228 | ||
229 | 229 | ||
@@ -231,34 +231,34 @@ request_callback(void *cls, | |||
231 | * Main function run with scheduler. | 231 | * Main function run with scheduler. |
232 | */ | 232 | */ |
233 | static void | 233 | static void |
234 | run(void *cls, | 234 | run (void *cls, |
235 | char *const *args, | 235 | char *const *args, |
236 | const char *cfgfile, | 236 | const char *cfgfile, |
237 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 237 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
238 | { | 238 | { |
239 | //Lets create the socket | 239 | // Lets create the socket |
240 | lsock4 = bind_v4(); | 240 | lsock4 = bind_v4 (); |
241 | if (NULL == lsock4) | 241 | if (NULL == lsock4) |
242 | { | 242 | { |
243 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, | 243 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, |
244 | "bind"); | 244 | "bind"); |
245 | GNUNET_SCHEDULER_shutdown(); | 245 | GNUNET_SCHEDULER_shutdown (); |
246 | return; | 246 | return; |
247 | } | 247 | } |
248 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 248 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
249 | "Service listens on port %u\n", | 249 | "Service listens on port %u\n", |
250 | (unsigned int)port); | 250 | (unsigned int) port); |
251 | rh = GNUNET_NAT_stun_make_request(stun_server, | 251 | rh = GNUNET_NAT_stun_make_request (stun_server, |
252 | stun_port, | 252 | stun_port, |
253 | lsock4, | 253 | lsock4, |
254 | &request_callback, NULL); | 254 | &request_callback, NULL); |
255 | GNUNET_SCHEDULER_add_delayed(TIMEOUT, | 255 | GNUNET_SCHEDULER_add_delayed (TIMEOUT, |
256 | &stop, NULL); | 256 | &stop, NULL); |
257 | } | 257 | } |
258 | 258 | ||
259 | 259 | ||
260 | int | 260 | int |
261 | main(int argc, char *const argv[]) | 261 | main (int argc, char *const argv[]) |
262 | { | 262 | { |
263 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 263 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
264 | GNUNET_GETOPT_OPTION_END | 264 | GNUNET_GETOPT_OPTION_END |
@@ -272,40 +272,40 @@ main(int argc, char *const argv[]) | |||
272 | char *fn; | 272 | char *fn; |
273 | struct GNUNET_OS_Process *proc; | 273 | struct GNUNET_OS_Process *proc; |
274 | 274 | ||
275 | GNUNET_log_setup("test-stun", | 275 | GNUNET_log_setup ("test-stun", |
276 | "WARNING", | 276 | "WARNING", |
277 | NULL); | 277 | NULL); |
278 | 278 | ||
279 | /* Lets start resolver */ | 279 | /* Lets start resolver */ |
280 | fn = GNUNET_OS_get_libexec_binary_path("gnunet-service-resolver"); | 280 | fn = GNUNET_OS_get_libexec_binary_path ("gnunet-service-resolver"); |
281 | proc = GNUNET_OS_start_process(GNUNET_YES, | 281 | proc = GNUNET_OS_start_process (GNUNET_YES, |
282 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 282 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
283 | NULL, NULL, NULL, | 283 | NULL, NULL, NULL, |
284 | fn, | 284 | fn, |
285 | "gnunet-service-resolver", | 285 | "gnunet-service-resolver", |
286 | "-c", "test_stun.conf", NULL); | 286 | "-c", "test_stun.conf", NULL); |
287 | 287 | ||
288 | if (NULL == proc) | 288 | if (NULL == proc) |
289 | { | 289 | { |
290 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 290 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
291 | "This test was unable to start gnunet-service-resolver, and it is required to run ...\n"); | 291 | "This test was unable to start gnunet-service-resolver, and it is required to run ...\n"); |
292 | exit(1); | 292 | exit (1); |
293 | } | 293 | } |
294 | 294 | ||
295 | GNUNET_PROGRAM_run(3, argv_prog, | 295 | GNUNET_PROGRAM_run (3, argv_prog, |
296 | "test-stun", "nohelp", | 296 | "test-stun", "nohelp", |
297 | options, | 297 | options, |
298 | &run, NULL); | 298 | &run, NULL); |
299 | 299 | ||
300 | /* Now kill the resolver */ | 300 | /* Now kill the resolver */ |
301 | if (0 != GNUNET_OS_process_kill(proc, GNUNET_TERM_SIG)) | 301 | if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG)) |
302 | { | 302 | { |
303 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); | 303 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); |
304 | } | 304 | } |
305 | GNUNET_OS_process_wait(proc); | 305 | GNUNET_OS_process_wait (proc); |
306 | GNUNET_OS_process_destroy(proc); | 306 | GNUNET_OS_process_destroy (proc); |
307 | proc = NULL; | 307 | proc = NULL; |
308 | GNUNET_free(fn); | 308 | GNUNET_free (fn); |
309 | 309 | ||
310 | return ret; | 310 | return ret; |
311 | } | 311 | } |