aboutsummaryrefslogtreecommitdiff
path: root/src/exit
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2019-10-05 15:09:28 +0200
committerChristian Grothoff <christian@grothoff.org>2019-10-05 15:09:28 +0200
commitc4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch)
treecac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/exit
parentfbb71d527c7d6babf269a8fefce1db291b9f7068 (diff)
downloadgnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz
gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/exit')
-rw-r--r--src/exit/exit.h27
-rw-r--r--src/exit/gnunet-daemon-exit.c4592
-rw-r--r--src/exit/gnunet-helper-exit.c957
3 files changed, 2840 insertions, 2736 deletions
diff --git a/src/exit/exit.h b/src/exit/exit.h
index be4f042b6..41dad6246 100644
--- a/src/exit/exit.h
+++ b/src/exit/exit.h
@@ -34,7 +34,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
34 * Message send via cadet to an exit daemon to initiate forwarding of 34 * Message send via cadet to an exit daemon to initiate forwarding of
35 * TCP data to a local service. 35 * TCP data to a local service.
36 */ 36 */
37struct GNUNET_EXIT_TcpServiceStartMessage { 37struct GNUNET_EXIT_TcpServiceStartMessage
38{
38 /** 39 /**
39 * Type is #GNUNET_MESSAGE_TYPE_VPN_TCP_TO_SERVICE_START 40 * Type is #GNUNET_MESSAGE_TYPE_VPN_TCP_TO_SERVICE_START
40 */ 41 */
@@ -59,7 +60,8 @@ struct GNUNET_EXIT_TcpServiceStartMessage {
59 * Message send via cadet to an exit daemon to initiate forwarding of 60 * Message send via cadet to an exit daemon to initiate forwarding of
60 * TCP data to the Internet. 61 * TCP data to the Internet.
61 */ 62 */
62struct GNUNET_EXIT_TcpInternetStartMessage { 63struct GNUNET_EXIT_TcpInternetStartMessage
64{
63 /** 65 /**
64 * Type is #GNUNET_MESSAGE_TYPE_VPN_TCP_TO_INTERNET_START 66 * Type is #GNUNET_MESSAGE_TYPE_VPN_TCP_TO_INTERNET_START
65 */ 67 */
@@ -89,7 +91,8 @@ struct GNUNET_EXIT_TcpInternetStartMessage {
89 * format is used for both Internet-exits and service-exits and 91 * format is used for both Internet-exits and service-exits and
90 * in both directions (VPN to exit and exit to VPN). 92 * in both directions (VPN to exit and exit to VPN).
91 */ 93 */
92struct GNUNET_EXIT_TcpDataMessage { 94struct GNUNET_EXIT_TcpDataMessage
95{
93 /** 96 /**
94 * Type is #GNUNET_MESSAGE_TYPE_VPN_TCP_DATA 97 * Type is #GNUNET_MESSAGE_TYPE_VPN_TCP_DATA
95 */ 98 */
@@ -114,7 +117,8 @@ struct GNUNET_EXIT_TcpDataMessage {
114 * Message send via cadet to an exit daemon to send 117 * Message send via cadet to an exit daemon to send
115 * UDP data to a local service. 118 * UDP data to a local service.
116 */ 119 */
117struct GNUNET_EXIT_UdpServiceMessage { 120struct GNUNET_EXIT_UdpServiceMessage
121{
118 /** 122 /**
119 * Type is #GNUNET_MESSAGE_TYPE_VPN_UDP_TO_SERVICE 123 * Type is #GNUNET_MESSAGE_TYPE_VPN_UDP_TO_SERVICE
120 */ 124 */
@@ -138,7 +142,8 @@ struct GNUNET_EXIT_UdpServiceMessage {
138 * Message send via cadet to an exit daemon to forward 142 * Message send via cadet to an exit daemon to forward
139 * UDP data to the Internet. 143 * UDP data to the Internet.
140 */ 144 */
141struct GNUNET_EXIT_UdpInternetMessage { 145struct GNUNET_EXIT_UdpInternetMessage
146{
142 /** 147 /**
143 * Type is #GNUNET_MESSAGE_TYPE_VPN_UDP_TO_INTERNET 148 * Type is #GNUNET_MESSAGE_TYPE_VPN_UDP_TO_INTERNET
144 */ 149 */
@@ -170,7 +175,8 @@ struct GNUNET_EXIT_UdpInternetMessage {
170 * Message send from exit daemon back to the UDP entry point 175 * Message send from exit daemon back to the UDP entry point
171 * (used for both Internet and Service exit replies). 176 * (used for both Internet and Service exit replies).
172 */ 177 */
173struct GNUNET_EXIT_UdpReplyMessage { 178struct GNUNET_EXIT_UdpReplyMessage
179{
174 /** 180 /**
175 * Type is #GNUNET_MESSAGE_TYPE_VPN_UDP_REPLY 181 * Type is #GNUNET_MESSAGE_TYPE_VPN_UDP_REPLY
176 */ 182 */
@@ -196,7 +202,8 @@ struct GNUNET_EXIT_UdpReplyMessage {
196 * Message send via cadet to an exit daemon to send 202 * Message send via cadet to an exit daemon to send
197 * ICMP data to a local service. 203 * ICMP data to a local service.
198 */ 204 */
199struct GNUNET_EXIT_IcmpServiceMessage { 205struct GNUNET_EXIT_IcmpServiceMessage
206{
200 /** 207 /**
201 * Type is #GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_SERVICE 208 * Type is #GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_SERVICE
202 */ 209 */
@@ -226,7 +233,8 @@ struct GNUNET_EXIT_IcmpServiceMessage {
226 * Message send via cadet to an exit daemon to forward 233 * Message send via cadet to an exit daemon to forward
227 * ICMP data to the Internet. 234 * ICMP data to the Internet.
228 */ 235 */
229struct GNUNET_EXIT_IcmpInternetMessage { 236struct GNUNET_EXIT_IcmpInternetMessage
237{
230 /** 238 /**
231 * Type is #GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_INTERNET 239 * Type is #GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_INTERNET
232 */ 240 */
@@ -260,7 +268,8 @@ struct GNUNET_EXIT_IcmpInternetMessage {
260 * Message send via cadet to the vpn service to send 268 * Message send via cadet to the vpn service to send
261 * ICMP data to the VPN's TUN interface. 269 * ICMP data to the VPN's TUN interface.
262 */ 270 */
263struct GNUNET_EXIT_IcmpToVPNMessage { 271struct GNUNET_EXIT_IcmpToVPNMessage
272{
264 /** 273 /**
265 * Type is #GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_VPN 274 * Type is #GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_VPN
266 */ 275 */
diff --git a/src/exit/gnunet-daemon-exit.c b/src/exit/gnunet-daemon-exit.c
index f7cadbace..578997f4a 100644
--- a/src/exit/gnunet-daemon-exit.c
+++ b/src/exit/gnunet-daemon-exit.c
@@ -66,30 +66,34 @@
66/** 66/**
67 * How frequently do we re-announce the regex for the exit? 67 * How frequently do we re-announce the regex for the exit?
68 */ 68 */
69#define REGEX_REFRESH_FREQUENCY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30) 69#define REGEX_REFRESH_FREQUENCY GNUNET_TIME_relative_multiply ( \
70 GNUNET_TIME_UNIT_MINUTES, 30)
70 71
71/** 72/**
72 * How frequently do we re-announce the DNS exit in the DHT? 73 * How frequently do we re-announce the DNS exit in the DHT?
73 */ 74 */
74#define DHT_PUT_FREQUENCY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15) 75#define DHT_PUT_FREQUENCY GNUNET_TIME_relative_multiply ( \
76 GNUNET_TIME_UNIT_MINUTES, 15)
75 77
76/** 78/**
77 * How long do we typically sign the DNS exit advertisement for? 79 * How long do we typically sign the DNS exit advertisement for?
78 */ 80 */
79#define DNS_ADVERTISEMENT_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 3) 81#define DNS_ADVERTISEMENT_TIMEOUT GNUNET_TIME_relative_multiply ( \
82 GNUNET_TIME_UNIT_HOURS, 3)
80 83
81 84
82/** 85/**
83 * Generic logging shorthand 86 * Generic logging shorthand
84 */ 87 */
85#define LOG(kind, ...) \ 88#define LOG(kind, ...) \
86 GNUNET_log_from(kind, "exit", __VA_ARGS__); 89 GNUNET_log_from (kind, "exit", __VA_ARGS__);
87 90
88 91
89/** 92/**
90 * Information about an address. 93 * Information about an address.
91 */ 94 */
92struct SocketAddress { 95struct SocketAddress
96{
93 /** 97 /**
94 * AF_INET or AF_INET6. 98 * AF_INET or AF_INET6.
95 */ 99 */
@@ -98,7 +102,8 @@ struct SocketAddress {
98 /** 102 /**
99 * Remote address information. 103 * Remote address information.
100 */ 104 */
101 union { 105 union
106 {
102 /** 107 /**
103 * Address, if af is AF_INET. 108 * Address, if af is AF_INET.
104 */ 109 */
@@ -127,7 +132,8 @@ struct SocketAddress {
127 * a service this peer is specifically offering an exit for 132 * a service this peer is specifically offering an exit for
128 * (for a specific domain name). 133 * (for a specific domain name).
129 */ 134 */
130struct LocalService { 135struct LocalService
136{
131 /** 137 /**
132 * Remote address to use for the service. 138 * Remote address to use for the service.
133 */ 139 */
@@ -160,7 +166,8 @@ struct LocalService {
160 * IP-version, protocol, source-IP, destination-IP, source-port and 166 * IP-version, protocol, source-IP, destination-IP, source-port and
161 * destinatin-port. 167 * destinatin-port.
162 */ 168 */
163struct RedirectInformation { 169struct RedirectInformation
170{
164 /** 171 /**
165 * Address information for the other party (equivalent of the 172 * Address information for the other party (equivalent of the
166 * arguments one would give to "connect"). 173 * arguments one would give to "connect").
@@ -192,7 +199,8 @@ struct RedirectInformation {
192 * with the channel's closure so we can find it again for the next 199 * with the channel's closure so we can find it again for the next
193 * message from the channel. 200 * message from the channel.
194 */ 201 */
195struct ChannelState { 202struct ChannelState
203{
196 /** 204 /**
197 * Cadet channel that is used for this connection. 205 * Cadet channel that is used for this connection.
198 */ 206 */
@@ -211,8 +219,10 @@ struct ChannelState {
211 */ 219 */
212 int is_dns; 220 int is_dns;
213 221
214 union { 222 union
215 struct { 223 {
224 struct
225 {
216 /** 226 /**
217 * Heap node for this state in the connections_heap. 227 * Heap node for this state in the connections_heap.
218 */ 228 */
@@ -234,7 +244,8 @@ struct ChannelState {
234 struct RedirectInformation ri; 244 struct RedirectInformation ri;
235 } tcp_udp; 245 } tcp_udp;
236 246
237 struct { 247 struct
248 {
238 /** 249 /**
239 * Socket we are using to transmit this request (must match if we receive 250 * Socket we are using to transmit this request (must match if we receive
240 * a response). 251 * a response).
@@ -418,7 +429,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
418/** 429/**
419 * Message with a DNS response. 430 * Message with a DNS response.
420 */ 431 */
421struct DnsResponseMessage { 432struct DnsResponseMessage
433{
422 /** 434 /**
423 * GNUnet header, of type #GNUNET_MESSAGE_TYPE_VPN_DNS_FROM_INTERNET 435 * GNUnet header, of type #GNUNET_MESSAGE_TYPE_VPN_DNS_FROM_INTERNET
424 */ 436 */
@@ -444,35 +456,35 @@ GNUNET_NETWORK_STRUCT_END
444 * @param r number of bytes in @a dns 456 * @param r number of bytes in @a dns
445 */ 457 */
446static void 458static void
447process_dns_result(void *cls, 459process_dns_result (void *cls,
448 const struct GNUNET_TUN_DnsHeader *dns, 460 const struct GNUNET_TUN_DnsHeader *dns,
449 size_t r) 461 size_t r)
450{ 462{
451 struct ChannelState *ts; 463 struct ChannelState *ts;
452 struct GNUNET_MQ_Envelope *env; 464 struct GNUNET_MQ_Envelope *env;
453 struct DnsResponseMessage *resp; 465 struct DnsResponseMessage *resp;
454 466
455 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 467 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
456 "Processing DNS result from stub resolver\n"); 468 "Processing DNS result from stub resolver\n");
457 GNUNET_assert(NULL == cls); 469 GNUNET_assert (NULL == cls);
458 if (NULL == dns) 470 if (NULL == dns)
459 return; 471 return;
460 /* Handle case that this is a reply to a request from a CADET DNS channel */ 472 /* Handle case that this is a reply to a request from a CADET DNS channel */
461 ts = channels[dns->id]; 473 ts = channels[dns->id];
462 if (NULL == ts) 474 if (NULL == ts)
463 return; 475 return;
464 LOG(GNUNET_ERROR_TYPE_DEBUG, 476 LOG (GNUNET_ERROR_TYPE_DEBUG,
465 "Got a response from the stub resolver for DNS request received via CADET!\n"); 477 "Got a response from the stub resolver for DNS request received via CADET!\n");
466 channels[dns->id] = NULL; 478 channels[dns->id] = NULL;
467 env = GNUNET_MQ_msg_extra(resp, 479 env = GNUNET_MQ_msg_extra (resp,
468 r - sizeof(struct GNUNET_TUN_DnsHeader), 480 r - sizeof(struct GNUNET_TUN_DnsHeader),
469 GNUNET_MESSAGE_TYPE_VPN_DNS_FROM_INTERNET); 481 GNUNET_MESSAGE_TYPE_VPN_DNS_FROM_INTERNET);
470 GNUNET_memcpy(&resp->dns, 482 GNUNET_memcpy (&resp->dns,
471 dns, 483 dns,
472 r); 484 r);
473 resp->dns.id = ts->specifics.dns.original_id; 485 resp->dns.id = ts->specifics.dns.original_id;
474 GNUNET_MQ_send(GNUNET_CADET_get_mq(ts->channel), 486 GNUNET_MQ_send (GNUNET_CADET_get_mq (ts->channel),
475 env); 487 env);
476} 488}
477 489
478 490
@@ -485,21 +497,21 @@ process_dns_result(void *cls,
485 * #GNUNET_SYSERR to close it (signal serious error) 497 * #GNUNET_SYSERR to close it (signal serious error)
486 */ 498 */
487static int 499static int
488check_dns_request(void *cls, 500check_dns_request (void *cls,
489 const struct DnsResponseMessage *msg) 501 const struct DnsResponseMessage *msg)
490{ 502{
491 struct ChannelState *ts = cls; 503 struct ChannelState *ts = cls;
492 504
493 if (NULL == dnsstub) 505 if (NULL == dnsstub)
494 { 506 {
495 GNUNET_break(0); 507 GNUNET_break (0);
496 return GNUNET_SYSERR; 508 return GNUNET_SYSERR;
497 } 509 }
498 if (GNUNET_NO == ts->is_dns) 510 if (GNUNET_NO == ts->is_dns)
499 { 511 {
500 GNUNET_break_op(0); 512 GNUNET_break_op (0);
501 return GNUNET_SYSERR; 513 return GNUNET_SYSERR;
502 } 514 }
503 return GNUNET_OK; 515 return GNUNET_OK;
504} 516}
505 517
@@ -511,42 +523,44 @@ check_dns_request(void *cls,
511 * @param msg the actual message 523 * @param msg the actual message
512 */ 524 */
513static void 525static void
514handle_dns_request(void *cls, 526handle_dns_request (void *cls,
515 const struct DnsResponseMessage *msg) 527 const struct DnsResponseMessage *msg)
516{ 528{
517 struct ChannelState *ts = cls; 529 struct ChannelState *ts = cls;
518 size_t mlen = ntohs(msg->header.size); 530 size_t mlen = ntohs (msg->header.size);
519 size_t dlen = mlen - sizeof(struct GNUNET_MessageHeader); 531 size_t dlen = mlen - sizeof(struct GNUNET_MessageHeader);
520 char buf[dlen] GNUNET_ALIGN; 532 char buf[dlen] GNUNET_ALIGN;
521 struct GNUNET_TUN_DnsHeader *dout; 533 struct GNUNET_TUN_DnsHeader *dout;
522 534
523 if (GNUNET_SYSERR == ts->is_dns) 535 if (GNUNET_SYSERR == ts->is_dns)
524 { 536 {
525 /* channel is DNS from now on */ 537 /* channel is DNS from now on */
526 ts->is_dns = GNUNET_YES; 538 ts->is_dns = GNUNET_YES;
527 } 539 }
528 ts->specifics.dns.original_id = msg->dns.id; 540 ts->specifics.dns.original_id = msg->dns.id;
529 if (channels[ts->specifics.dns.my_id] == ts) 541 if (channels[ts->specifics.dns.my_id] == ts)
530 channels[ts->specifics.dns.my_id] = NULL; 542 channels[ts->specifics.dns.my_id] = NULL;
531 ts->specifics.dns.my_id = (uint16_t)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 543 ts->specifics.dns.my_id = (uint16_t) GNUNET_CRYPTO_random_u32 (
532 UINT16_MAX + 1); 544 GNUNET_CRYPTO_QUALITY_WEAK,
545 UINT16_MAX
546 + 1);
533 channels[ts->specifics.dns.my_id] = ts; 547 channels[ts->specifics.dns.my_id] = ts;
534 GNUNET_memcpy(buf, 548 GNUNET_memcpy (buf,
535 &msg->dns, 549 &msg->dns,
536 dlen); 550 dlen);
537 dout = (struct GNUNET_TUN_DnsHeader *)buf; 551 dout = (struct GNUNET_TUN_DnsHeader *) buf;
538 dout->id = ts->specifics.dns.my_id; 552 dout->id = ts->specifics.dns.my_id;
539 ts->specifics.dns.rs = GNUNET_DNSSTUB_resolve(dnsstub, 553 ts->specifics.dns.rs = GNUNET_DNSSTUB_resolve (dnsstub,
540 buf, 554 buf,
541 dlen, 555 dlen,
542 &process_dns_result, 556 &process_dns_result,
543 NULL); 557 NULL);
544 if (NULL == ts->specifics.dns.rs) 558 if (NULL == ts->specifics.dns.rs)
545 { 559 {
546 GNUNET_break_op(0); 560 GNUNET_break_op (0);
547 return; 561 return;
548 } 562 }
549 GNUNET_CADET_receive_done(ts->channel); 563 GNUNET_CADET_receive_done (ts->channel);
550} 564}
551 565
552 566
@@ -558,66 +572,66 @@ handle_dns_request(void *cls,
558 * @param ri information about the connection 572 * @param ri information about the connection
559 */ 573 */
560static void 574static void
561hash_redirect_info(struct GNUNET_HashCode *hash, 575hash_redirect_info (struct GNUNET_HashCode *hash,
562 const struct RedirectInformation *ri) 576 const struct RedirectInformation *ri)
563{ 577{
564 char *off; 578 char *off;
565 579
566 memset(hash, 580 memset (hash,
567 0, 581 0,
568 sizeof(struct GNUNET_HashCode)); 582 sizeof(struct GNUNET_HashCode));
569 /* the GNUnet hashmap only uses the first sizeof(unsigned int) of the hash, 583 /* the GNUnet hashmap only uses the first sizeof(unsigned int) of the hash,
570 so we put the IP address in there (and hope for few collisions) */ 584 so we put the IP address in there (and hope for few collisions) */
571 off = (char*)hash; 585 off = (char*) hash;
572 switch (ri->remote_address.af) 586 switch (ri->remote_address.af)
573 { 587 {
574 case AF_INET: 588 case AF_INET:
575 GNUNET_memcpy(off, 589 GNUNET_memcpy (off,
576 &ri->remote_address.address.ipv4, 590 &ri->remote_address.address.ipv4,
577 sizeof(struct in_addr)); 591 sizeof(struct in_addr));
578 off += sizeof(struct in_addr); 592 off += sizeof(struct in_addr);
579 break; 593 break;
580 594
581 case AF_INET6: 595 case AF_INET6:
582 GNUNET_memcpy(off, 596 GNUNET_memcpy (off,
583 &ri->remote_address.address.ipv6, 597 &ri->remote_address.address.ipv6,
584 sizeof(struct in6_addr)); 598 sizeof(struct in6_addr));
585 off += sizeof(struct in_addr); 599 off += sizeof(struct in_addr);
586 break; 600 break;
587 601
588 default: 602 default:
589 GNUNET_assert(0); 603 GNUNET_assert (0);
590 } 604 }
591 GNUNET_memcpy(off, 605 GNUNET_memcpy (off,
592 &ri->remote_address.port, 606 &ri->remote_address.port,
593 sizeof(uint16_t)); 607 sizeof(uint16_t));
594 off += sizeof(uint16_t); 608 off += sizeof(uint16_t);
595 switch (ri->local_address.af) 609 switch (ri->local_address.af)
596 { 610 {
597 case AF_INET: 611 case AF_INET:
598 GNUNET_memcpy(off, 612 GNUNET_memcpy (off,
599 &ri->local_address.address.ipv4, 613 &ri->local_address.address.ipv4,
600 sizeof(struct in_addr)); 614 sizeof(struct in_addr));
601 off += sizeof(struct in_addr); 615 off += sizeof(struct in_addr);
602 break; 616 break;
603 617
604 case AF_INET6: 618 case AF_INET6:
605 GNUNET_memcpy(off, 619 GNUNET_memcpy (off,
606 &ri->local_address.address.ipv6, 620 &ri->local_address.address.ipv6,
607 sizeof(struct in6_addr)); 621 sizeof(struct in6_addr));
608 off += sizeof(struct in_addr); 622 off += sizeof(struct in_addr);
609 break; 623 break;
610 624
611 default: 625 default:
612 GNUNET_assert(0); 626 GNUNET_assert (0);
613 } 627 }
614 GNUNET_memcpy(off, 628 GNUNET_memcpy (off,
615 &ri->local_address.port, 629 &ri->local_address.port,
616 sizeof(uint16_t)); 630 sizeof(uint16_t));
617 off += sizeof(uint16_t); 631 off += sizeof(uint16_t);
618 GNUNET_memcpy(off, 632 GNUNET_memcpy (off,
619 &ri->remote_address.proto, 633 &ri->remote_address.proto,
620 sizeof(uint8_t)); 634 sizeof(uint8_t));
621 /* off += sizeof (uint8_t); */ 635 /* off += sizeof (uint8_t); */
622} 636}
623 637
@@ -636,13 +650,13 @@ hash_redirect_info(struct GNUNET_HashCode *hash,
636 * @return NULL if we have no tracking information for this tuple 650 * @return NULL if we have no tracking information for this tuple
637 */ 651 */
638static struct ChannelState * 652static struct ChannelState *
639get_redirect_state(int af, 653get_redirect_state (int af,
640 int protocol, 654 int protocol,
641 const void *destination_ip, 655 const void *destination_ip,
642 uint16_t destination_port, 656 uint16_t destination_port,
643 const void *local_ip, 657 const void *local_ip,
644 uint16_t local_port, 658 uint16_t local_port,
645 struct GNUNET_HashCode *state_key) 659 struct GNUNET_HashCode *state_key)
646{ 660{
647 struct RedirectInformation ri; 661 struct RedirectInformation ri;
648 struct GNUNET_HashCode key; 662 struct GNUNET_HashCode key;
@@ -650,37 +664,37 @@ get_redirect_state(int af,
650 664
651 if (((af == AF_INET) && (protocol == IPPROTO_ICMP)) || 665 if (((af == AF_INET) && (protocol == IPPROTO_ICMP)) ||
652 ((af == AF_INET6) && (protocol == IPPROTO_ICMPV6))) 666 ((af == AF_INET6) && (protocol == IPPROTO_ICMPV6)))
653 { 667 {
654 /* ignore ports */ 668 /* ignore ports */
655 destination_port = 0; 669 destination_port = 0;
656 local_port = 0; 670 local_port = 0;
657 } 671 }
658 ri.remote_address.af = af; 672 ri.remote_address.af = af;
659 if (af == AF_INET) 673 if (af == AF_INET)
660 ri.remote_address.address.ipv4 = *((struct in_addr*)destination_ip); 674 ri.remote_address.address.ipv4 = *((struct in_addr*) destination_ip);
661 else 675 else
662 ri.remote_address.address.ipv6 = *((struct in6_addr*)destination_ip); 676 ri.remote_address.address.ipv6 = *((struct in6_addr*) destination_ip);
663 ri.remote_address.port = destination_port; 677 ri.remote_address.port = destination_port;
664 ri.remote_address.proto = protocol; 678 ri.remote_address.proto = protocol;
665 ri.local_address.af = af; 679 ri.local_address.af = af;
666 if (af == AF_INET) 680 if (af == AF_INET)
667 ri.local_address.address.ipv4 = *((struct in_addr*)local_ip); 681 ri.local_address.address.ipv4 = *((struct in_addr*) local_ip);
668 else 682 else
669 ri.local_address.address.ipv6 = *((struct in6_addr*)local_ip); 683 ri.local_address.address.ipv6 = *((struct in6_addr*) local_ip);
670 ri.local_address.port = local_port; 684 ri.local_address.port = local_port;
671 ri.local_address.proto = protocol; 685 ri.local_address.proto = protocol;
672 hash_redirect_info(&key, 686 hash_redirect_info (&key,
673 &ri); 687 &ri);
674 if (NULL != state_key) 688 if (NULL != state_key)
675 *state_key = key; 689 *state_key = key;
676 state = GNUNET_CONTAINER_multihashmap_get(connections_map, 690 state = GNUNET_CONTAINER_multihashmap_get (connections_map,
677 &key); 691 &key);
678 if (NULL == state) 692 if (NULL == state)
679 return NULL; 693 return NULL;
680 /* Mark this connection as freshly used */ 694 /* Mark this connection as freshly used */
681 if (NULL == state_key) 695 if (NULL == state_key)
682 GNUNET_CONTAINER_heap_update_cost(state->specifics.tcp_udp.heap_node, 696 GNUNET_CONTAINER_heap_update_cost (state->specifics.tcp_udp.heap_node,
683 GNUNET_TIME_absolute_get().abs_value_us); 697 GNUNET_TIME_absolute_get ().abs_value_us);
684 return state; 698 return state;
685} 699}
686 700
@@ -696,36 +710,36 @@ get_redirect_state(int af,
696 * #GNUNET_SYSERR to close it (signal serious error) 710 * #GNUNET_SYSERR to close it (signal serious error)
697 */ 711 */
698static int 712static int
699check_tcp_service(void *cls, 713check_tcp_service (void *cls,
700 const struct GNUNET_EXIT_TcpServiceStartMessage *start) 714 const struct GNUNET_EXIT_TcpServiceStartMessage *start)
701{ 715{
702 struct ChannelState *state = cls; 716 struct ChannelState *state = cls;
703 717
704 if (NULL == state) 718 if (NULL == state)
705 { 719 {
706 GNUNET_break_op(0); 720 GNUNET_break_op (0);
707 return GNUNET_SYSERR; 721 return GNUNET_SYSERR;
708 } 722 }
709 if (GNUNET_YES == state->is_dns) 723 if (GNUNET_YES == state->is_dns)
710 { 724 {
711 GNUNET_break_op(0); 725 GNUNET_break_op (0);
712 return GNUNET_SYSERR; 726 return GNUNET_SYSERR;
713 } 727 }
714 if (NULL == state->specifics.tcp_udp.serv) 728 if (NULL == state->specifics.tcp_udp.serv)
715 { 729 {
716 GNUNET_break_op(0); 730 GNUNET_break_op (0);
717 return GNUNET_SYSERR; 731 return GNUNET_SYSERR;
718 } 732 }
719 if (NULL != state->specifics.tcp_udp.heap_node) 733 if (NULL != state->specifics.tcp_udp.heap_node)
720 { 734 {
721 GNUNET_break_op(0); 735 GNUNET_break_op (0);
722 return GNUNET_SYSERR; 736 return GNUNET_SYSERR;
723 } 737 }
724 if (start->tcp_header.off * 4 < sizeof(struct GNUNET_TUN_TcpHeader)) 738 if (start->tcp_header.off * 4 < sizeof(struct GNUNET_TUN_TcpHeader))
725 { 739 {
726 GNUNET_break_op(0); 740 GNUNET_break_op (0);
727 return GNUNET_SYSERR; 741 return GNUNET_SYSERR;
728 } 742 }
729 return GNUNET_OK; 743 return GNUNET_OK;
730} 744}
731 745
@@ -749,86 +763,88 @@ check_tcp_service(void *cls,
749 * AND the payload 763 * AND the payload
750 */ 764 */
751static void 765static void
752prepare_ipv4_packet(const void *payload, 766prepare_ipv4_packet (const void *payload,
753 size_t payload_length, 767 size_t payload_length,
754 int protocol, 768 int protocol,
755 const struct GNUNET_TUN_TcpHeader *tcp_header, 769 const struct GNUNET_TUN_TcpHeader *tcp_header,
756 const struct SocketAddress *src_address, 770 const struct SocketAddress *src_address,
757 const struct SocketAddress *dst_address, 771 const struct SocketAddress *dst_address,
758 struct GNUNET_TUN_IPv4Header *pkt4) 772 struct GNUNET_TUN_IPv4Header *pkt4)
759{ 773{
760 size_t len; 774 size_t len;
761 775
762 len = payload_length; 776 len = payload_length;
763 switch (protocol) 777 switch (protocol)
764 { 778 {
765 case IPPROTO_UDP: 779 case IPPROTO_UDP:
766 len += sizeof(struct GNUNET_TUN_UdpHeader); 780 len += sizeof(struct GNUNET_TUN_UdpHeader);
767 break; 781 break;
768 782
769 case IPPROTO_TCP: 783 case IPPROTO_TCP:
770 len += sizeof(struct GNUNET_TUN_TcpHeader); 784 len += sizeof(struct GNUNET_TUN_TcpHeader);
771 GNUNET_assert(NULL != tcp_header); 785 GNUNET_assert (NULL != tcp_header);
772 break; 786 break;
773 787
774 default: 788 default:
775 GNUNET_break(0); 789 GNUNET_break (0);
776 return; 790 return;
777 } 791 }
778 if (len + sizeof(struct GNUNET_TUN_IPv4Header) > UINT16_MAX) 792 if (len + sizeof(struct GNUNET_TUN_IPv4Header) > UINT16_MAX)
779 { 793 {
780 GNUNET_break(0); 794 GNUNET_break (0);
781 return; 795 return;
782 } 796 }
783 797
784 GNUNET_TUN_initialize_ipv4_header(pkt4, 798 GNUNET_TUN_initialize_ipv4_header (pkt4,
785 protocol, 799 protocol,
786 len, 800 len,
787 &src_address->address.ipv4, 801 &src_address->address.ipv4,
788 &dst_address->address.ipv4); 802 &dst_address->address.ipv4);
789 switch (protocol) 803 switch (protocol)
804 {
805 case IPPROTO_UDP:
790 { 806 {
791 case IPPROTO_UDP: 807 struct GNUNET_TUN_UdpHeader *pkt4_udp = (struct
792 { 808 GNUNET_TUN_UdpHeader *) &pkt4[1];
793 struct GNUNET_TUN_UdpHeader *pkt4_udp = (struct GNUNET_TUN_UdpHeader *)&pkt4[1]; 809
794 810 pkt4_udp->source_port = htons (src_address->port);
795 pkt4_udp->source_port = htons(src_address->port); 811 pkt4_udp->destination_port = htons (dst_address->port);
796 pkt4_udp->destination_port = htons(dst_address->port); 812 pkt4_udp->len = htons ((uint16_t) payload_length);
797 pkt4_udp->len = htons((uint16_t)payload_length); 813 GNUNET_TUN_calculate_udp4_checksum (pkt4,
798 GNUNET_TUN_calculate_udp4_checksum(pkt4, 814 pkt4_udp,
799 pkt4_udp, 815 payload,
800 payload, 816 payload_length);
801 payload_length); 817 GNUNET_memcpy (&pkt4_udp[1],
802 GNUNET_memcpy(&pkt4_udp[1], 818 payload,
803 payload, 819 payload_length);
804 payload_length);
805 } 820 }
806 break; 821 break;
807 822
808 case IPPROTO_TCP: 823 case IPPROTO_TCP:
809 { 824 {
810 struct GNUNET_TUN_TcpHeader *pkt4_tcp = (struct GNUNET_TUN_TcpHeader *)&pkt4[1]; 825 struct GNUNET_TUN_TcpHeader *pkt4_tcp = (struct
826 GNUNET_TUN_TcpHeader *) &pkt4[1];
811 827
812 *pkt4_tcp = *tcp_header; 828 *pkt4_tcp = *tcp_header;
813 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 829 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
814 "Sending TCP packet from port %u to port %u\n", 830 "Sending TCP packet from port %u to port %u\n",
815 src_address->port, 831 src_address->port,
816 dst_address->port); 832 dst_address->port);
817 pkt4_tcp->source_port = htons(src_address->port); 833 pkt4_tcp->source_port = htons (src_address->port);
818 pkt4_tcp->destination_port = htons(dst_address->port); 834 pkt4_tcp->destination_port = htons (dst_address->port);
819 GNUNET_TUN_calculate_tcp4_checksum(pkt4, 835 GNUNET_TUN_calculate_tcp4_checksum (pkt4,
820 pkt4_tcp, 836 pkt4_tcp,
821 payload, 837 payload,
822 payload_length); 838 payload_length);
823 GNUNET_memcpy(&pkt4_tcp[1], 839 GNUNET_memcpy (&pkt4_tcp[1],
824 payload, 840 payload,
825 payload_length); 841 payload_length);
826 } 842 }
827 break; 843 break;
828 844
829 default: 845 default:
830 GNUNET_assert(0); 846 GNUNET_assert (0);
831 } 847 }
832} 848}
833 849
834 850
@@ -851,84 +867,86 @@ prepare_ipv4_packet(const void *payload,
851 * AND the payload 867 * AND the payload
852 */ 868 */
853static void 869static void
854prepare_ipv6_packet(const void *payload, 870prepare_ipv6_packet (const void *payload,
855 size_t payload_length, 871 size_t payload_length,
856 int protocol, 872 int protocol,
857 const struct GNUNET_TUN_TcpHeader *tcp_header, 873 const struct GNUNET_TUN_TcpHeader *tcp_header,
858 const struct SocketAddress *src_address, 874 const struct SocketAddress *src_address,
859 const struct SocketAddress *dst_address, 875 const struct SocketAddress *dst_address,
860 struct GNUNET_TUN_IPv6Header *pkt6) 876 struct GNUNET_TUN_IPv6Header *pkt6)
861{ 877{
862 size_t len; 878 size_t len;
863 879
864 len = payload_length; 880 len = payload_length;
865 switch (protocol) 881 switch (protocol)
866 { 882 {
867 case IPPROTO_UDP: 883 case IPPROTO_UDP:
868 len += sizeof(struct GNUNET_TUN_UdpHeader); 884 len += sizeof(struct GNUNET_TUN_UdpHeader);
869 break; 885 break;
870 886
871 case IPPROTO_TCP: 887 case IPPROTO_TCP:
872 len += sizeof(struct GNUNET_TUN_TcpHeader); 888 len += sizeof(struct GNUNET_TUN_TcpHeader);
873 break; 889 break;
874 890
875 default: 891 default:
876 GNUNET_break(0); 892 GNUNET_break (0);
877 return; 893 return;
878 } 894 }
879 if (len > UINT16_MAX) 895 if (len > UINT16_MAX)
880 { 896 {
881 GNUNET_break(0); 897 GNUNET_break (0);
882 return; 898 return;
883 } 899 }
884 900
885 GNUNET_TUN_initialize_ipv6_header(pkt6, 901 GNUNET_TUN_initialize_ipv6_header (pkt6,
886 protocol, 902 protocol,
887 len, 903 len,
888 &src_address->address.ipv6, 904 &src_address->address.ipv6,
889 &dst_address->address.ipv6); 905 &dst_address->address.ipv6);
890 906
891 switch (protocol) 907 switch (protocol)
908 {
909 case IPPROTO_UDP:
892 { 910 {
893 case IPPROTO_UDP: 911 struct GNUNET_TUN_UdpHeader *pkt6_udp = (struct
894 { 912 GNUNET_TUN_UdpHeader *) &pkt6[1];
895 struct GNUNET_TUN_UdpHeader *pkt6_udp = (struct GNUNET_TUN_UdpHeader *)&pkt6[1]; 913
896 914 pkt6_udp->source_port = htons (src_address->port);
897 pkt6_udp->source_port = htons(src_address->port); 915 pkt6_udp->destination_port = htons (dst_address->port);
898 pkt6_udp->destination_port = htons(dst_address->port); 916 pkt6_udp->len = htons ((uint16_t) payload_length);
899 pkt6_udp->len = htons((uint16_t)payload_length); 917 GNUNET_TUN_calculate_udp6_checksum (pkt6,
900 GNUNET_TUN_calculate_udp6_checksum(pkt6, 918 pkt6_udp,
901 pkt6_udp, 919 payload,
902 payload, 920 payload_length);
903 payload_length); 921 GNUNET_memcpy (&pkt6_udp[1],
904 GNUNET_memcpy(&pkt6_udp[1], 922 payload,
905 payload, 923 payload_length);
906 payload_length);
907 } 924 }
908 break; 925 break;
909 926
910 case IPPROTO_TCP: 927 case IPPROTO_TCP:
911 { 928 {
912 struct GNUNET_TUN_TcpHeader *pkt6_tcp = (struct GNUNET_TUN_TcpHeader *)&pkt6[1]; 929 struct GNUNET_TUN_TcpHeader *pkt6_tcp = (struct
930 GNUNET_TUN_TcpHeader *) &pkt6[1];
913 931
914 /* GNUNET_memcpy first here as some TCP header fields are initialized this way! */ 932 /* GNUNET_memcpy first here as some TCP header fields are initialized this way! */
915 *pkt6_tcp = *tcp_header; 933 *pkt6_tcp = *tcp_header;
916 pkt6_tcp->source_port = htons(src_address->port); 934 pkt6_tcp->source_port = htons (src_address->port);
917 pkt6_tcp->destination_port = htons(dst_address->port); 935 pkt6_tcp->destination_port = htons (dst_address->port);
918 GNUNET_TUN_calculate_tcp6_checksum(pkt6, 936 GNUNET_TUN_calculate_tcp6_checksum (pkt6,
919 pkt6_tcp, 937 pkt6_tcp,
920 payload, 938 payload,
921 payload_length); 939 payload_length);
922 GNUNET_memcpy(&pkt6_tcp[1], 940 GNUNET_memcpy (&pkt6_tcp[1],
923 payload, 941 payload,
924 payload_length); 942 payload_length);
925 } 943 }
926 break; 944 break;
927 945
928 default: 946 default:
929 GNUNET_assert(0); 947 GNUNET_assert (0);
930 break; 948 break;
931 } 949 }
932} 950}
933 951
934 952
@@ -942,97 +960,98 @@ prepare_ipv6_packet(const void *payload,
942 * @param payload_length number of bytes in @a payload 960 * @param payload_length number of bytes in @a payload
943 */ 961 */
944static void 962static void
945send_tcp_packet_via_tun(const struct SocketAddress *destination_address, 963send_tcp_packet_via_tun (const struct SocketAddress *destination_address,
946 const struct SocketAddress *source_address, 964 const struct SocketAddress *source_address,
947 const struct GNUNET_TUN_TcpHeader *tcp_header, 965 const struct GNUNET_TUN_TcpHeader *tcp_header,
948 const void *payload, 966 const void *payload,
949 size_t payload_length) 967 size_t payload_length)
950{ 968{
951 size_t len; 969 size_t len;
952 970
953 GNUNET_STATISTICS_update(stats, 971 GNUNET_STATISTICS_update (stats,
954 gettext_noop("# TCP packets sent via TUN"), 972 gettext_noop ("# TCP packets sent via TUN"),
955 1, 973 1,
956 GNUNET_NO); 974 GNUNET_NO);
957 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 975 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
958 "Sending packet with %u bytes TCP payload via TUN\n", 976 "Sending packet with %u bytes TCP payload via TUN\n",
959 (unsigned int)payload_length); 977 (unsigned int) payload_length);
960 len = sizeof(struct GNUNET_MessageHeader) + sizeof(struct GNUNET_TUN_Layer2PacketHeader); 978 len = sizeof(struct GNUNET_MessageHeader) + sizeof(struct
979 GNUNET_TUN_Layer2PacketHeader);
961 switch (source_address->af) 980 switch (source_address->af)
962 { 981 {
963 case AF_INET: 982 case AF_INET:
964 len += sizeof(struct GNUNET_TUN_IPv4Header); 983 len += sizeof(struct GNUNET_TUN_IPv4Header);
965 break; 984 break;
966 985
967 case AF_INET6: 986 case AF_INET6:
968 len += sizeof(struct GNUNET_TUN_IPv6Header); 987 len += sizeof(struct GNUNET_TUN_IPv6Header);
969 break; 988 break;
970 989
971 default: 990 default:
972 GNUNET_break(0); 991 GNUNET_break (0);
973 return; 992 return;
974 } 993 }
975 len += sizeof(struct GNUNET_TUN_TcpHeader); 994 len += sizeof(struct GNUNET_TUN_TcpHeader);
976 len += payload_length; 995 len += payload_length;
977 if (len >= GNUNET_MAX_MESSAGE_SIZE) 996 if (len >= GNUNET_MAX_MESSAGE_SIZE)
978 { 997 {
979 GNUNET_break(0); 998 GNUNET_break (0);
980 return; 999 return;
981 } 1000 }
982 { 1001 {
983 char buf[len] GNUNET_ALIGN; 1002 char buf[len] GNUNET_ALIGN;
984 struct GNUNET_MessageHeader *hdr; 1003 struct GNUNET_MessageHeader *hdr;
985 struct GNUNET_TUN_Layer2PacketHeader *tun; 1004 struct GNUNET_TUN_Layer2PacketHeader *tun;
986 1005
987 hdr = (struct GNUNET_MessageHeader *)buf; 1006 hdr = (struct GNUNET_MessageHeader *) buf;
988 hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_HELPER); 1007 hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
989 hdr->size = htons(len); 1008 hdr->size = htons (len);
990 tun = (struct GNUNET_TUN_Layer2PacketHeader*)&hdr[1]; 1009 tun = (struct GNUNET_TUN_Layer2PacketHeader*) &hdr[1];
991 tun->flags = htons(0); 1010 tun->flags = htons (0);
992 switch (source_address->af) 1011 switch (source_address->af)
993 { 1012 {
994 case AF_INET: 1013 case AF_INET:
995 { 1014 {
996 struct GNUNET_TUN_IPv4Header *ipv4 1015 struct GNUNET_TUN_IPv4Header *ipv4
997 = (struct GNUNET_TUN_IPv4Header*)&tun[1]; 1016 = (struct GNUNET_TUN_IPv4Header*) &tun[1];
998 1017
999 tun->proto = htons(ETH_P_IPV4); 1018 tun->proto = htons (ETH_P_IPV4);
1000 prepare_ipv4_packet(payload, 1019 prepare_ipv4_packet (payload,
1001 payload_length, 1020 payload_length,
1002 IPPROTO_TCP, 1021 IPPROTO_TCP,
1003 tcp_header, 1022 tcp_header,
1004 source_address, 1023 source_address,
1005 destination_address, 1024 destination_address,
1006 ipv4); 1025 ipv4);
1007 } 1026 }
1008 break; 1027 break;
1009 1028
1010 case AF_INET6: 1029 case AF_INET6:
1011 { 1030 {
1012 struct GNUNET_TUN_IPv6Header *ipv6 1031 struct GNUNET_TUN_IPv6Header *ipv6
1013 = (struct GNUNET_TUN_IPv6Header*)&tun[1]; 1032 = (struct GNUNET_TUN_IPv6Header*) &tun[1];
1014 1033
1015 tun->proto = htons(ETH_P_IPV6); 1034 tun->proto = htons (ETH_P_IPV6);
1016 prepare_ipv6_packet(payload, 1035 prepare_ipv6_packet (payload,
1017 payload_length, 1036 payload_length,
1018 IPPROTO_TCP, 1037 IPPROTO_TCP,
1019 tcp_header, 1038 tcp_header,
1020 source_address, 1039 source_address,
1021 destination_address, 1040 destination_address,
1022 ipv6); 1041 ipv6);
1023 } 1042 }
1024 break; 1043 break;
1025 1044
1026 default: 1045 default:
1027 GNUNET_assert(0); 1046 GNUNET_assert (0);
1028 break; 1047 break;
1029 } 1048 }
1030 if (NULL != helper_handle) 1049 if (NULL != helper_handle)
1031 (void)GNUNET_HELPER_send(helper_handle, 1050 (void) GNUNET_HELPER_send (helper_handle,
1032 (const struct GNUNET_MessageHeader*)buf, 1051 (const struct GNUNET_MessageHeader*) buf,
1033 GNUNET_YES, 1052 GNUNET_YES,
1034 NULL, 1053 NULL,
1035 NULL); 1054 NULL);
1036 } 1055 }
1037} 1056}
1038 1057
@@ -1047,98 +1066,105 @@ send_tcp_packet_via_tun(const struct SocketAddress *destination_address,
1047 * @param payload_length number of bytes of data in @a payload 1066 * @param payload_length number of bytes of data in @a payload
1048 */ 1067 */
1049static void 1068static void
1050send_icmp_packet_via_tun(const struct SocketAddress *destination_address, 1069send_icmp_packet_via_tun (const struct SocketAddress *destination_address,
1051 const struct SocketAddress *source_address, 1070 const struct SocketAddress *source_address,
1052 const struct GNUNET_TUN_IcmpHeader *icmp_header, 1071 const struct GNUNET_TUN_IcmpHeader *icmp_header,
1053 const void *payload, size_t payload_length) 1072 const void *payload, size_t payload_length)
1054{ 1073{
1055 size_t len; 1074 size_t len;
1056 struct GNUNET_TUN_IcmpHeader *icmp; 1075 struct GNUNET_TUN_IcmpHeader *icmp;
1057 1076
1058 GNUNET_STATISTICS_update(stats, 1077 GNUNET_STATISTICS_update (stats,
1059 gettext_noop("# ICMP packets sent via TUN"), 1078 gettext_noop ("# ICMP packets sent via TUN"),
1060 1, GNUNET_NO); 1079 1, GNUNET_NO);
1061 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 1080 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1062 "Sending packet with %u bytes ICMP payload via TUN\n", 1081 "Sending packet with %u bytes ICMP payload via TUN\n",
1063 (unsigned int)payload_length); 1082 (unsigned int) payload_length);
1064 len = sizeof(struct GNUNET_MessageHeader) + sizeof(struct GNUNET_TUN_Layer2PacketHeader); 1083 len = sizeof(struct GNUNET_MessageHeader) + sizeof(struct
1084 GNUNET_TUN_Layer2PacketHeader);
1065 switch (destination_address->af) 1085 switch (destination_address->af)
1066 { 1086 {
1067 case AF_INET: 1087 case AF_INET:
1068 len += sizeof(struct GNUNET_TUN_IPv4Header); 1088 len += sizeof(struct GNUNET_TUN_IPv4Header);
1069 break; 1089 break;
1070 1090
1071 case AF_INET6: 1091 case AF_INET6:
1072 len += sizeof(struct GNUNET_TUN_IPv6Header); 1092 len += sizeof(struct GNUNET_TUN_IPv6Header);
1073 break; 1093 break;
1074 1094
1075 default: 1095 default:
1076 GNUNET_break(0); 1096 GNUNET_break (0);
1077 return; 1097 return;
1078 } 1098 }
1079 len += sizeof(struct GNUNET_TUN_IcmpHeader); 1099 len += sizeof(struct GNUNET_TUN_IcmpHeader);
1080 len += payload_length; 1100 len += payload_length;
1081 if (len >= GNUNET_MAX_MESSAGE_SIZE) 1101 if (len >= GNUNET_MAX_MESSAGE_SIZE)
1082 { 1102 {
1083 GNUNET_break(0); 1103 GNUNET_break (0);
1084 return; 1104 return;
1085 } 1105 }
1086 { 1106 {
1087 char buf[len] GNUNET_ALIGN; 1107 char buf[len] GNUNET_ALIGN;
1088 struct GNUNET_MessageHeader *hdr; 1108 struct GNUNET_MessageHeader *hdr;
1089 struct GNUNET_TUN_Layer2PacketHeader *tun; 1109 struct GNUNET_TUN_Layer2PacketHeader *tun;
1090 1110
1091 hdr = (struct GNUNET_MessageHeader *)buf; 1111 hdr = (struct GNUNET_MessageHeader *) buf;
1092 hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_HELPER); 1112 hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
1093 hdr->size = htons(len); 1113 hdr->size = htons (len);
1094 tun = (struct GNUNET_TUN_Layer2PacketHeader*)&hdr[1]; 1114 tun = (struct GNUNET_TUN_Layer2PacketHeader*) &hdr[1];
1095 tun->flags = htons(0); 1115 tun->flags = htons (0);
1096 switch (source_address->af) 1116 switch (source_address->af)
1117 {
1118 case AF_INET:
1097 { 1119 {
1098 case AF_INET: 1120 struct GNUNET_TUN_IPv4Header *ipv4 = (struct
1099 { 1121 GNUNET_TUN_IPv4Header*) &tun[1];
1100 struct GNUNET_TUN_IPv4Header * ipv4 = (struct GNUNET_TUN_IPv4Header*)&tun[1]; 1122
1101 1123 tun->proto = htons (ETH_P_IPV4);
1102 tun->proto = htons(ETH_P_IPV4); 1124 GNUNET_TUN_initialize_ipv4_header (ipv4,
1103 GNUNET_TUN_initialize_ipv4_header(ipv4, 1125 IPPROTO_ICMP,
1104 IPPROTO_ICMP, 1126 sizeof(struct
1105 sizeof(struct GNUNET_TUN_IcmpHeader) + payload_length, 1127 GNUNET_TUN_IcmpHeader)
1106 &source_address->address.ipv4, 1128 + payload_length,
1107 &destination_address->address.ipv4); 1129 &source_address->address.ipv4,
1108 icmp = (struct GNUNET_TUN_IcmpHeader*)&ipv4[1]; 1130 &destination_address->address.ipv4);
1131 icmp = (struct GNUNET_TUN_IcmpHeader*) &ipv4[1];
1109 } 1132 }
1110 break; 1133 break;
1111 1134
1112 case AF_INET6: 1135 case AF_INET6:
1113 { 1136 {
1114 struct GNUNET_TUN_IPv6Header * ipv6 = (struct GNUNET_TUN_IPv6Header*)&tun[1]; 1137 struct GNUNET_TUN_IPv6Header *ipv6 = (struct
1115 1138 GNUNET_TUN_IPv6Header*) &tun[1];
1116 tun->proto = htons(ETH_P_IPV6); 1139
1117 GNUNET_TUN_initialize_ipv6_header(ipv6, 1140 tun->proto = htons (ETH_P_IPV6);
1118 IPPROTO_ICMPV6, 1141 GNUNET_TUN_initialize_ipv6_header (ipv6,
1119 sizeof(struct GNUNET_TUN_IcmpHeader) + payload_length, 1142 IPPROTO_ICMPV6,
1120 &source_address->address.ipv6, 1143 sizeof(struct
1121 &destination_address->address.ipv6); 1144 GNUNET_TUN_IcmpHeader)
1122 icmp = (struct GNUNET_TUN_IcmpHeader*)&ipv6[1]; 1145 + payload_length,
1146 &source_address->address.ipv6,
1147 &destination_address->address.ipv6);
1148 icmp = (struct GNUNET_TUN_IcmpHeader*) &ipv6[1];
1123 } 1149 }
1124 break; 1150 break;
1125 1151
1126 default: 1152 default:
1127 GNUNET_assert(0); 1153 GNUNET_assert (0);
1128 break; 1154 break;
1129 } 1155 }
1130 *icmp = *icmp_header; 1156 *icmp = *icmp_header;
1131 GNUNET_memcpy(&icmp[1], 1157 GNUNET_memcpy (&icmp[1],
1132 payload, 1158 payload,
1133 payload_length); 1159 payload_length);
1134 GNUNET_TUN_calculate_icmp_checksum(icmp, 1160 GNUNET_TUN_calculate_icmp_checksum (icmp,
1135 payload, 1161 payload,
1136 payload_length); 1162 payload_length);
1137 if (NULL != helper_handle) 1163 if (NULL != helper_handle)
1138 (void)GNUNET_HELPER_send(helper_handle, 1164 (void) GNUNET_HELPER_send (helper_handle,
1139 (const struct GNUNET_MessageHeader*)buf, 1165 (const struct GNUNET_MessageHeader*) buf,
1140 GNUNET_YES, 1166 GNUNET_YES,
1141 NULL, NULL); 1167 NULL, NULL);
1142 } 1168 }
1143} 1169}
1144 1170
@@ -1152,12 +1178,12 @@ send_icmp_packet_via_tun(const struct SocketAddress *destination_address,
1152 * @param local_address address to initialize 1178 * @param local_address address to initialize
1153 */ 1179 */
1154static void 1180static void
1155setup_fresh_address(int af, 1181setup_fresh_address (int af,
1156 uint8_t proto, 1182 uint8_t proto,
1157 struct SocketAddress *local_address) 1183 struct SocketAddress *local_address)
1158{ 1184{
1159 local_address->af = af; 1185 local_address->af = af;
1160 local_address->proto = (uint8_t)proto; 1186 local_address->proto = (uint8_t) proto;
1161 /* default "local" port range is often 32768--61000, 1187 /* default "local" port range is often 32768--61000,
1162 so we pick a random value in that range */ 1188 so we pick a random value in that range */
1163 if (((af == AF_INET) && (proto == IPPROTO_ICMP)) || 1189 if (((af == AF_INET) && (proto == IPPROTO_ICMP)) ||
@@ -1165,11 +1191,11 @@ setup_fresh_address(int af,
1165 local_address->port = 0; 1191 local_address->port = 0;
1166 else 1192 else
1167 local_address->port 1193 local_address->port
1168 = (uint16_t)32768 + GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 1194 = (uint16_t) 32768 + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
1169 28232); 1195 28232);
1170 switch (af) 1196 switch (af)
1171 { 1197 {
1172 case AF_INET: 1198 case AF_INET:
1173 { 1199 {
1174 struct in_addr addr; 1200 struct in_addr addr;
1175 struct in_addr mask; 1201 struct in_addr mask;
@@ -1178,27 +1204,28 @@ setup_fresh_address(int af,
1178 addr = exit_ipv4addr; 1204 addr = exit_ipv4addr;
1179 mask = exit_ipv4mask; 1205 mask = exit_ipv4mask;
1180 if (0 == ~mask.s_addr) 1206 if (0 == ~mask.s_addr)
1181 { 1207 {
1182 /* only one valid IP anyway */ 1208 /* only one valid IP anyway */
1183 local_address->address.ipv4 = addr; 1209 local_address->address.ipv4 = addr;
1184 return; 1210 return;
1185 } 1211 }
1186 /* Given 192.168.0.1/255.255.0.0, we want a mask 1212 /* Given 192.168.0.1/255.255.0.0, we want a mask
1187 of '192.168.255.255', thus: */ 1213 of '192.168.255.255', thus: */
1188 mask.s_addr = addr.s_addr | ~mask.s_addr; 1214 mask.s_addr = addr.s_addr | ~mask.s_addr;
1189 /* Pick random IPv4 address within the subnet, except 'addr' or 'mask' itself */ 1215 /* Pick random IPv4 address within the subnet, except 'addr' or 'mask' itself */
1190 do 1216 do
1191 { 1217 {
1192 rnd.s_addr = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 1218 rnd.s_addr = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
1193 UINT32_MAX); 1219 UINT32_MAX);
1194 local_address->address.ipv4.s_addr = (addr.s_addr | rnd.s_addr) & mask.s_addr; 1220 local_address->address.ipv4.s_addr = (addr.s_addr | rnd.s_addr)
1195 } 1221 & mask.s_addr;
1222 }
1196 while ((local_address->address.ipv4.s_addr == addr.s_addr) || 1223 while ((local_address->address.ipv4.s_addr == addr.s_addr) ||
1197 (local_address->address.ipv4.s_addr == mask.s_addr)); 1224 (local_address->address.ipv4.s_addr == mask.s_addr));
1198 } 1225 }
1199 break; 1226 break;
1200 1227
1201 case AF_INET6: 1228 case AF_INET6:
1202 { 1229 {
1203 struct in6_addr addr; 1230 struct in6_addr addr;
1204 struct in6_addr mask; 1231 struct in6_addr mask;
@@ -1206,13 +1233,13 @@ setup_fresh_address(int af,
1206 int i; 1233 int i;
1207 1234
1208 addr = exit_ipv6addr; 1235 addr = exit_ipv6addr;
1209 GNUNET_assert(ipv6prefix < 128); 1236 GNUNET_assert (ipv6prefix < 128);
1210 if (ipv6prefix == 127) 1237 if (ipv6prefix == 127)
1211 { 1238 {
1212 /* only one valid IP anyway */ 1239 /* only one valid IP anyway */
1213 local_address->address.ipv6 = addr; 1240 local_address->address.ipv6 = addr;
1214 return; 1241 return;
1215 } 1242 }
1216 /* Given ABCD::/96, we want a mask of 'ABCD::FFFF:FFFF, 1243 /* Given ABCD::/96, we want a mask of 'ABCD::FFFF:FFFF,
1217 thus: */ 1244 thus: */
1218 mask = addr; 1245 mask = addr;
@@ -1221,25 +1248,26 @@ setup_fresh_address(int af,
1221 1248
1222 /* Pick random IPv6 address within the subnet, except 'addr' or 'mask' itself */ 1249 /* Pick random IPv6 address within the subnet, except 'addr' or 'mask' itself */
1223 do 1250 do
1251 {
1252 for (i = 0; i < 16; i++)
1224 { 1253 {
1225 for (i = 0; i < 16; i++) 1254 rnd.s6_addr[i] = (unsigned char) GNUNET_CRYPTO_random_u32 (
1226 { 1255 GNUNET_CRYPTO_QUALITY_WEAK,
1227 rnd.s6_addr[i] = (unsigned char)GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 1256 256);
1228 256); 1257 local_address->address.ipv6.s6_addr[i]
1229 local_address->address.ipv6.s6_addr[i] 1258 = (addr.s6_addr[i] | rnd.s6_addr[i]) & mask.s6_addr[i];
1230 = (addr.s6_addr[i] | rnd.s6_addr[i]) & mask.s6_addr[i];
1231 }
1232 } 1259 }
1233 while ((0 == GNUNET_memcmp(&local_address->address.ipv6, 1260 }
1234 &addr)) || 1261 while ((0 == GNUNET_memcmp (&local_address->address.ipv6,
1235 (0 == GNUNET_memcmp(&local_address->address.ipv6, 1262 &addr)) ||
1236 &mask))); 1263 (0 == GNUNET_memcmp (&local_address->address.ipv6,
1264 &mask)));
1237 } 1265 }
1238 break; 1266 break;
1239 1267
1240 default: 1268 default:
1241 GNUNET_assert(0); 1269 GNUNET_assert (0);
1242 } 1270 }
1243} 1271}
1244 1272
1245 1273
@@ -1265,62 +1293,63 @@ setup_fresh_address(int af,
1265 * used to test if a state has been fully setup). 1293 * used to test if a state has been fully setup).
1266 */ 1294 */
1267static void 1295static void
1268setup_state_record(struct ChannelState *state) 1296setup_state_record (struct ChannelState *state)
1269{ 1297{
1270 struct GNUNET_HashCode key; 1298 struct GNUNET_HashCode key;
1271 struct ChannelState *s; 1299 struct ChannelState *s;
1272 1300
1273 /* generate fresh, unique address */ 1301 /* generate fresh, unique address */
1274 do 1302 do
1275 { 1303 {
1276 if (NULL == state->specifics.tcp_udp.serv) 1304 if (NULL == state->specifics.tcp_udp.serv)
1277 setup_fresh_address(state->specifics.tcp_udp.ri.remote_address.af, 1305 setup_fresh_address (state->specifics.tcp_udp.ri.remote_address.af,
1278 state->specifics.tcp_udp.ri.remote_address.proto, 1306 state->specifics.tcp_udp.ri.remote_address.proto,
1279 &state->specifics.tcp_udp.ri.local_address); 1307 &state->specifics.tcp_udp.ri.local_address);
1280 else 1308 else
1281 setup_fresh_address(state->specifics.tcp_udp.serv->address.af, 1309 setup_fresh_address (state->specifics.tcp_udp.serv->address.af,
1282 state->specifics.tcp_udp.serv->address.proto, 1310 state->specifics.tcp_udp.serv->address.proto,
1283 &state->specifics.tcp_udp.ri.local_address); 1311 &state->specifics.tcp_udp.ri.local_address);
1284 } 1312 }
1285 while (NULL != 1313 while (NULL !=
1286 get_redirect_state(state->specifics.tcp_udp.ri.remote_address.af, 1314 get_redirect_state (state->specifics.tcp_udp.ri.remote_address.af,
1287 state->specifics.tcp_udp.ri.remote_address.proto, 1315 state->specifics.tcp_udp.ri.remote_address.proto,
1288 &state->specifics.tcp_udp.ri.remote_address.address, 1316 &state->specifics.tcp_udp.ri.remote_address.address,
1289 state->specifics.tcp_udp.ri.remote_address.port, 1317 state->specifics.tcp_udp.ri.remote_address.port,
1290 &state->specifics.tcp_udp.ri.local_address.address, 1318 &state->specifics.tcp_udp.ri.local_address.address,
1291 state->specifics.tcp_udp.ri.local_address.port, 1319 state->specifics.tcp_udp.ri.local_address.port,
1292 &key)); 1320 &key));
1293 { 1321 {
1294 char buf[INET6_ADDRSTRLEN]; 1322 char buf[INET6_ADDRSTRLEN];
1295 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 1323 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1296 "Picked local address %s:%u for new connection\n", 1324 "Picked local address %s:%u for new connection\n",
1297 inet_ntop(state->specifics.tcp_udp.ri.local_address.af, 1325 inet_ntop (state->specifics.tcp_udp.ri.local_address.af,
1298 &state->specifics.tcp_udp.ri.local_address.address, 1326 &state->specifics.tcp_udp.ri.local_address.address,
1299 buf, 1327 buf,
1300 sizeof(buf)), 1328 sizeof(buf)),
1301 (unsigned int)state->specifics.tcp_udp.ri.local_address.port); 1329 (unsigned int) state->specifics.tcp_udp.ri.local_address.port);
1302 } 1330 }
1303 state->specifics.tcp_udp.state_key = key; 1331 state->specifics.tcp_udp.state_key = key;
1304 GNUNET_assert(GNUNET_OK == 1332 GNUNET_assert (GNUNET_OK ==
1305 GNUNET_CONTAINER_multihashmap_put(connections_map, 1333 GNUNET_CONTAINER_multihashmap_put (connections_map,
1306 &key, state, 1334 &key, state,
1307 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); 1335 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
1308 state->specifics.tcp_udp.heap_node 1336 state->specifics.tcp_udp.heap_node
1309 = GNUNET_CONTAINER_heap_insert(connections_heap, 1337 = GNUNET_CONTAINER_heap_insert (connections_heap,
1310 state, 1338 state,
1311 GNUNET_TIME_absolute_get().abs_value_us); 1339 GNUNET_TIME_absolute_get ().abs_value_us);
1312 while (GNUNET_CONTAINER_heap_get_size(connections_heap) > max_connections) 1340 while (GNUNET_CONTAINER_heap_get_size (connections_heap) > max_connections)
1313 { 1341 {
1314 s = GNUNET_CONTAINER_heap_remove_root(connections_heap); 1342 s = GNUNET_CONTAINER_heap_remove_root (connections_heap);
1315 GNUNET_assert(state != s); 1343 GNUNET_assert (state != s);
1316 s->specifics.tcp_udp.heap_node = NULL; 1344 s->specifics.tcp_udp.heap_node = NULL;
1317 GNUNET_CADET_channel_destroy(s->channel); 1345 GNUNET_CADET_channel_destroy (s->channel);
1318 GNUNET_assert(GNUNET_OK == 1346 GNUNET_assert (GNUNET_OK ==
1319 GNUNET_CONTAINER_multihashmap_remove(connections_map, 1347 GNUNET_CONTAINER_multihashmap_remove (connections_map,
1320 &s->specifics.tcp_udp.state_key, 1348 &s->specifics.tcp_udp.
1349 state_key,
1321 s)); 1350 s));
1322 GNUNET_free(s); 1351 GNUNET_free (s);
1323 } 1352 }
1324} 1353}
1325 1354
1326 1355
@@ -1333,91 +1362,94 @@ setup_state_record(struct ChannelState *state)
1333 * @param payload_length number of bytes of data in @a payload 1362 * @param payload_length number of bytes of data in @a payload
1334 */ 1363 */
1335static void 1364static void
1336send_udp_packet_via_tun(const struct SocketAddress *destination_address, 1365send_udp_packet_via_tun (const struct SocketAddress *destination_address,
1337 const struct SocketAddress *source_address, 1366 const struct SocketAddress *source_address,
1338 const void *payload, size_t payload_length) 1367 const void *payload, size_t payload_length)
1339{ 1368{
1340 size_t len; 1369 size_t len;
1341 1370
1342 GNUNET_STATISTICS_update(stats, 1371 GNUNET_STATISTICS_update (stats,
1343 gettext_noop("# UDP packets sent via TUN"), 1372 gettext_noop ("# UDP packets sent via TUN"),
1344 1, GNUNET_NO); 1373 1, GNUNET_NO);
1345 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 1374 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1346 "Sending packet with %u bytes UDP payload via TUN\n", 1375 "Sending packet with %u bytes UDP payload via TUN\n",
1347 (unsigned int)payload_length); 1376 (unsigned int) payload_length);
1348 len = sizeof(struct GNUNET_MessageHeader) + sizeof(struct GNUNET_TUN_Layer2PacketHeader); 1377 len = sizeof(struct GNUNET_MessageHeader) + sizeof(struct
1378 GNUNET_TUN_Layer2PacketHeader);
1349 switch (source_address->af) 1379 switch (source_address->af)
1350 { 1380 {
1351 case AF_INET: 1381 case AF_INET:
1352 len += sizeof(struct GNUNET_TUN_IPv4Header); 1382 len += sizeof(struct GNUNET_TUN_IPv4Header);
1353 break; 1383 break;
1354 1384
1355 case AF_INET6: 1385 case AF_INET6:
1356 len += sizeof(struct GNUNET_TUN_IPv6Header); 1386 len += sizeof(struct GNUNET_TUN_IPv6Header);
1357 break; 1387 break;
1358 1388
1359 default: 1389 default:
1360 GNUNET_break(0); 1390 GNUNET_break (0);
1361 return; 1391 return;
1362 } 1392 }
1363 len += sizeof(struct GNUNET_TUN_UdpHeader); 1393 len += sizeof(struct GNUNET_TUN_UdpHeader);
1364 len += payload_length; 1394 len += payload_length;
1365 if (len >= GNUNET_MAX_MESSAGE_SIZE) 1395 if (len >= GNUNET_MAX_MESSAGE_SIZE)
1366 { 1396 {
1367 GNUNET_break(0); 1397 GNUNET_break (0);
1368 return; 1398 return;
1369 } 1399 }
1370 { 1400 {
1371 char buf[len] GNUNET_ALIGN; 1401 char buf[len] GNUNET_ALIGN;
1372 struct GNUNET_MessageHeader *hdr; 1402 struct GNUNET_MessageHeader *hdr;
1373 struct GNUNET_TUN_Layer2PacketHeader *tun; 1403 struct GNUNET_TUN_Layer2PacketHeader *tun;
1374 1404
1375 hdr = (struct GNUNET_MessageHeader *)buf; 1405 hdr = (struct GNUNET_MessageHeader *) buf;
1376 hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_HELPER); 1406 hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
1377 hdr->size = htons(len); 1407 hdr->size = htons (len);
1378 tun = (struct GNUNET_TUN_Layer2PacketHeader*)&hdr[1]; 1408 tun = (struct GNUNET_TUN_Layer2PacketHeader*) &hdr[1];
1379 tun->flags = htons(0); 1409 tun->flags = htons (0);
1380 switch (source_address->af) 1410 switch (source_address->af)
1411 {
1412 case AF_INET:
1381 { 1413 {
1382 case AF_INET: 1414 struct GNUNET_TUN_IPv4Header *ipv4 = (struct
1383 { 1415 GNUNET_TUN_IPv4Header*) &tun[1];
1384 struct GNUNET_TUN_IPv4Header * ipv4 = (struct GNUNET_TUN_IPv4Header*)&tun[1]; 1416
1385 1417 tun->proto = htons (ETH_P_IPV4);
1386 tun->proto = htons(ETH_P_IPV4); 1418 prepare_ipv4_packet (payload,
1387 prepare_ipv4_packet(payload, 1419 payload_length,
1388 payload_length, 1420 IPPROTO_UDP,
1389 IPPROTO_UDP, 1421 NULL,
1390 NULL, 1422 source_address,
1391 source_address, 1423 destination_address,
1392 destination_address, 1424 ipv4);
1393 ipv4);
1394 } 1425 }
1395 break; 1426 break;
1396 1427
1397 case AF_INET6: 1428 case AF_INET6:
1398 { 1429 {
1399 struct GNUNET_TUN_IPv6Header * ipv6 = (struct GNUNET_TUN_IPv6Header*)&tun[1]; 1430 struct GNUNET_TUN_IPv6Header *ipv6 = (struct
1400 1431 GNUNET_TUN_IPv6Header*) &tun[1];
1401 tun->proto = htons(ETH_P_IPV6); 1432
1402 prepare_ipv6_packet(payload, 1433 tun->proto = htons (ETH_P_IPV6);
1403 payload_length, 1434 prepare_ipv6_packet (payload,
1404 IPPROTO_UDP, 1435 payload_length,
1405 NULL, 1436 IPPROTO_UDP,
1406 source_address, 1437 NULL,
1407 destination_address, 1438 source_address,
1408 ipv6); 1439 destination_address,
1440 ipv6);
1409 } 1441 }
1410 break; 1442 break;
1411 1443
1412 default: 1444 default:
1413 GNUNET_assert(0); 1445 GNUNET_assert (0);
1414 break; 1446 break;
1415 } 1447 }
1416 if (NULL != helper_handle) 1448 if (NULL != helper_handle)
1417 (void)GNUNET_HELPER_send(helper_handle, 1449 (void) GNUNET_HELPER_send (helper_handle,
1418 (const struct GNUNET_MessageHeader*)buf, 1450 (const struct GNUNET_MessageHeader*) buf,
1419 GNUNET_YES, 1451 GNUNET_YES,
1420 NULL, NULL); 1452 NULL, NULL);
1421 } 1453 }
1422} 1454}
1423 1455
@@ -1431,16 +1463,16 @@ send_udp_packet_via_tun(const struct SocketAddress *destination_address,
1431 * #GNUNET_SYSERR to close it (signal serious error) 1463 * #GNUNET_SYSERR to close it (signal serious error)
1432 */ 1464 */
1433static int 1465static int
1434check_udp_remote(void *cls, 1466check_udp_remote (void *cls,
1435 const struct GNUNET_EXIT_UdpInternetMessage *msg) 1467 const struct GNUNET_EXIT_UdpInternetMessage *msg)
1436{ 1468{
1437 struct ChannelState *state = cls; 1469 struct ChannelState *state = cls;
1438 1470
1439 if (GNUNET_YES == state->is_dns) 1471 if (GNUNET_YES == state->is_dns)
1440 { 1472 {
1441 GNUNET_break_op(0); 1473 GNUNET_break_op (0);
1442 return GNUNET_SYSERR; 1474 return GNUNET_SYSERR;
1443 } 1475 }
1444 return GNUNET_OK; 1476 return GNUNET_OK;
1445} 1477}
1446 1478
@@ -1452,90 +1484,92 @@ check_udp_remote(void *cls,
1452 * @param msg the actual message 1484 * @param msg the actual message
1453 */ 1485 */
1454static void 1486static void
1455handle_udp_remote(void *cls, 1487handle_udp_remote (void *cls,
1456 const struct GNUNET_EXIT_UdpInternetMessage *msg) 1488 const struct GNUNET_EXIT_UdpInternetMessage *msg)
1457{ 1489{
1458 struct ChannelState *state = cls; 1490 struct ChannelState *state = cls;
1459 uint16_t pkt_len = ntohs(msg->header.size) - sizeof(struct GNUNET_EXIT_UdpInternetMessage); 1491 uint16_t pkt_len = ntohs (msg->header.size) - sizeof(struct
1492 GNUNET_EXIT_UdpInternetMessage);
1460 const struct in_addr *v4; 1493 const struct in_addr *v4;
1461 const struct in6_addr *v6; 1494 const struct in6_addr *v6;
1462 const void *payload; 1495 const void *payload;
1463 int af; 1496 int af;
1464 1497
1465 if (GNUNET_SYSERR == state->is_dns) 1498 if (GNUNET_SYSERR == state->is_dns)
1466 { 1499 {
1467 /* channel is UDP/TCP from now on */ 1500 /* channel is UDP/TCP from now on */
1468 state->is_dns = GNUNET_NO; 1501 state->is_dns = GNUNET_NO;
1469 } 1502 }
1470 GNUNET_STATISTICS_update(stats, 1503 GNUNET_STATISTICS_update (stats,
1471 gettext_noop("# Bytes received from CADET"), 1504 gettext_noop ("# Bytes received from CADET"),
1472 pkt_len, GNUNET_NO); 1505 pkt_len, GNUNET_NO);
1473 GNUNET_STATISTICS_update(stats, 1506 GNUNET_STATISTICS_update (stats,
1474 gettext_noop("# UDP IP-exit requests received via cadet"), 1507 gettext_noop (
1475 1, GNUNET_NO); 1508 "# UDP IP-exit requests received via cadet"),
1476 af = (int)ntohl(msg->af); 1509 1, GNUNET_NO);
1510 af = (int) ntohl (msg->af);
1477 state->specifics.tcp_udp.ri.remote_address.af = af; 1511 state->specifics.tcp_udp.ri.remote_address.af = af;
1478 switch (af) 1512 switch (af)
1513 {
1514 case AF_INET:
1515 if (pkt_len < sizeof(struct in_addr))
1479 { 1516 {
1480 case AF_INET: 1517 GNUNET_break_op (0);
1481 if (pkt_len < sizeof(struct in_addr)) 1518 return;
1482 { 1519 }
1483 GNUNET_break_op(0); 1520 if (! ipv4_exit)
1484 return; 1521 {
1485 } 1522 GNUNET_break_op (0);
1486 if (!ipv4_exit) 1523 return;
1487 { 1524 }
1488 GNUNET_break_op(0); 1525 v4 = (const struct in_addr*) &msg[1];
1489 return; 1526 payload = &v4[1];
1490 } 1527 pkt_len -= sizeof(struct in_addr);
1491 v4 = (const struct in_addr*)&msg[1]; 1528 state->specifics.tcp_udp.ri.remote_address.address.ipv4 = *v4;
1492 payload = &v4[1]; 1529 break;
1493 pkt_len -= sizeof(struct in_addr);
1494 state->specifics.tcp_udp.ri.remote_address.address.ipv4 = *v4;
1495 break;
1496
1497 case AF_INET6:
1498 if (pkt_len < sizeof(struct in6_addr))
1499 {
1500 GNUNET_break_op(0);
1501 return;
1502 }
1503 if (!ipv6_exit)
1504 {
1505 GNUNET_break_op(0);
1506 return;
1507 }
1508 v6 = (const struct in6_addr*)&msg[1];
1509 payload = &v6[1];
1510 pkt_len -= sizeof(struct in6_addr);
1511 state->specifics.tcp_udp.ri.remote_address.address.ipv6 = *v6;
1512 break;
1513 1530
1514 default: 1531 case AF_INET6:
1515 GNUNET_break_op(0); 1532 if (pkt_len < sizeof(struct in6_addr))
1533 {
1534 GNUNET_break_op (0);
1535 return;
1536 }
1537 if (! ipv6_exit)
1538 {
1539 GNUNET_break_op (0);
1516 return; 1540 return;
1517 } 1541 }
1542 v6 = (const struct in6_addr*) &msg[1];
1543 payload = &v6[1];
1544 pkt_len -= sizeof(struct in6_addr);
1545 state->specifics.tcp_udp.ri.remote_address.address.ipv6 = *v6;
1546 break;
1547
1548 default:
1549 GNUNET_break_op (0);
1550 return;
1551 }
1518 { 1552 {
1519 char buf[INET6_ADDRSTRLEN]; 1553 char buf[INET6_ADDRSTRLEN];
1520 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 1554 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1521 "Received data from %s for forwarding to UDP %s:%u\n", 1555 "Received data from %s for forwarding to UDP %s:%u\n",
1522 GNUNET_i2s(&state->peer), 1556 GNUNET_i2s (&state->peer),
1523 inet_ntop(af, 1557 inet_ntop (af,
1524 &state->specifics.tcp_udp.ri.remote_address.address, 1558 &state->specifics.tcp_udp.ri.remote_address.address,
1525 buf, sizeof(buf)), 1559 buf, sizeof(buf)),
1526 (unsigned int)ntohs(msg->destination_port)); 1560 (unsigned int) ntohs (msg->destination_port));
1527 } 1561 }
1528 state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_UDP; 1562 state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_UDP;
1529 state->specifics.tcp_udp.ri.remote_address.port = msg->destination_port; 1563 state->specifics.tcp_udp.ri.remote_address.port = msg->destination_port;
1530 if (NULL == state->specifics.tcp_udp.heap_node) 1564 if (NULL == state->specifics.tcp_udp.heap_node)
1531 setup_state_record(state); 1565 setup_state_record (state);
1532 if (0 != ntohs(msg->source_port)) 1566 if (0 != ntohs (msg->source_port))
1533 state->specifics.tcp_udp.ri.local_address.port = msg->source_port; 1567 state->specifics.tcp_udp.ri.local_address.port = msg->source_port;
1534 send_udp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address, 1568 send_udp_packet_via_tun (&state->specifics.tcp_udp.ri.remote_address,
1535 &state->specifics.tcp_udp.ri.local_address, 1569 &state->specifics.tcp_udp.ri.local_address,
1536 payload, 1570 payload,
1537 pkt_len); 1571 pkt_len);
1538 GNUNET_CADET_receive_done(state->channel); 1572 GNUNET_CADET_receive_done (state->channel);
1539} 1573}
1540 1574
1541 1575
@@ -1549,16 +1583,16 @@ handle_udp_remote(void *cls,
1549 * #GNUNET_SYSERR to close it (signal serious error) 1583 * #GNUNET_SYSERR to close it (signal serious error)
1550 */ 1584 */
1551static int 1585static int
1552check_udp_service(void *cls, 1586check_udp_service (void *cls,
1553 const struct GNUNET_EXIT_UdpServiceMessage *msg) 1587 const struct GNUNET_EXIT_UdpServiceMessage *msg)
1554{ 1588{
1555 struct ChannelState *state = cls; 1589 struct ChannelState *state = cls;
1556 1590
1557 if (NULL == state->specifics.tcp_udp.serv) 1591 if (NULL == state->specifics.tcp_udp.serv)
1558 { 1592 {
1559 GNUNET_break_op(0); 1593 GNUNET_break_op (0);
1560 return GNUNET_SYSERR; 1594 return GNUNET_SYSERR;
1561 } 1595 }
1562 return GNUNET_OK; 1596 return GNUNET_OK;
1563} 1597}
1564 1598
@@ -1571,31 +1605,33 @@ check_udp_service(void *cls,
1571 * @param msg the actual message 1605 * @param msg the actual message
1572 */ 1606 */
1573static void 1607static void
1574handle_udp_service(void *cls, 1608handle_udp_service (void *cls,
1575 const struct GNUNET_EXIT_UdpServiceMessage *msg) 1609 const struct GNUNET_EXIT_UdpServiceMessage *msg)
1576{ 1610{
1577 struct ChannelState *state = cls; 1611 struct ChannelState *state = cls;
1578 uint16_t pkt_len = ntohs(msg->header.size) - sizeof(struct GNUNET_EXIT_UdpServiceMessage); 1612 uint16_t pkt_len = ntohs (msg->header.size) - sizeof(struct
1579 1613 GNUNET_EXIT_UdpServiceMessage);
1580 GNUNET_STATISTICS_update(stats, 1614
1581 gettext_noop("# Bytes received from CADET"), 1615 GNUNET_STATISTICS_update (stats,
1582 pkt_len, GNUNET_NO); 1616 gettext_noop ("# Bytes received from CADET"),
1583 GNUNET_STATISTICS_update(stats, 1617 pkt_len, GNUNET_NO);
1584 gettext_noop("# UDP service requests received via cadet"), 1618 GNUNET_STATISTICS_update (stats,
1585 1, GNUNET_NO); 1619 gettext_noop (
1586 LOG(GNUNET_ERROR_TYPE_DEBUG, 1620 "# UDP service requests received via cadet"),
1587 "Received data from %s for forwarding to UDP service %s on port %u\n", 1621 1, GNUNET_NO);
1588 GNUNET_i2s(&state->peer), 1622 LOG (GNUNET_ERROR_TYPE_DEBUG,
1589 GNUNET_h2s(&state->specifics.tcp_udp.serv->descriptor), 1623 "Received data from %s for forwarding to UDP service %s on port %u\n",
1590 (unsigned int)ntohs(msg->destination_port)); 1624 GNUNET_i2s (&state->peer),
1591 setup_state_record(state); 1625 GNUNET_h2s (&state->specifics.tcp_udp.serv->descriptor),
1592 if (0 != ntohs(msg->source_port)) 1626 (unsigned int) ntohs (msg->destination_port));
1627 setup_state_record (state);
1628 if (0 != ntohs (msg->source_port))
1593 state->specifics.tcp_udp.ri.local_address.port = msg->source_port; 1629 state->specifics.tcp_udp.ri.local_address.port = msg->source_port;
1594 send_udp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address, 1630 send_udp_packet_via_tun (&state->specifics.tcp_udp.ri.remote_address,
1595 &state->specifics.tcp_udp.ri.local_address, 1631 &state->specifics.tcp_udp.ri.local_address,
1596 &msg[1], 1632 &msg[1],
1597 pkt_len); 1633 pkt_len);
1598 GNUNET_CADET_receive_done(state->channel); 1634 GNUNET_CADET_receive_done (state->channel);
1599} 1635}
1600 1636
1601 1637
@@ -1609,39 +1645,41 @@ handle_udp_service(void *cls,
1609 * #GNUNET_SYSERR to close it (signal serious error) 1645 * #GNUNET_SYSERR to close it (signal serious error)
1610 */ 1646 */
1611static void 1647static void
1612handle_tcp_service(void *cls, 1648handle_tcp_service (void *cls,
1613 const struct GNUNET_EXIT_TcpServiceStartMessage *start) 1649 const struct GNUNET_EXIT_TcpServiceStartMessage *start)
1614{ 1650{
1615 struct ChannelState *state = cls; 1651 struct ChannelState *state = cls;
1616 uint16_t pkt_len = ntohs(start->header.size) - sizeof(struct GNUNET_EXIT_TcpServiceStartMessage); 1652 uint16_t pkt_len = ntohs (start->header.size) - sizeof(struct
1653 GNUNET_EXIT_TcpServiceStartMessage);
1617 1654
1618 if (GNUNET_SYSERR == state->is_dns) 1655 if (GNUNET_SYSERR == state->is_dns)
1619 { 1656 {
1620 /* channel is UDP/TCP from now on */ 1657 /* channel is UDP/TCP from now on */
1621 state->is_dns = GNUNET_NO; 1658 state->is_dns = GNUNET_NO;
1622 } 1659 }
1623 GNUNET_STATISTICS_update(stats, 1660 GNUNET_STATISTICS_update (stats,
1624 gettext_noop("# TCP service creation requests received via cadet"), 1661 gettext_noop (
1625 1, 1662 "# TCP service creation requests received via cadet"),
1626 GNUNET_NO); 1663 1,
1627 GNUNET_STATISTICS_update(stats, 1664 GNUNET_NO);
1628 gettext_noop("# Bytes received from CADET"), 1665 GNUNET_STATISTICS_update (stats,
1629 pkt_len, 1666 gettext_noop ("# Bytes received from CADET"),
1630 GNUNET_NO); 1667 pkt_len,
1631 GNUNET_break_op(ntohl(start->reserved) == 0); 1668 GNUNET_NO);
1669 GNUNET_break_op (ntohl (start->reserved) == 0);
1632 /* setup fresh connection */ 1670 /* setup fresh connection */
1633 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 1671 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1634 "Received data from %s for forwarding to TCP service %s on port %u\n", 1672 "Received data from %s for forwarding to TCP service %s on port %u\n",
1635 GNUNET_i2s(&state->peer), 1673 GNUNET_i2s (&state->peer),
1636 GNUNET_h2s(&state->specifics.tcp_udp.serv->descriptor), 1674 GNUNET_h2s (&state->specifics.tcp_udp.serv->descriptor),
1637 (unsigned int)ntohs(start->tcp_header.destination_port)); 1675 (unsigned int) ntohs (start->tcp_header.destination_port));
1638 setup_state_record(state); 1676 setup_state_record (state);
1639 send_tcp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address, 1677 send_tcp_packet_via_tun (&state->specifics.tcp_udp.ri.remote_address,
1640 &state->specifics.tcp_udp.ri.local_address, 1678 &state->specifics.tcp_udp.ri.local_address,
1641 &start->tcp_header, 1679 &start->tcp_header,
1642 &start[1], 1680 &start[1],
1643 pkt_len); 1681 pkt_len);
1644 GNUNET_CADET_receive_done(state->channel); 1682 GNUNET_CADET_receive_done (state->channel);
1645} 1683}
1646 1684
1647 1685
@@ -1654,32 +1692,32 @@ handle_tcp_service(void *cls,
1654 * #GNUNET_SYSERR to close it (signal serious error) 1692 * #GNUNET_SYSERR to close it (signal serious error)
1655 */ 1693 */
1656static int 1694static int
1657check_tcp_remote(void *cls, 1695check_tcp_remote (void *cls,
1658 const struct GNUNET_EXIT_TcpInternetStartMessage *start) 1696 const struct GNUNET_EXIT_TcpInternetStartMessage *start)
1659{ 1697{
1660 struct ChannelState *state = cls; 1698 struct ChannelState *state = cls;
1661 1699
1662 if (NULL == state) 1700 if (NULL == state)
1663 { 1701 {
1664 GNUNET_break_op(0); 1702 GNUNET_break_op (0);
1665 return GNUNET_SYSERR; 1703 return GNUNET_SYSERR;
1666 } 1704 }
1667 if (GNUNET_YES == state->is_dns) 1705 if (GNUNET_YES == state->is_dns)
1668 { 1706 {
1669 GNUNET_break_op(0); 1707 GNUNET_break_op (0);
1670 return GNUNET_SYSERR; 1708 return GNUNET_SYSERR;
1671 } 1709 }
1672 if ((NULL != state->specifics.tcp_udp.serv) || 1710 if ((NULL != state->specifics.tcp_udp.serv) ||
1673 (NULL != state->specifics.tcp_udp.heap_node)) 1711 (NULL != state->specifics.tcp_udp.heap_node))
1674 { 1712 {
1675 GNUNET_break_op(0); 1713 GNUNET_break_op (0);
1676 return GNUNET_SYSERR; 1714 return GNUNET_SYSERR;
1677 } 1715 }
1678 if (start->tcp_header.off * 4 < sizeof(struct GNUNET_TUN_TcpHeader)) 1716 if (start->tcp_header.off * 4 < sizeof(struct GNUNET_TUN_TcpHeader))
1679 { 1717 {
1680 GNUNET_break_op(0); 1718 GNUNET_break_op (0);
1681 return GNUNET_SYSERR; 1719 return GNUNET_SYSERR;
1682 } 1720 }
1683 return GNUNET_OK; 1721 return GNUNET_OK;
1684} 1722}
1685 1723
@@ -1691,88 +1729,91 @@ check_tcp_remote(void *cls,
1691 * @param start the actual message 1729 * @param start the actual message
1692 */ 1730 */
1693static void 1731static void
1694handle_tcp_remote(void *cls, 1732handle_tcp_remote (void *cls,
1695 const struct GNUNET_EXIT_TcpInternetStartMessage *start) 1733 const struct GNUNET_EXIT_TcpInternetStartMessage *start)
1696{ 1734{
1697 struct ChannelState *state = cls; 1735 struct ChannelState *state = cls;
1698 uint16_t pkt_len = ntohs(start->header.size) - sizeof(struct GNUNET_EXIT_TcpInternetStartMessage); 1736 uint16_t pkt_len = ntohs (start->header.size) - sizeof(struct
1737 GNUNET_EXIT_TcpInternetStartMessage);
1699 const struct in_addr *v4; 1738 const struct in_addr *v4;
1700 const struct in6_addr *v6; 1739 const struct in6_addr *v6;
1701 const void *payload; 1740 const void *payload;
1702 int af; 1741 int af;
1703 1742
1704 if (GNUNET_SYSERR == state->is_dns) 1743 if (GNUNET_SYSERR == state->is_dns)
1705 { 1744 {
1706 /* channel is UDP/TCP from now on */ 1745 /* channel is UDP/TCP from now on */
1707 state->is_dns = GNUNET_NO; 1746 state->is_dns = GNUNET_NO;
1708 } 1747 }
1709 GNUNET_STATISTICS_update(stats, 1748 GNUNET_STATISTICS_update (stats,
1710 gettext_noop("# Bytes received from CADET"), 1749 gettext_noop ("# Bytes received from CADET"),
1711 pkt_len, GNUNET_NO); 1750 pkt_len, GNUNET_NO);
1712 GNUNET_STATISTICS_update(stats, 1751 GNUNET_STATISTICS_update (stats,
1713 gettext_noop("# TCP IP-exit creation requests received via cadet"), 1752 gettext_noop (
1714 1, GNUNET_NO); 1753 "# TCP IP-exit creation requests received via cadet"),
1715 af = (int)ntohl(start->af); 1754 1, GNUNET_NO);
1755 af = (int) ntohl (start->af);
1716 state->specifics.tcp_udp.ri.remote_address.af = af; 1756 state->specifics.tcp_udp.ri.remote_address.af = af;
1717 switch (af) 1757 switch (af)
1758 {
1759 case AF_INET:
1760 if (pkt_len < sizeof(struct in_addr))
1718 { 1761 {
1719 case AF_INET: 1762 GNUNET_break_op (0);
1720 if (pkt_len < sizeof(struct in_addr)) 1763 return;
1721 { 1764 }
1722 GNUNET_break_op(0); 1765 if (! ipv4_exit)
1723 return; 1766 {
1724 } 1767 GNUNET_break_op (0);
1725 if (!ipv4_exit) 1768 return;
1726 { 1769 }
1727 GNUNET_break_op(0); 1770 v4 = (const struct in_addr*) &start[1];
1728 return; 1771 payload = &v4[1];
1729 } 1772 pkt_len -= sizeof(struct in_addr);
1730 v4 = (const struct in_addr*)&start[1]; 1773 state->specifics.tcp_udp.ri.remote_address.address.ipv4 = *v4;
1731 payload = &v4[1]; 1774 break;
1732 pkt_len -= sizeof(struct in_addr);
1733 state->specifics.tcp_udp.ri.remote_address.address.ipv4 = *v4;
1734 break;
1735
1736 case AF_INET6:
1737 if (pkt_len < sizeof(struct in6_addr))
1738 {
1739 GNUNET_break_op(0);
1740 return;
1741 }
1742 if (!ipv6_exit)
1743 {
1744 GNUNET_break_op(0);
1745 return;
1746 }
1747 v6 = (const struct in6_addr*)&start[1];
1748 payload = &v6[1];
1749 pkt_len -= sizeof(struct in6_addr);
1750 state->specifics.tcp_udp.ri.remote_address.address.ipv6 = *v6;
1751 break;
1752 1775
1753 default: 1776 case AF_INET6:
1754 GNUNET_break_op(0); 1777 if (pkt_len < sizeof(struct in6_addr))
1778 {
1779 GNUNET_break_op (0);
1780 return;
1781 }
1782 if (! ipv6_exit)
1783 {
1784 GNUNET_break_op (0);
1755 return; 1785 return;
1756 } 1786 }
1787 v6 = (const struct in6_addr*) &start[1];
1788 payload = &v6[1];
1789 pkt_len -= sizeof(struct in6_addr);
1790 state->specifics.tcp_udp.ri.remote_address.address.ipv6 = *v6;
1791 break;
1792
1793 default:
1794 GNUNET_break_op (0);
1795 return;
1796 }
1757 { 1797 {
1758 char buf[INET6_ADDRSTRLEN]; 1798 char buf[INET6_ADDRSTRLEN];
1759 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 1799 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1760 "Received payload from %s for existing TCP stream to %s:%u\n", 1800 "Received payload from %s for existing TCP stream to %s:%u\n",
1761 GNUNET_i2s(&state->peer), 1801 GNUNET_i2s (&state->peer),
1762 inet_ntop(af, 1802 inet_ntop (af,
1763 &state->specifics.tcp_udp.ri.remote_address.address, 1803 &state->specifics.tcp_udp.ri.remote_address.address,
1764 buf, sizeof(buf)), 1804 buf, sizeof(buf)),
1765 (unsigned int)ntohs(start->tcp_header.destination_port)); 1805 (unsigned int) ntohs (start->tcp_header.destination_port));
1766 } 1806 }
1767 state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_TCP; 1807 state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_TCP;
1768 state->specifics.tcp_udp.ri.remote_address.port = ntohs(start->tcp_header.destination_port); 1808 state->specifics.tcp_udp.ri.remote_address.port = ntohs (
1769 setup_state_record(state); 1809 start->tcp_header.destination_port);
1770 send_tcp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address, 1810 setup_state_record (state);
1771 &state->specifics.tcp_udp.ri.local_address, 1811 send_tcp_packet_via_tun (&state->specifics.tcp_udp.ri.remote_address,
1772 &start->tcp_header, 1812 &state->specifics.tcp_udp.ri.local_address,
1773 payload, 1813 &start->tcp_header,
1774 pkt_len); 1814 payload,
1775 GNUNET_CADET_receive_done(state->channel); 1815 pkt_len);
1816 GNUNET_CADET_receive_done (state->channel);
1776} 1817}
1777 1818
1778 1819
@@ -1786,31 +1827,32 @@ handle_tcp_remote(void *cls,
1786 * #GNUNET_SYSERR to close it (signal serious error) 1827 * #GNUNET_SYSERR to close it (signal serious error)
1787 */ 1828 */
1788static int 1829static int
1789check_tcp_data(void *cls, 1830check_tcp_data (void *cls,
1790 const struct GNUNET_EXIT_TcpDataMessage *data) 1831 const struct GNUNET_EXIT_TcpDataMessage *data)
1791{ 1832{
1792 struct ChannelState *state = cls; 1833 struct ChannelState *state = cls;
1793 1834
1794 if ((NULL == state) || 1835 if ((NULL == state) ||
1795 (NULL == state->specifics.tcp_udp.heap_node)) 1836 (NULL == state->specifics.tcp_udp.heap_node))
1796 { 1837 {
1797 /* connection should have been up! */ 1838 /* connection should have been up! */
1798 GNUNET_STATISTICS_update(stats, 1839 GNUNET_STATISTICS_update (stats,
1799 gettext_noop("# TCP DATA requests dropped (no session)"), 1840 gettext_noop (
1800 1, GNUNET_NO); 1841 "# TCP DATA requests dropped (no session)"),
1801 GNUNET_break_op(0); 1842 1, GNUNET_NO);
1802 return GNUNET_SYSERR; 1843 GNUNET_break_op (0);
1803 } 1844 return GNUNET_SYSERR;
1845 }
1804 if (data->tcp_header.off * 4 < sizeof(struct GNUNET_TUN_TcpHeader)) 1846 if (data->tcp_header.off * 4 < sizeof(struct GNUNET_TUN_TcpHeader))
1805 { 1847 {
1806 GNUNET_break_op(0); 1848 GNUNET_break_op (0);
1807 return GNUNET_SYSERR; 1849 return GNUNET_SYSERR;
1808 } 1850 }
1809 if (GNUNET_YES == state->is_dns) 1851 if (GNUNET_YES == state->is_dns)
1810 { 1852 {
1811 GNUNET_break_op(0); 1853 GNUNET_break_op (0);
1812 return GNUNET_SYSERR; 1854 return GNUNET_SYSERR;
1813 } 1855 }
1814 return GNUNET_OK; 1856 return GNUNET_OK;
1815} 1857}
1816 1858
@@ -1823,42 +1865,44 @@ check_tcp_data(void *cls,
1823 * @param message the actual message 1865 * @param message the actual message
1824 */ 1866 */
1825static void 1867static void
1826handle_tcp_data(void *cls, 1868handle_tcp_data (void *cls,
1827 const struct GNUNET_EXIT_TcpDataMessage *data) 1869 const struct GNUNET_EXIT_TcpDataMessage *data)
1828{ 1870{
1829 struct ChannelState *state = cls; 1871 struct ChannelState *state = cls;
1830 uint16_t pkt_len = ntohs(data->header.size) - sizeof(struct GNUNET_EXIT_TcpDataMessage); 1872 uint16_t pkt_len = ntohs (data->header.size) - sizeof(struct
1831 1873 GNUNET_EXIT_TcpDataMessage);
1832 GNUNET_STATISTICS_update(stats, 1874
1833 gettext_noop("# Bytes received from CADET"), 1875 GNUNET_STATISTICS_update (stats,
1834 pkt_len, GNUNET_NO); 1876 gettext_noop ("# Bytes received from CADET"),
1835 GNUNET_STATISTICS_update(stats, 1877 pkt_len, GNUNET_NO);
1836 gettext_noop("# TCP data requests received via cadet"), 1878 GNUNET_STATISTICS_update (stats,
1837 1, GNUNET_NO); 1879 gettext_noop (
1880 "# TCP data requests received via cadet"),
1881 1, GNUNET_NO);
1838 if (GNUNET_SYSERR == state->is_dns) 1882 if (GNUNET_SYSERR == state->is_dns)
1839 { 1883 {
1840 /* channel is UDP/TCP from now on */ 1884 /* channel is UDP/TCP from now on */
1841 state->is_dns = GNUNET_NO; 1885 state->is_dns = GNUNET_NO;
1842 } 1886 }
1843 1887
1844 GNUNET_break_op(ntohl(data->reserved) == 0); 1888 GNUNET_break_op (ntohl (data->reserved) == 0);
1845 { 1889 {
1846 char buf[INET6_ADDRSTRLEN]; 1890 char buf[INET6_ADDRSTRLEN];
1847 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 1891 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1848 "Received additional %u bytes of data from %s for TCP stream to %s:%u\n", 1892 "Received additional %u bytes of data from %s for TCP stream to %s:%u\n",
1849 pkt_len, 1893 pkt_len,
1850 GNUNET_i2s(&state->peer), 1894 GNUNET_i2s (&state->peer),
1851 inet_ntop(state->specifics.tcp_udp.ri.remote_address.af, 1895 inet_ntop (state->specifics.tcp_udp.ri.remote_address.af,
1852 &state->specifics.tcp_udp.ri.remote_address.address, 1896 &state->specifics.tcp_udp.ri.remote_address.address,
1853 buf, sizeof(buf)), 1897 buf, sizeof(buf)),
1854 (unsigned int)state->specifics.tcp_udp.ri.remote_address.port); 1898 (unsigned int) state->specifics.tcp_udp.ri.remote_address.port);
1855 } 1899 }
1856 1900
1857 send_tcp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address, 1901 send_tcp_packet_via_tun (&state->specifics.tcp_udp.ri.remote_address,
1858 &state->specifics.tcp_udp.ri.local_address, 1902 &state->specifics.tcp_udp.ri.local_address,
1859 &data->tcp_header, 1903 &data->tcp_header,
1860 &data[1], pkt_len); 1904 &data[1], pkt_len);
1861 GNUNET_CADET_receive_done(state->channel); 1905 GNUNET_CADET_receive_done (state->channel);
1862} 1906}
1863 1907
1864 1908
@@ -1872,19 +1916,23 @@ handle_tcp_data(void *cls,
1872 * also be the first 8 bytes of the TCP header 1916 * also be the first 8 bytes of the TCP header
1873 */ 1917 */
1874static void 1918static void
1875make_up_icmpv4_payload(struct ChannelState *state, 1919make_up_icmpv4_payload (struct ChannelState *state,
1876 struct GNUNET_TUN_IPv4Header *ipp, 1920 struct GNUNET_TUN_IPv4Header *ipp,
1877 struct GNUNET_TUN_UdpHeader *udp) 1921 struct GNUNET_TUN_UdpHeader *udp)
1878{ 1922{
1879 GNUNET_TUN_initialize_ipv4_header(ipp, 1923 GNUNET_TUN_initialize_ipv4_header (ipp,
1880 state->specifics.tcp_udp.ri.remote_address.proto, 1924 state->specifics.tcp_udp.ri.remote_address.
1881 sizeof(struct GNUNET_TUN_TcpHeader), 1925 proto,
1882 &state->specifics.tcp_udp.ri.remote_address.address.ipv4, 1926 sizeof(struct GNUNET_TUN_TcpHeader),
1883 &state->specifics.tcp_udp.ri.local_address.address.ipv4); 1927 &state->specifics.tcp_udp.ri.remote_address
1884 udp->source_port = htons(state->specifics.tcp_udp.ri.remote_address.port); 1928 .address.ipv4,
1885 udp->destination_port = htons(state->specifics.tcp_udp.ri.local_address.port); 1929 &state->specifics.tcp_udp.ri.local_address.
1886 udp->len = htons(0); 1930 address.ipv4);
1887 udp->crc = htons(0); 1931 udp->source_port = htons (state->specifics.tcp_udp.ri.remote_address.port);
1932 udp->destination_port = htons (
1933 state->specifics.tcp_udp.ri.local_address.port);
1934 udp->len = htons (0);
1935 udp->crc = htons (0);
1888} 1936}
1889 1937
1890 1938
@@ -1898,19 +1946,23 @@ make_up_icmpv4_payload(struct ChannelState *state,
1898 * also be the first 8 bytes of the TCP header 1946 * also be the first 8 bytes of the TCP header
1899 */ 1947 */
1900static void 1948static void
1901make_up_icmpv6_payload(struct ChannelState *state, 1949make_up_icmpv6_payload (struct ChannelState *state,
1902 struct GNUNET_TUN_IPv6Header *ipp, 1950 struct GNUNET_TUN_IPv6Header *ipp,
1903 struct GNUNET_TUN_UdpHeader *udp) 1951 struct GNUNET_TUN_UdpHeader *udp)
1904{ 1952{
1905 GNUNET_TUN_initialize_ipv6_header(ipp, 1953 GNUNET_TUN_initialize_ipv6_header (ipp,
1906 state->specifics.tcp_udp.ri.remote_address.proto, 1954 state->specifics.tcp_udp.ri.remote_address.
1907 sizeof(struct GNUNET_TUN_TcpHeader), 1955 proto,
1908 &state->specifics.tcp_udp.ri.remote_address.address.ipv6, 1956 sizeof(struct GNUNET_TUN_TcpHeader),
1909 &state->specifics.tcp_udp.ri.local_address.address.ipv6); 1957 &state->specifics.tcp_udp.ri.remote_address
1910 udp->source_port = htons(state->specifics.tcp_udp.ri.remote_address.port); 1958 .address.ipv6,
1911 udp->destination_port = htons(state->specifics.tcp_udp.ri.local_address.port); 1959 &state->specifics.tcp_udp.ri.local_address.
1912 udp->len = htons(0); 1960 address.ipv6);
1913 udp->crc = htons(0); 1961 udp->source_port = htons (state->specifics.tcp_udp.ri.remote_address.port);
1962 udp->destination_port = htons (
1963 state->specifics.tcp_udp.ri.local_address.port);
1964 udp->len = htons (0);
1965 udp->crc = htons (0);
1914} 1966}
1915 1967
1916 1968
@@ -1923,16 +1975,16 @@ make_up_icmpv6_payload(struct ChannelState *state,
1923 * #GNUNET_SYSERR to close it (signal serious error) 1975 * #GNUNET_SYSERR to close it (signal serious error)
1924 */ 1976 */
1925static int 1977static int
1926check_icmp_remote(void *cls, 1978check_icmp_remote (void *cls,
1927 const struct GNUNET_EXIT_IcmpInternetMessage *msg) 1979 const struct GNUNET_EXIT_IcmpInternetMessage *msg)
1928{ 1980{
1929 struct ChannelState *state = cls; 1981 struct ChannelState *state = cls;
1930 1982
1931 if (GNUNET_YES == state->is_dns) 1983 if (GNUNET_YES == state->is_dns)
1932 { 1984 {
1933 GNUNET_break_op(0); 1985 GNUNET_break_op (0);
1934 return GNUNET_SYSERR; 1986 return GNUNET_SYSERR;
1935 } 1987 }
1936 return GNUNET_OK; 1988 return GNUNET_OK;
1937} 1989}
1938 1990
@@ -1944,11 +1996,12 @@ check_icmp_remote(void *cls,
1944 * @param msg the actual message 1996 * @param msg the actual message
1945 */ 1997 */
1946static void 1998static void
1947handle_icmp_remote(void *cls, 1999handle_icmp_remote (void *cls,
1948 const struct GNUNET_EXIT_IcmpInternetMessage *msg) 2000 const struct GNUNET_EXIT_IcmpInternetMessage *msg)
1949{ 2001{
1950 struct ChannelState *state = cls; 2002 struct ChannelState *state = cls;
1951 uint16_t pkt_len = ntohs(msg->header.size) - sizeof(struct GNUNET_EXIT_IcmpInternetMessage); 2003 uint16_t pkt_len = ntohs (msg->header.size) - sizeof(struct
2004 GNUNET_EXIT_IcmpInternetMessage);
1952 const struct in_addr *v4; 2005 const struct in_addr *v4;
1953 const struct in6_addr *v6; 2006 const struct in6_addr *v6;
1954 const void *payload; 2007 const void *payload;
@@ -1956,171 +2009,178 @@ handle_icmp_remote(void *cls,
1956 int af; 2009 int af;
1957 2010
1958 if (GNUNET_SYSERR == state->is_dns) 2011 if (GNUNET_SYSERR == state->is_dns)
1959 { 2012 {
1960 /* channel is UDP/TCP from now on */ 2013 /* channel is UDP/TCP from now on */
1961 state->is_dns = GNUNET_NO; 2014 state->is_dns = GNUNET_NO;
1962 } 2015 }
1963 GNUNET_STATISTICS_update(stats, 2016 GNUNET_STATISTICS_update (stats,
1964 gettext_noop("# Bytes received from CADET"), 2017 gettext_noop ("# Bytes received from CADET"),
1965 pkt_len, GNUNET_NO); 2018 pkt_len, GNUNET_NO);
1966 GNUNET_STATISTICS_update(stats, 2019 GNUNET_STATISTICS_update (stats,
1967 gettext_noop("# ICMP IP-exit requests received via cadet"), 2020 gettext_noop (
1968 1, GNUNET_NO); 2021 "# ICMP IP-exit requests received via cadet"),
1969 2022 1, GNUNET_NO);
1970 af = (int)ntohl(msg->af); 2023
2024 af = (int) ntohl (msg->af);
1971 if ((NULL != state->specifics.tcp_udp.heap_node) && 2025 if ((NULL != state->specifics.tcp_udp.heap_node) &&
1972 (af != state->specifics.tcp_udp.ri.remote_address.af)) 2026 (af != state->specifics.tcp_udp.ri.remote_address.af))
2027 {
2028 /* other peer switched AF on this channel; not allowed */
2029 GNUNET_break_op (0);
2030 return;
2031 }
2032
2033 switch (af)
2034 {
2035 case AF_INET:
2036 if (pkt_len < sizeof(struct in_addr))
1973 { 2037 {
1974 /* other peer switched AF on this channel; not allowed */ 2038 GNUNET_break_op (0);
1975 GNUNET_break_op(0);
1976 return; 2039 return;
1977 } 2040 }
2041 if (! ipv4_exit)
2042 {
2043 GNUNET_break_op (0);
2044 return;
2045 }
2046 v4 = (const struct in_addr*) &msg[1];
2047 payload = &v4[1];
2048 pkt_len -= sizeof(struct in_addr);
2049 state->specifics.tcp_udp.ri.remote_address.address.ipv4 = *v4;
2050 if (NULL == state->specifics.tcp_udp.heap_node)
2051 {
2052 state->specifics.tcp_udp.ri.remote_address.af = af;
2053 state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_ICMP;
2054 setup_state_record (state);
2055 }
2056 /* check that ICMP type is something we want to support
2057 and possibly make up payload! */
2058 switch (msg->icmp_header.type)
2059 {
2060 case GNUNET_TUN_ICMPTYPE_ECHO_REPLY:
2061 case GNUNET_TUN_ICMPTYPE_ECHO_REQUEST:
2062 break;
1978 2063
1979 switch (af) 2064 case GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE:
2065 case GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH:
2066 case GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED:
2067 if (0 != pkt_len)
2068 {
2069 GNUNET_break_op (0);
2070 return;
2071 }
2072 /* make up payload */
2073 {
2074 struct GNUNET_TUN_IPv4Header *ipp = (struct
2075 GNUNET_TUN_IPv4Header *) buf;
2076 struct GNUNET_TUN_UdpHeader *udp = (struct
2077 GNUNET_TUN_UdpHeader *) &ipp[1];
2078
2079 GNUNET_assert (8 == sizeof(struct GNUNET_TUN_UdpHeader));
2080 pkt_len = sizeof(struct GNUNET_TUN_IPv4Header) + 8;
2081 make_up_icmpv4_payload (state,
2082 ipp,
2083 udp);
2084 payload = ipp;
2085 }
2086 break;
2087
2088 default:
2089 GNUNET_break_op (0);
2090 GNUNET_STATISTICS_update (stats,
2091 gettext_noop (
2092 "# ICMPv4 packets dropped (type not allowed)"),
2093 1, GNUNET_NO);
2094 return;
2095 }
2096 /* end AF_INET */
2097 break;
2098
2099 case AF_INET6:
2100 if (pkt_len < sizeof(struct in6_addr))
1980 { 2101 {
1981 case AF_INET: 2102 GNUNET_break_op (0);
1982 if (pkt_len < sizeof(struct in_addr)) 2103 return;
1983 { 2104 }
1984 GNUNET_break_op(0); 2105 if (! ipv6_exit)
1985 return; 2106 {
1986 } 2107 GNUNET_break_op (0);
1987 if (!ipv4_exit) 2108 return;
1988 { 2109 }
1989 GNUNET_break_op(0); 2110 v6 = (const struct in6_addr*) &msg[1];
1990 return; 2111 payload = &v6[1];
1991 } 2112 pkt_len -= sizeof(struct in6_addr);
1992 v4 = (const struct in_addr*)&msg[1]; 2113 state->specifics.tcp_udp.ri.remote_address.address.ipv6 = *v6;
1993 payload = &v4[1]; 2114 if (NULL == state->specifics.tcp_udp.heap_node)
1994 pkt_len -= sizeof(struct in_addr); 2115 {
1995 state->specifics.tcp_udp.ri.remote_address.address.ipv4 = *v4; 2116 state->specifics.tcp_udp.ri.remote_address.af = af;
1996 if (NULL == state->specifics.tcp_udp.heap_node) 2117 state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_ICMPV6;
1997 { 2118 setup_state_record (state);
1998 state->specifics.tcp_udp.ri.remote_address.af = af; 2119 }
1999 state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_ICMP; 2120 /* check that ICMP type is something we want to support
2000 setup_state_record(state); 2121 and possibly make up payload! */
2001 } 2122 switch (msg->icmp_header.type)
2002 /* check that ICMP type is something we want to support 2123 {
2003 and possibly make up payload! */ 2124 case GNUNET_TUN_ICMPTYPE6_ECHO_REPLY:
2004 switch (msg->icmp_header.type) 2125 case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST:
2005 {
2006 case GNUNET_TUN_ICMPTYPE_ECHO_REPLY:
2007 case GNUNET_TUN_ICMPTYPE_ECHO_REQUEST:
2008 break;
2009
2010 case GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE:
2011 case GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH:
2012 case GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED:
2013 if (0 != pkt_len)
2014 {
2015 GNUNET_break_op(0);
2016 return;
2017 }
2018 /* make up payload */
2019 {
2020 struct GNUNET_TUN_IPv4Header *ipp = (struct GNUNET_TUN_IPv4Header *)buf;
2021 struct GNUNET_TUN_UdpHeader *udp = (struct GNUNET_TUN_UdpHeader *)&ipp[1];
2022
2023 GNUNET_assert(8 == sizeof(struct GNUNET_TUN_UdpHeader));
2024 pkt_len = sizeof(struct GNUNET_TUN_IPv4Header) + 8;
2025 make_up_icmpv4_payload(state,
2026 ipp,
2027 udp);
2028 payload = ipp;
2029 }
2030 break;
2031
2032 default:
2033 GNUNET_break_op(0);
2034 GNUNET_STATISTICS_update(stats,
2035 gettext_noop("# ICMPv4 packets dropped (type not allowed)"),
2036 1, GNUNET_NO);
2037 return;
2038 }
2039 /* end AF_INET */
2040 break; 2126 break;
2041 2127
2042 case AF_INET6: 2128 case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE:
2043 if (pkt_len < sizeof(struct in6_addr)) 2129 case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG:
2044 { 2130 case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED:
2045 GNUNET_break_op(0); 2131 case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM:
2046 return; 2132 if (0 != pkt_len)
2047 } 2133 {
2048 if (!ipv6_exit) 2134 GNUNET_break_op (0);
2049 { 2135 return;
2050 GNUNET_break_op(0); 2136 }
2051 return; 2137 /* make up payload */
2052 } 2138 {
2053 v6 = (const struct in6_addr*)&msg[1]; 2139 struct GNUNET_TUN_IPv6Header *ipp = (struct
2054 payload = &v6[1]; 2140 GNUNET_TUN_IPv6Header *) buf;
2055 pkt_len -= sizeof(struct in6_addr); 2141 struct GNUNET_TUN_UdpHeader *udp = (struct
2056 state->specifics.tcp_udp.ri.remote_address.address.ipv6 = *v6; 2142 GNUNET_TUN_UdpHeader *) &ipp[1];
2057 if (NULL == state->specifics.tcp_udp.heap_node) 2143
2058 { 2144 GNUNET_assert (8 == sizeof(struct GNUNET_TUN_UdpHeader));
2059 state->specifics.tcp_udp.ri.remote_address.af = af; 2145 pkt_len = sizeof(struct GNUNET_TUN_IPv6Header) + 8;
2060 state->specifics.tcp_udp.ri.remote_address.proto = IPPROTO_ICMPV6; 2146 make_up_icmpv6_payload (state,
2061 setup_state_record(state); 2147 ipp,
2062 } 2148 udp);
2063 /* check that ICMP type is something we want to support 2149 payload = ipp;
2064 and possibly make up payload! */ 2150 }
2065 switch (msg->icmp_header.type)
2066 {
2067 case GNUNET_TUN_ICMPTYPE6_ECHO_REPLY:
2068 case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST:
2069 break;
2070
2071 case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE:
2072 case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG:
2073 case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED:
2074 case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM:
2075 if (0 != pkt_len)
2076 {
2077 GNUNET_break_op(0);
2078 return;
2079 }
2080 /* make up payload */
2081 {
2082 struct GNUNET_TUN_IPv6Header *ipp = (struct GNUNET_TUN_IPv6Header *)buf;
2083 struct GNUNET_TUN_UdpHeader *udp = (struct GNUNET_TUN_UdpHeader *)&ipp[1];
2084
2085 GNUNET_assert(8 == sizeof(struct GNUNET_TUN_UdpHeader));
2086 pkt_len = sizeof(struct GNUNET_TUN_IPv6Header) + 8;
2087 make_up_icmpv6_payload(state,
2088 ipp,
2089 udp);
2090 payload = ipp;
2091 }
2092 break;
2093
2094 default:
2095 GNUNET_break_op(0);
2096 GNUNET_STATISTICS_update(stats,
2097 gettext_noop("# ICMPv6 packets dropped (type not allowed)"),
2098 1, GNUNET_NO);
2099 return;
2100 }
2101 /* end AF_INET6 */
2102 break; 2151 break;
2103 2152
2104 default: 2153 default:
2105 /* bad AF */ 2154 GNUNET_break_op (0);
2106 GNUNET_break_op(0); 2155 GNUNET_STATISTICS_update (stats,
2156 gettext_noop (
2157 "# ICMPv6 packets dropped (type not allowed)"),
2158 1, GNUNET_NO);
2107 return; 2159 return;
2108 } 2160 }
2161 /* end AF_INET6 */
2162 break;
2163
2164 default:
2165 /* bad AF */
2166 GNUNET_break_op (0);
2167 return;
2168 }
2109 2169
2110 { 2170 {
2111 char buf[INET6_ADDRSTRLEN]; 2171 char buf[INET6_ADDRSTRLEN];
2112 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 2172 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2113 "Received ICMP data from %s for forwarding to %s\n", 2173 "Received ICMP data from %s for forwarding to %s\n",
2114 GNUNET_i2s(&state->peer), 2174 GNUNET_i2s (&state->peer),
2115 inet_ntop(af, 2175 inet_ntop (af,
2116 &state->specifics.tcp_udp.ri.remote_address.address, 2176 &state->specifics.tcp_udp.ri.remote_address.address,
2117 buf, sizeof(buf))); 2177 buf, sizeof(buf)));
2118 } 2178 }
2119 send_icmp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address, 2179 send_icmp_packet_via_tun (&state->specifics.tcp_udp.ri.remote_address,
2120 &state->specifics.tcp_udp.ri.local_address, 2180 &state->specifics.tcp_udp.ri.local_address,
2121 &msg->icmp_header, 2181 &msg->icmp_header,
2122 payload, pkt_len); 2182 payload, pkt_len);
2123 GNUNET_CADET_receive_done(state->channel); 2183 GNUNET_CADET_receive_done (state->channel);
2124} 2184}
2125 2185
2126 2186
@@ -2134,44 +2194,44 @@ handle_icmp_remote(void *cls,
2134 * @return number of bytes of payload we created in buf 2194 * @return number of bytes of payload we created in buf
2135 */ 2195 */
2136static uint16_t 2196static uint16_t
2137make_up_icmp_service_payload(struct ChannelState *state, 2197make_up_icmp_service_payload (struct ChannelState *state,
2138 char *buf) 2198 char *buf)
2139{ 2199{
2140 switch (state->specifics.tcp_udp.serv->address.af) 2200 switch (state->specifics.tcp_udp.serv->address.af)
2141 { 2201 {
2142 case AF_INET: 2202 case AF_INET:
2143 { 2203 {
2144 struct GNUNET_TUN_IPv4Header *ipv4; 2204 struct GNUNET_TUN_IPv4Header *ipv4;
2145 struct GNUNET_TUN_UdpHeader *udp; 2205 struct GNUNET_TUN_UdpHeader *udp;
2146 2206
2147 ipv4 = (struct GNUNET_TUN_IPv4Header *)buf; 2207 ipv4 = (struct GNUNET_TUN_IPv4Header *) buf;
2148 udp = (struct GNUNET_TUN_UdpHeader *)&ipv4[1]; 2208 udp = (struct GNUNET_TUN_UdpHeader *) &ipv4[1];
2149 make_up_icmpv4_payload(state, 2209 make_up_icmpv4_payload (state,
2150 ipv4, 2210 ipv4,
2151 udp); 2211 udp);
2152 GNUNET_assert(8 == sizeof(struct GNUNET_TUN_UdpHeader)); 2212 GNUNET_assert (8 == sizeof(struct GNUNET_TUN_UdpHeader));
2153 return sizeof(struct GNUNET_TUN_IPv4Header) + 8; 2213 return sizeof(struct GNUNET_TUN_IPv4Header) + 8;
2154 } 2214 }
2155 break; 2215 break;
2156 2216
2157 case AF_INET6: 2217 case AF_INET6:
2158 { 2218 {
2159 struct GNUNET_TUN_IPv6Header *ipv6; 2219 struct GNUNET_TUN_IPv6Header *ipv6;
2160 struct GNUNET_TUN_UdpHeader *udp; 2220 struct GNUNET_TUN_UdpHeader *udp;
2161 2221
2162 ipv6 = (struct GNUNET_TUN_IPv6Header *)buf; 2222 ipv6 = (struct GNUNET_TUN_IPv6Header *) buf;
2163 udp = (struct GNUNET_TUN_UdpHeader *)&ipv6[1]; 2223 udp = (struct GNUNET_TUN_UdpHeader *) &ipv6[1];
2164 make_up_icmpv6_payload(state, 2224 make_up_icmpv6_payload (state,
2165 ipv6, 2225 ipv6,
2166 udp); 2226 udp);
2167 GNUNET_assert(8 == sizeof(struct GNUNET_TUN_UdpHeader)); 2227 GNUNET_assert (8 == sizeof(struct GNUNET_TUN_UdpHeader));
2168 return sizeof(struct GNUNET_TUN_IPv6Header) + 8; 2228 return sizeof(struct GNUNET_TUN_IPv6Header) + 8;
2169 } 2229 }
2170 break; 2230 break;
2171 2231
2172 default: 2232 default:
2173 GNUNET_break(0); 2233 GNUNET_break (0);
2174 } 2234 }
2175 return 0; 2235 return 0;
2176} 2236}
2177 2237
@@ -2186,21 +2246,21 @@ make_up_icmp_service_payload(struct ChannelState *state,
2186 * #GNUNET_SYSERR to close it (signal serious error) 2246 * #GNUNET_SYSERR to close it (signal serious error)
2187 */ 2247 */
2188static int 2248static int
2189check_icmp_service(void *cls, 2249check_icmp_service (void *cls,
2190 const struct GNUNET_EXIT_IcmpServiceMessage *msg) 2250 const struct GNUNET_EXIT_IcmpServiceMessage *msg)
2191{ 2251{
2192 struct ChannelState *state = cls; 2252 struct ChannelState *state = cls;
2193 2253
2194 if (GNUNET_YES == state->is_dns) 2254 if (GNUNET_YES == state->is_dns)
2195 { 2255 {
2196 GNUNET_break_op(0); 2256 GNUNET_break_op (0);
2197 return GNUNET_SYSERR; 2257 return GNUNET_SYSERR;
2198 } 2258 }
2199 if (NULL == state->specifics.tcp_udp.serv) 2259 if (NULL == state->specifics.tcp_udp.serv)
2200 { 2260 {
2201 GNUNET_break_op(0); 2261 GNUNET_break_op (0);
2202 return GNUNET_SYSERR; 2262 return GNUNET_SYSERR;
2203 } 2263 }
2204 return GNUNET_OK; 2264 return GNUNET_OK;
2205} 2265}
2206 2266
@@ -2213,176 +2273,182 @@ check_icmp_service(void *cls,
2213 * @param msg the actual message 2273 * @param msg the actual message
2214 */ 2274 */
2215static void 2275static void
2216handle_icmp_service(void *cls, 2276handle_icmp_service (void *cls,
2217 const struct GNUNET_EXIT_IcmpServiceMessage *msg) 2277 const struct GNUNET_EXIT_IcmpServiceMessage *msg)
2218{ 2278{
2219 struct ChannelState *state = cls; 2279 struct ChannelState *state = cls;
2220 uint16_t pkt_len = ntohs(msg->header.size) - sizeof(struct GNUNET_EXIT_IcmpServiceMessage); 2280 uint16_t pkt_len = ntohs (msg->header.size) - sizeof(struct
2281 GNUNET_EXIT_IcmpServiceMessage);
2221 struct GNUNET_TUN_IcmpHeader icmp; 2282 struct GNUNET_TUN_IcmpHeader icmp;
2222 char buf[sizeof(struct GNUNET_TUN_IPv6Header) + 8] GNUNET_ALIGN; 2283 char buf[sizeof(struct GNUNET_TUN_IPv6Header) + 8] GNUNET_ALIGN;
2223 const void *payload; 2284 const void *payload;
2224 2285
2225 GNUNET_STATISTICS_update(stats, 2286 GNUNET_STATISTICS_update (stats,
2226 gettext_noop("# Bytes received from CADET"), 2287 gettext_noop ("# Bytes received from CADET"),
2227 pkt_len, GNUNET_NO); 2288 pkt_len, GNUNET_NO);
2228 GNUNET_STATISTICS_update(stats, 2289 GNUNET_STATISTICS_update (stats,
2229 gettext_noop("# ICMP service requests received via cadet"), 2290 gettext_noop (
2230 1, GNUNET_NO); 2291 "# ICMP service requests received via cadet"),
2292 1, GNUNET_NO);
2231 /* check that we got at least a valid header */ 2293 /* check that we got at least a valid header */
2232 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 2294 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2233 "Received data from %s for forwarding to ICMP service %s\n", 2295 "Received data from %s for forwarding to ICMP service %s\n",
2234 GNUNET_i2s(&state->peer), 2296 GNUNET_i2s (&state->peer),
2235 GNUNET_h2s(&state->specifics.tcp_udp.serv->descriptor)); 2297 GNUNET_h2s (&state->specifics.tcp_udp.serv->descriptor));
2236 icmp = msg->icmp_header; 2298 icmp = msg->icmp_header;
2237 payload = &msg[1]; 2299 payload = &msg[1];
2238 state->specifics.tcp_udp.ri.remote_address 2300 state->specifics.tcp_udp.ri.remote_address
2239 = state->specifics.tcp_udp.serv->address; 2301 = state->specifics.tcp_udp.serv->address;
2240 setup_state_record(state); 2302 setup_state_record (state);
2241 2303
2242 /* check that ICMP type is something we want to support, 2304 /* check that ICMP type is something we want to support,
2243 perform ICMP PT if needed ans possibly make up payload */ 2305 perform ICMP PT if needed ans possibly make up payload */
2244 switch (msg->af) 2306 switch (msg->af)
2307 {
2308 case AF_INET:
2309 switch (msg->icmp_header.type)
2245 { 2310 {
2246 case AF_INET: 2311 case GNUNET_TUN_ICMPTYPE_ECHO_REPLY:
2247 switch (msg->icmp_header.type) 2312 if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
2248 { 2313 icmp.type = GNUNET_TUN_ICMPTYPE6_ECHO_REPLY;
2249 case GNUNET_TUN_ICMPTYPE_ECHO_REPLY:
2250 if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
2251 icmp.type = GNUNET_TUN_ICMPTYPE6_ECHO_REPLY;
2252 break;
2253
2254 case GNUNET_TUN_ICMPTYPE_ECHO_REQUEST:
2255 if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
2256 icmp.type = GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST;
2257 break;
2258
2259 case GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE:
2260 if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
2261 icmp.type = GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE;
2262 if (0 != pkt_len)
2263 {
2264 GNUNET_break_op(0);
2265 return;
2266 }
2267 payload = buf;
2268 pkt_len = make_up_icmp_service_payload(state, buf);
2269 break;
2270
2271 case GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED:
2272 if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
2273 icmp.type = GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED;
2274 if (0 != pkt_len)
2275 {
2276 GNUNET_break_op(0);
2277 return;
2278 }
2279 payload = buf;
2280 pkt_len = make_up_icmp_service_payload(state, buf);
2281 break;
2282
2283 case GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH:
2284 if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
2285 {
2286 GNUNET_STATISTICS_update(stats,
2287 gettext_noop("# ICMPv4 packets dropped (impossible PT to v6)"),
2288 1, GNUNET_NO);
2289 return;
2290 }
2291 if (0 != pkt_len)
2292 {
2293 GNUNET_break_op(0);
2294 return;
2295 }
2296 payload = buf;
2297 pkt_len = make_up_icmp_service_payload(state, buf);
2298 break;
2299
2300 default:
2301 GNUNET_break_op(0);
2302 GNUNET_STATISTICS_update(stats,
2303 gettext_noop("# ICMPv4 packets dropped (type not allowed)"),
2304 1, GNUNET_NO);
2305 return;
2306 }
2307 /* end of AF_INET */
2308 break; 2314 break;
2309 2315
2310 case AF_INET6: 2316 case GNUNET_TUN_ICMPTYPE_ECHO_REQUEST:
2311 switch (msg->icmp_header.type) 2317 if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
2312 { 2318 icmp.type = GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST;
2313 case GNUNET_TUN_ICMPTYPE6_ECHO_REPLY: 2319 break;
2314 if (state->specifics.tcp_udp.serv->address.af == AF_INET) 2320
2315 icmp.type = GNUNET_TUN_ICMPTYPE_ECHO_REPLY; 2321 case GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE:
2316 break; 2322 if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
2317 2323 icmp.type = GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE;
2318 case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST: 2324 if (0 != pkt_len)
2319 if (state->specifics.tcp_udp.serv->address.af == AF_INET) 2325 {
2320 icmp.type = GNUNET_TUN_ICMPTYPE_ECHO_REQUEST; 2326 GNUNET_break_op (0);
2321 break; 2327 return;
2322 2328 }
2323 case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE: 2329 payload = buf;
2324 if (state->specifics.tcp_udp.serv->address.af == AF_INET) 2330 pkt_len = make_up_icmp_service_payload (state, buf);
2325 icmp.type = GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE; 2331 break;
2326 if (0 != pkt_len) 2332
2327 { 2333 case GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED:
2328 GNUNET_break_op(0); 2334 if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
2329 return; 2335 icmp.type = GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED;
2330 } 2336 if (0 != pkt_len)
2331 payload = buf; 2337 {
2332 pkt_len = make_up_icmp_service_payload(state, buf); 2338 GNUNET_break_op (0);
2333 break; 2339 return;
2334 2340 }
2335 case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED: 2341 payload = buf;
2336 if (state->specifics.tcp_udp.serv->address.af == AF_INET) 2342 pkt_len = make_up_icmp_service_payload (state, buf);
2337 icmp.type = GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED; 2343 break;
2338 if (0 != pkt_len) 2344
2339 { 2345 case GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH:
2340 GNUNET_break_op(0); 2346 if (state->specifics.tcp_udp.serv->address.af == AF_INET6)
2341 return; 2347 {
2342 } 2348 GNUNET_STATISTICS_update (stats,
2343 payload = buf; 2349 gettext_noop (
2344 pkt_len = make_up_icmp_service_payload(state, buf); 2350 "# ICMPv4 packets dropped (impossible PT to v6)"),
2345 break; 2351 1, GNUNET_NO);
2346 2352 return;
2347 case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG: 2353 }
2348 case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM: 2354 if (0 != pkt_len)
2349 if (state->specifics.tcp_udp.serv->address.af == AF_INET) 2355 {
2350 { 2356 GNUNET_break_op (0);
2351 GNUNET_STATISTICS_update(stats, 2357 return;
2352 gettext_noop("# ICMPv6 packets dropped (impossible PT to v4)"), 2358 }
2353 1, GNUNET_NO); 2359 payload = buf;
2354 return; 2360 pkt_len = make_up_icmp_service_payload (state, buf);
2355 }
2356 if (0 != pkt_len)
2357 {
2358 GNUNET_break_op(0);
2359 return;
2360 }
2361 payload = buf;
2362 pkt_len = make_up_icmp_service_payload(state, buf);
2363 break;
2364
2365 default:
2366 GNUNET_break_op(0);
2367 GNUNET_STATISTICS_update(stats,
2368 gettext_noop("# ICMPv6 packets dropped (type not allowed)"),
2369 1, GNUNET_NO);
2370 return;
2371 }
2372 /* end of AF_INET6 */
2373 break; 2361 break;
2374 2362
2375 default: 2363 default:
2376 GNUNET_break_op(0); 2364 GNUNET_break_op (0);
2365 GNUNET_STATISTICS_update (stats,
2366 gettext_noop (
2367 "# ICMPv4 packets dropped (type not allowed)"),
2368 1, GNUNET_NO);
2377 return; 2369 return;
2378 } 2370 }
2371 /* end of AF_INET */
2372 break;
2379 2373
2380 send_icmp_packet_via_tun(&state->specifics.tcp_udp.ri.remote_address, 2374 case AF_INET6:
2381 &state->specifics.tcp_udp.ri.local_address, 2375 switch (msg->icmp_header.type)
2382 &icmp, 2376 {
2383 payload, 2377 case GNUNET_TUN_ICMPTYPE6_ECHO_REPLY:
2384 pkt_len); 2378 if (state->specifics.tcp_udp.serv->address.af == AF_INET)
2385 GNUNET_CADET_receive_done(state->channel); 2379 icmp.type = GNUNET_TUN_ICMPTYPE_ECHO_REPLY;
2380 break;
2381
2382 case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST:
2383 if (state->specifics.tcp_udp.serv->address.af == AF_INET)
2384 icmp.type = GNUNET_TUN_ICMPTYPE_ECHO_REQUEST;
2385 break;
2386
2387 case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE:
2388 if (state->specifics.tcp_udp.serv->address.af == AF_INET)
2389 icmp.type = GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE;
2390 if (0 != pkt_len)
2391 {
2392 GNUNET_break_op (0);
2393 return;
2394 }
2395 payload = buf;
2396 pkt_len = make_up_icmp_service_payload (state, buf);
2397 break;
2398
2399 case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED:
2400 if (state->specifics.tcp_udp.serv->address.af == AF_INET)
2401 icmp.type = GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED;
2402 if (0 != pkt_len)
2403 {
2404 GNUNET_break_op (0);
2405 return;
2406 }
2407 payload = buf;
2408 pkt_len = make_up_icmp_service_payload (state, buf);
2409 break;
2410
2411 case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG:
2412 case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM:
2413 if (state->specifics.tcp_udp.serv->address.af == AF_INET)
2414 {
2415 GNUNET_STATISTICS_update (stats,
2416 gettext_noop (
2417 "# ICMPv6 packets dropped (impossible PT to v4)"),
2418 1, GNUNET_NO);
2419 return;
2420 }
2421 if (0 != pkt_len)
2422 {
2423 GNUNET_break_op (0);
2424 return;
2425 }
2426 payload = buf;
2427 pkt_len = make_up_icmp_service_payload (state, buf);
2428 break;
2429
2430 default:
2431 GNUNET_break_op (0);
2432 GNUNET_STATISTICS_update (stats,
2433 gettext_noop (
2434 "# ICMPv6 packets dropped (type not allowed)"),
2435 1, GNUNET_NO);
2436 return;
2437 }
2438 /* end of AF_INET6 */
2439 break;
2440
2441 default:
2442 GNUNET_break_op (0);
2443 return;
2444 }
2445
2446 send_icmp_packet_via_tun (&state->specifics.tcp_udp.ri.remote_address,
2447 &state->specifics.tcp_udp.ri.local_address,
2448 &icmp,
2449 payload,
2450 pkt_len);
2451 GNUNET_CADET_receive_done (state->channel);
2386} 2452}
2387 2453
2388 2454
@@ -2395,19 +2461,19 @@ handle_icmp_service(void *cls,
2395 * @return #GNUNET_OK 2461 * @return #GNUNET_OK
2396 */ 2462 */
2397static int 2463static int
2398free_service_record(void *cls, 2464free_service_record (void *cls,
2399 const struct GNUNET_HashCode *key, 2465 const struct GNUNET_HashCode *key,
2400 void *value) 2466 void *value)
2401{ 2467{
2402 struct LocalService *service = value; 2468 struct LocalService *service = value;
2403 2469
2404 GNUNET_assert(GNUNET_YES == 2470 GNUNET_assert (GNUNET_YES ==
2405 GNUNET_CONTAINER_multihashmap_remove(services, 2471 GNUNET_CONTAINER_multihashmap_remove (services,
2406 key, 2472 key,
2407 service)); 2473 service));
2408 GNUNET_CADET_close_port(service->port); 2474 GNUNET_CADET_close_port (service->port);
2409 GNUNET_free_non_null(service->name); 2475 GNUNET_free_non_null (service->name);
2410 GNUNET_free(service); 2476 GNUNET_free (service);
2411 return GNUNET_OK; 2477 return GNUNET_OK;
2412} 2478}
2413 2479
@@ -2421,21 +2487,21 @@ free_service_record(void *cls,
2421 * @return initial channel context for the channel 2487 * @return initial channel context for the channel
2422 */ 2488 */
2423static void * 2489static void *
2424new_service_channel(void *cls, 2490new_service_channel (void *cls,
2425 struct GNUNET_CADET_Channel *channel, 2491 struct GNUNET_CADET_Channel *channel,
2426 const struct GNUNET_PeerIdentity *initiator) 2492 const struct GNUNET_PeerIdentity *initiator)
2427{ 2493{
2428 struct LocalService *ls = cls; 2494 struct LocalService *ls = cls;
2429 struct ChannelState *s = GNUNET_new(struct ChannelState); 2495 struct ChannelState *s = GNUNET_new (struct ChannelState);
2430 2496
2431 s->peer = *initiator; 2497 s->peer = *initiator;
2432 GNUNET_STATISTICS_update(stats, 2498 GNUNET_STATISTICS_update (stats,
2433 gettext_noop("# Inbound CADET channels created"), 2499 gettext_noop ("# Inbound CADET channels created"),
2434 1, 2500 1,
2435 GNUNET_NO); 2501 GNUNET_NO);
2436 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 2502 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2437 "Received inbound channel from `%s'\n", 2503 "Received inbound channel from `%s'\n",
2438 GNUNET_i2s(initiator)); 2504 GNUNET_i2s (initiator));
2439 s->channel = channel; 2505 s->channel = channel;
2440 s->specifics.tcp_udp.serv = ls; 2506 s->specifics.tcp_udp.serv = ls;
2441 s->specifics.tcp_udp.ri.remote_address = ls->address; 2507 s->specifics.tcp_udp.ri.remote_address = ls->address;
@@ -2451,36 +2517,37 @@ new_service_channel(void *cls,
2451 * @param channel connection to the other end (henceforth invalid) 2517 * @param channel connection to the other end (henceforth invalid)
2452 */ 2518 */
2453static void 2519static void
2454clean_channel(void *cls, 2520clean_channel (void *cls,
2455 const struct GNUNET_CADET_Channel *channel) 2521 const struct GNUNET_CADET_Channel *channel)
2456{ 2522{
2457 struct ChannelState *s = cls; 2523 struct ChannelState *s = cls;
2458 2524
2459 LOG(GNUNET_ERROR_TYPE_DEBUG, 2525 LOG (GNUNET_ERROR_TYPE_DEBUG,
2460 "Channel destroyed\n"); 2526 "Channel destroyed\n");
2461 if (GNUNET_SYSERR == s->is_dns) 2527 if (GNUNET_SYSERR == s->is_dns)
2462 { 2528 {
2463 GNUNET_free(s); 2529 GNUNET_free (s);
2464 return; 2530 return;
2465 } 2531 }
2466 if (GNUNET_YES == s->is_dns) 2532 if (GNUNET_YES == s->is_dns)
2467 { 2533 {
2468 if (channels[s->specifics.dns.my_id] == s) 2534 if (channels[s->specifics.dns.my_id] == s)
2469 channels[s->specifics.dns.my_id] = NULL; 2535 channels[s->specifics.dns.my_id] = NULL;
2470 } 2536 }
2471 else 2537 else
2538 {
2539 if (NULL != s->specifics.tcp_udp.heap_node)
2472 { 2540 {
2473 if (NULL != s->specifics.tcp_udp.heap_node) 2541 GNUNET_assert (GNUNET_YES ==
2474 { 2542 GNUNET_CONTAINER_multihashmap_remove (connections_map,
2475 GNUNET_assert(GNUNET_YES == 2543 &s->specifics.tcp_udp
2476 GNUNET_CONTAINER_multihashmap_remove(connections_map, 2544 .state_key,
2477 &s->specifics.tcp_udp.state_key, 2545 s));
2478 s)); 2546 GNUNET_CONTAINER_heap_remove_node (s->specifics.tcp_udp.heap_node);
2479 GNUNET_CONTAINER_heap_remove_node(s->specifics.tcp_udp.heap_node); 2547 s->specifics.tcp_udp.heap_node = NULL;
2480 s->specifics.tcp_udp.heap_node = NULL;
2481 }
2482 } 2548 }
2483 GNUNET_free(s); 2549 }
2550 GNUNET_free (s);
2484} 2551}
2485 2552
2486 2553
@@ -2494,66 +2561,66 @@ clean_channel(void *cls,
2494 * @param service service information record to store (service->name will be set). 2561 * @param service service information record to store (service->name will be set).
2495 */ 2562 */
2496static void 2563static void
2497store_service(int proto, 2564store_service (int proto,
2498 const char *name, 2565 const char *name,
2499 uint16_t destination_port, 2566 uint16_t destination_port,
2500 struct LocalService *service) 2567 struct LocalService *service)
2501{ 2568{
2502 struct GNUNET_MQ_MessageHandler handlers[] = { 2569 struct GNUNET_MQ_MessageHandler handlers[] = {
2503 GNUNET_MQ_hd_var_size(icmp_service, 2570 GNUNET_MQ_hd_var_size (icmp_service,
2504 GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_SERVICE, 2571 GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_SERVICE,
2505 struct GNUNET_EXIT_IcmpServiceMessage, 2572 struct GNUNET_EXIT_IcmpServiceMessage,
2506 service), 2573 service),
2507 GNUNET_MQ_hd_var_size(udp_service, 2574 GNUNET_MQ_hd_var_size (udp_service,
2508 GNUNET_MESSAGE_TYPE_VPN_UDP_TO_SERVICE, 2575 GNUNET_MESSAGE_TYPE_VPN_UDP_TO_SERVICE,
2509 struct GNUNET_EXIT_UdpServiceMessage, 2576 struct GNUNET_EXIT_UdpServiceMessage,
2510 service), 2577 service),
2511 GNUNET_MQ_hd_var_size(tcp_service, 2578 GNUNET_MQ_hd_var_size (tcp_service,
2512 GNUNET_MESSAGE_TYPE_VPN_TCP_TO_SERVICE_START, 2579 GNUNET_MESSAGE_TYPE_VPN_TCP_TO_SERVICE_START,
2513 struct GNUNET_EXIT_TcpServiceStartMessage, 2580 struct GNUNET_EXIT_TcpServiceStartMessage,
2514 service), 2581 service),
2515 GNUNET_MQ_hd_var_size(tcp_data, 2582 GNUNET_MQ_hd_var_size (tcp_data,
2516 GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_EXIT, 2583 GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_EXIT,
2517 struct GNUNET_EXIT_TcpDataMessage, 2584 struct GNUNET_EXIT_TcpDataMessage,
2518 service), 2585 service),
2519 GNUNET_MQ_handler_end() 2586 GNUNET_MQ_handler_end ()
2520 }; 2587 };
2521 2588
2522 struct GNUNET_HashCode cadet_port; 2589 struct GNUNET_HashCode cadet_port;
2523 2590
2524 service->name = GNUNET_strdup(name); 2591 service->name = GNUNET_strdup (name);
2525 GNUNET_TUN_service_name_to_hash(name, 2592 GNUNET_TUN_service_name_to_hash (name,
2526 &service->descriptor); 2593 &service->descriptor);
2527 GNUNET_TUN_compute_service_cadet_port(&service->descriptor, 2594 GNUNET_TUN_compute_service_cadet_port (&service->descriptor,
2528 destination_port, 2595 destination_port,
2529 &cadet_port); 2596 &cadet_port);
2530 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 2597 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2531 "Opening CADET port %s for SERVICE exit %s on port %u\n", 2598 "Opening CADET port %s for SERVICE exit %s on port %u\n",
2532 GNUNET_h2s(&cadet_port), 2599 GNUNET_h2s (&cadet_port),
2533 name, 2600 name,
2534 (unsigned int)destination_port); 2601 (unsigned int) destination_port);
2535 service->port = GNUNET_CADET_open_port(cadet_handle, 2602 service->port = GNUNET_CADET_open_port (cadet_handle,
2536 &cadet_port, 2603 &cadet_port,
2537 &new_service_channel, 2604 &new_service_channel,
2538 service, 2605 service,
2539 NULL, 2606 NULL,
2540 &clean_channel, 2607 &clean_channel,
2541 handlers); 2608 handlers);
2542 service->is_udp = (IPPROTO_UDP == proto); 2609 service->is_udp = (IPPROTO_UDP == proto);
2543 if (GNUNET_OK != 2610 if (GNUNET_OK !=
2544 GNUNET_CONTAINER_multihashmap_put(services, 2611 GNUNET_CONTAINER_multihashmap_put (services,
2545 &cadet_port, 2612 &cadet_port,
2546 service, 2613 service,
2547 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)) 2614 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
2548 { 2615 {
2549 GNUNET_CADET_close_port(service->port); 2616 GNUNET_CADET_close_port (service->port);
2550 GNUNET_free_non_null(service->name); 2617 GNUNET_free_non_null (service->name);
2551 GNUNET_free(service); 2618 GNUNET_free (service);
2552 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 2619 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2553 _("Got duplicate service records for `%s:%u'\n"), 2620 _ ("Got duplicate service records for `%s:%u'\n"),
2554 name, 2621 name,
2555 (unsigned int)destination_port); 2622 (unsigned int) destination_port);
2556 } 2623 }
2557} 2624}
2558 2625
2559 2626
@@ -2564,16 +2631,17 @@ store_service(int proto,
2564 * @param env message to queue 2631 * @param env message to queue
2565 */ 2632 */
2566static void 2633static void
2567send_packet_to_cadet_channel(struct ChannelState *s, 2634send_packet_to_cadet_channel (struct ChannelState *s,
2568 struct GNUNET_MQ_Envelope *env) 2635 struct GNUNET_MQ_Envelope *env)
2569{ 2636{
2570 GNUNET_assert(NULL != s); 2637 GNUNET_assert (NULL != s);
2571 GNUNET_STATISTICS_update(stats, 2638 GNUNET_STATISTICS_update (stats,
2572 gettext_noop("# Messages transmitted via cadet channels"), 2639 gettext_noop (
2573 1, 2640 "# Messages transmitted via cadet channels"),
2574 GNUNET_NO); 2641 1,
2575 GNUNET_MQ_send(GNUNET_CADET_get_mq(s->channel), 2642 GNUNET_NO);
2576 env); 2643 GNUNET_MQ_send (GNUNET_CADET_get_mq (s->channel),
2644 env);
2577} 2645}
2578 2646
2579 2647
@@ -2589,11 +2657,11 @@ send_packet_to_cadet_channel(struct ChannelState *s,
2589 * be the original destination address) 2657 * be the original destination address)
2590 */ 2658 */
2591static void 2659static void
2592icmp_from_helper(const struct GNUNET_TUN_IcmpHeader *icmp, 2660icmp_from_helper (const struct GNUNET_TUN_IcmpHeader *icmp,
2593 size_t pktlen, 2661 size_t pktlen,
2594 int af, 2662 int af,
2595 const void *destination_ip, 2663 const void *destination_ip,
2596 const void *source_ip) 2664 const void *source_ip)
2597{ 2665{
2598 struct ChannelState *state; 2666 struct ChannelState *state;
2599 struct GNUNET_MQ_Envelope *env; 2667 struct GNUNET_MQ_Envelope *env;
@@ -2608,22 +2676,22 @@ icmp_from_helper(const struct GNUNET_TUN_IcmpHeader *icmp,
2608 { 2676 {
2609 char sbuf[INET6_ADDRSTRLEN]; 2677 char sbuf[INET6_ADDRSTRLEN];
2610 char dbuf[INET6_ADDRSTRLEN]; 2678 char dbuf[INET6_ADDRSTRLEN];
2611 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 2679 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2612 "Received ICMP packet going from %s to %s\n", 2680 "Received ICMP packet going from %s to %s\n",
2613 inet_ntop(af, 2681 inet_ntop (af,
2614 source_ip, 2682 source_ip,
2615 sbuf, sizeof(sbuf)), 2683 sbuf, sizeof(sbuf)),
2616 inet_ntop(af, 2684 inet_ntop (af,
2617 destination_ip, 2685 destination_ip,
2618 dbuf, sizeof(dbuf))); 2686 dbuf, sizeof(dbuf)));
2619 } 2687 }
2620 2688
2621 if (pktlen < sizeof(struct GNUNET_TUN_IcmpHeader)) 2689 if (pktlen < sizeof(struct GNUNET_TUN_IcmpHeader))
2622 { 2690 {
2623 /* blame kernel */ 2691 /* blame kernel */
2624 GNUNET_break(0); 2692 GNUNET_break (0);
2625 return; 2693 return;
2626 } 2694 }
2627 2695
2628 /* Find out if this is an ICMP packet in response to an existing 2696 /* Find out if this is an ICMP packet in response to an existing
2629 TCP/UDP packet and if so, figure out ports / protocol of the 2697 TCP/UDP packet and if so, figure out ports / protocol of the
@@ -2631,153 +2699,157 @@ icmp_from_helper(const struct GNUNET_TUN_IcmpHeader *icmp,
2631 source_port = 0; 2699 source_port = 0;
2632 destination_port = 0; 2700 destination_port = 0;
2633 switch (af) 2701 switch (af)
2702 {
2703 case AF_INET:
2704 protocol = IPPROTO_ICMP;
2705 switch (icmp->type)
2634 { 2706 {
2635 case AF_INET: 2707 case GNUNET_TUN_ICMPTYPE_ECHO_REPLY:
2636 protocol = IPPROTO_ICMP; 2708 case GNUNET_TUN_ICMPTYPE_ECHO_REQUEST:
2637 switch (icmp->type)
2638 {
2639 case GNUNET_TUN_ICMPTYPE_ECHO_REPLY:
2640 case GNUNET_TUN_ICMPTYPE_ECHO_REQUEST:
2641 break;
2642
2643 case GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE:
2644 case GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH:
2645 case GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED:
2646 if (pktlen <
2647 sizeof(struct GNUNET_TUN_IcmpHeader) +
2648 sizeof(struct GNUNET_TUN_IPv4Header) + 8)
2649 {
2650 /* blame kernel */
2651 GNUNET_break(0);
2652 return;
2653 }
2654 ipv4 = (const struct GNUNET_TUN_IPv4Header *)&icmp[1];
2655 protocol = ipv4->protocol;
2656 /* could be TCP or UDP, but both have the ports in the right
2657 place, so that doesn't matter here */
2658 udp = (const struct GNUNET_TUN_UdpHeader *)&ipv4[1];
2659 /* swap ports, as they are from the original message */
2660 destination_port = ntohs(udp->source_port);
2661 source_port = ntohs(udp->destination_port);
2662 /* throw away ICMP payload, won't be useful for the other side anyway */
2663 pktlen = sizeof(struct GNUNET_TUN_IcmpHeader);
2664 break;
2665
2666 default:
2667 GNUNET_STATISTICS_update(stats,
2668 gettext_noop("# ICMPv4 packets dropped (type not allowed)"),
2669 1, GNUNET_NO);
2670 return;
2671 }
2672 break; 2709 break;
2673 2710
2674 case AF_INET6: 2711 case GNUNET_TUN_ICMPTYPE_DESTINATION_UNREACHABLE:
2675 protocol = IPPROTO_ICMPV6; 2712 case GNUNET_TUN_ICMPTYPE_SOURCE_QUENCH:
2676 switch (icmp->type) 2713 case GNUNET_TUN_ICMPTYPE_TIME_EXCEEDED:
2677 { 2714 if (pktlen <
2678 case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE: 2715 sizeof(struct GNUNET_TUN_IcmpHeader)
2679 case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG: 2716 + sizeof(struct GNUNET_TUN_IPv4Header) + 8)
2680 case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED: 2717 {
2681 case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM: 2718 /* blame kernel */
2682 if (pktlen < 2719 GNUNET_break (0);
2683 sizeof(struct GNUNET_TUN_IcmpHeader) + 2720 return;
2684 sizeof(struct GNUNET_TUN_IPv6Header) + 8) 2721 }
2685 { 2722 ipv4 = (const struct GNUNET_TUN_IPv4Header *) &icmp[1];
2686 /* blame kernel */ 2723 protocol = ipv4->protocol;
2687 GNUNET_break(0); 2724 /* could be TCP or UDP, but both have the ports in the right
2688 return; 2725 place, so that doesn't matter here */
2689 } 2726 udp = (const struct GNUNET_TUN_UdpHeader *) &ipv4[1];
2690 ipv6 = (const struct GNUNET_TUN_IPv6Header *)&icmp[1]; 2727 /* swap ports, as they are from the original message */
2691 protocol = ipv6->next_header; 2728 destination_port = ntohs (udp->source_port);
2692 /* could be TCP or UDP, but both have the ports in the right 2729 source_port = ntohs (udp->destination_port);
2693 place, so that doesn't matter here */ 2730 /* throw away ICMP payload, won't be useful for the other side anyway */
2694 udp = (const struct GNUNET_TUN_UdpHeader *)&ipv6[1]; 2731 pktlen = sizeof(struct GNUNET_TUN_IcmpHeader);
2695 /* swap ports, as they are from the original message */
2696 destination_port = ntohs(udp->source_port);
2697 source_port = ntohs(udp->destination_port);
2698 /* throw away ICMP payload, won't be useful for the other side anyway */
2699 pktlen = sizeof(struct GNUNET_TUN_IcmpHeader);
2700 break;
2701
2702 case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST:
2703 case GNUNET_TUN_ICMPTYPE6_ECHO_REPLY:
2704 break;
2705
2706 default:
2707 GNUNET_STATISTICS_update(stats,
2708 gettext_noop("# ICMPv6 packets dropped (type not allowed)"),
2709 1, GNUNET_NO);
2710 return;
2711 }
2712 break; 2732 break;
2713 2733
2714 default: 2734 default:
2715 GNUNET_assert(0); 2735 GNUNET_STATISTICS_update (stats,
2736 gettext_noop (
2737 "# ICMPv4 packets dropped (type not allowed)"),
2738 1, GNUNET_NO);
2739 return;
2716 } 2740 }
2717 switch (protocol) 2741 break;
2718 {
2719 case IPPROTO_ICMP:
2720 state = get_redirect_state(af,
2721 IPPROTO_ICMP,
2722 source_ip,
2723 0,
2724 destination_ip,
2725 0,
2726 NULL);
2727 break;
2728
2729 case IPPROTO_ICMPV6:
2730 state = get_redirect_state(af,
2731 IPPROTO_ICMPV6,
2732 source_ip,
2733 0,
2734 destination_ip,
2735 0,
2736 NULL);
2737 break;
2738 2742
2739 case IPPROTO_UDP: 2743 case AF_INET6:
2740 state = get_redirect_state(af, 2744 protocol = IPPROTO_ICMPV6;
2741 IPPROTO_UDP, 2745 switch (icmp->type)
2742 source_ip, 2746 {
2743 source_port, 2747 case GNUNET_TUN_ICMPTYPE6_DESTINATION_UNREACHABLE:
2744 destination_ip, 2748 case GNUNET_TUN_ICMPTYPE6_PACKET_TOO_BIG:
2745 destination_port, 2749 case GNUNET_TUN_ICMPTYPE6_TIME_EXCEEDED:
2746 NULL); 2750 case GNUNET_TUN_ICMPTYPE6_PARAMETER_PROBLEM:
2751 if (pktlen <
2752 sizeof(struct GNUNET_TUN_IcmpHeader)
2753 + sizeof(struct GNUNET_TUN_IPv6Header) + 8)
2754 {
2755 /* blame kernel */
2756 GNUNET_break (0);
2757 return;
2758 }
2759 ipv6 = (const struct GNUNET_TUN_IPv6Header *) &icmp[1];
2760 protocol = ipv6->next_header;
2761 /* could be TCP or UDP, but both have the ports in the right
2762 place, so that doesn't matter here */
2763 udp = (const struct GNUNET_TUN_UdpHeader *) &ipv6[1];
2764 /* swap ports, as they are from the original message */
2765 destination_port = ntohs (udp->source_port);
2766 source_port = ntohs (udp->destination_port);
2767 /* throw away ICMP payload, won't be useful for the other side anyway */
2768 pktlen = sizeof(struct GNUNET_TUN_IcmpHeader);
2747 break; 2769 break;
2748 2770
2749 case IPPROTO_TCP: 2771 case GNUNET_TUN_ICMPTYPE6_ECHO_REQUEST:
2750 state = get_redirect_state(af, 2772 case GNUNET_TUN_ICMPTYPE6_ECHO_REPLY:
2751 IPPROTO_TCP,
2752 source_ip,
2753 source_port,
2754 destination_ip,
2755 destination_port,
2756 NULL);
2757 break; 2773 break;
2758 2774
2759 default: 2775 default:
2760 GNUNET_STATISTICS_update(stats, 2776 GNUNET_STATISTICS_update (stats,
2761 gettext_noop("# ICMP packets dropped (not allowed)"), 2777 gettext_noop (
2762 1, 2778 "# ICMPv6 packets dropped (type not allowed)"),
2763 GNUNET_NO); 2779 1, GNUNET_NO);
2764 return; 2780 return;
2765 } 2781 }
2782 break;
2783
2784 default:
2785 GNUNET_assert (0);
2786 }
2787 switch (protocol)
2788 {
2789 case IPPROTO_ICMP:
2790 state = get_redirect_state (af,
2791 IPPROTO_ICMP,
2792 source_ip,
2793 0,
2794 destination_ip,
2795 0,
2796 NULL);
2797 break;
2798
2799 case IPPROTO_ICMPV6:
2800 state = get_redirect_state (af,
2801 IPPROTO_ICMPV6,
2802 source_ip,
2803 0,
2804 destination_ip,
2805 0,
2806 NULL);
2807 break;
2808
2809 case IPPROTO_UDP:
2810 state = get_redirect_state (af,
2811 IPPROTO_UDP,
2812 source_ip,
2813 source_port,
2814 destination_ip,
2815 destination_port,
2816 NULL);
2817 break;
2818
2819 case IPPROTO_TCP:
2820 state = get_redirect_state (af,
2821 IPPROTO_TCP,
2822 source_ip,
2823 source_port,
2824 destination_ip,
2825 destination_port,
2826 NULL);
2827 break;
2828
2829 default:
2830 GNUNET_STATISTICS_update (stats,
2831 gettext_noop (
2832 "# ICMP packets dropped (not allowed)"),
2833 1,
2834 GNUNET_NO);
2835 return;
2836 }
2766 if (NULL == state) 2837 if (NULL == state)
2767 { 2838 {
2768 GNUNET_log(GNUNET_ERROR_TYPE_INFO, 2839 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2769 _("ICMP Packet dropped, have no matching connection information\n")); 2840 _ (
2770 return; 2841 "ICMP Packet dropped, have no matching connection information\n"));
2771 } 2842 return;
2772 env = GNUNET_MQ_msg_extra(i2v, 2843 }
2773 pktlen - sizeof(struct GNUNET_TUN_IcmpHeader), 2844 env = GNUNET_MQ_msg_extra (i2v,
2774 GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_VPN); 2845 pktlen - sizeof(struct GNUNET_TUN_IcmpHeader),
2775 i2v->af = htonl(af); 2846 GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_VPN);
2776 GNUNET_memcpy(&i2v->icmp_header, 2847 i2v->af = htonl (af);
2777 icmp, 2848 GNUNET_memcpy (&i2v->icmp_header,
2778 pktlen); 2849 icmp,
2779 send_packet_to_cadet_channel(state, 2850 pktlen);
2780 env); 2851 send_packet_to_cadet_channel (state,
2852 env);
2781} 2853}
2782 2854
2783 2855
@@ -2793,11 +2865,11 @@ icmp_from_helper(const struct GNUNET_TUN_IcmpHeader *icmp,
2793 * be the original destination address) 2865 * be the original destination address)
2794 */ 2866 */
2795static void 2867static void
2796udp_from_helper(const struct GNUNET_TUN_UdpHeader *udp, 2868udp_from_helper (const struct GNUNET_TUN_UdpHeader *udp,
2797 size_t pktlen, 2869 size_t pktlen,
2798 int af, 2870 int af,
2799 const void *destination_ip, 2871 const void *destination_ip,
2800 const void *source_ip) 2872 const void *source_ip)
2801{ 2873{
2802 struct ChannelState *state; 2874 struct ChannelState *state;
2803 struct GNUNET_MQ_Envelope *env; 2875 struct GNUNET_MQ_Envelope *env;
@@ -2807,53 +2879,54 @@ udp_from_helper(const struct GNUNET_TUN_UdpHeader *udp,
2807 char sbuf[INET6_ADDRSTRLEN]; 2879 char sbuf[INET6_ADDRSTRLEN];
2808 char dbuf[INET6_ADDRSTRLEN]; 2880 char dbuf[INET6_ADDRSTRLEN];
2809 2881
2810 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 2882 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2811 "Received UDP packet going from %s:%u to %s:%u\n", 2883 "Received UDP packet going from %s:%u to %s:%u\n",
2812 inet_ntop(af, 2884 inet_ntop (af,
2813 source_ip, 2885 source_ip,
2814 sbuf, sizeof(sbuf)), 2886 sbuf, sizeof(sbuf)),
2815 (unsigned int)ntohs(udp->source_port), 2887 (unsigned int) ntohs (udp->source_port),
2816 inet_ntop(af, 2888 inet_ntop (af,
2817 destination_ip, 2889 destination_ip,
2818 dbuf, sizeof(dbuf)), 2890 dbuf, sizeof(dbuf)),
2819 (unsigned int)ntohs(udp->destination_port)); 2891 (unsigned int) ntohs (udp->destination_port));
2820 } 2892 }
2821 2893
2822 if (pktlen < sizeof(struct GNUNET_TUN_UdpHeader)) 2894 if (pktlen < sizeof(struct GNUNET_TUN_UdpHeader))
2823 { 2895 {
2824 /* blame kernel */ 2896 /* blame kernel */
2825 GNUNET_break(0); 2897 GNUNET_break (0);
2826 return; 2898 return;
2827 } 2899 }
2828 if (pktlen != ntohs(udp->len)) 2900 if (pktlen != ntohs (udp->len))
2829 { 2901 {
2830 /* blame kernel */ 2902 /* blame kernel */
2831 GNUNET_break(0); 2903 GNUNET_break (0);
2832 return; 2904 return;
2833 } 2905 }
2834 state = get_redirect_state(af, 2906 state = get_redirect_state (af,
2835 IPPROTO_UDP, 2907 IPPROTO_UDP,
2836 source_ip, 2908 source_ip,
2837 ntohs(udp->source_port), 2909 ntohs (udp->source_port),
2838 destination_ip, 2910 destination_ip,
2839 ntohs(udp->destination_port), 2911 ntohs (udp->destination_port),
2840 NULL); 2912 NULL);
2841 if (NULL == state) 2913 if (NULL == state)
2842 { 2914 {
2843 GNUNET_log(GNUNET_ERROR_TYPE_INFO, 2915 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2844 _("UDP Packet dropped, have no matching connection information\n")); 2916 _ (
2845 return; 2917 "UDP Packet dropped, have no matching connection information\n"));
2846 } 2918 return;
2847 env = GNUNET_MQ_msg_extra(urm, 2919 }
2848 pktlen - sizeof(struct GNUNET_TUN_UdpHeader), 2920 env = GNUNET_MQ_msg_extra (urm,
2849 GNUNET_MESSAGE_TYPE_VPN_UDP_REPLY); 2921 pktlen - sizeof(struct GNUNET_TUN_UdpHeader),
2850 urm->source_port = htons(0); 2922 GNUNET_MESSAGE_TYPE_VPN_UDP_REPLY);
2851 urm->destination_port = htons(0); 2923 urm->source_port = htons (0);
2852 GNUNET_memcpy(&urm[1], 2924 urm->destination_port = htons (0);
2853 &udp[1], 2925 GNUNET_memcpy (&urm[1],
2854 pktlen - sizeof(struct GNUNET_TUN_UdpHeader)); 2926 &udp[1],
2855 send_packet_to_cadet_channel(state, 2927 pktlen - sizeof(struct GNUNET_TUN_UdpHeader));
2856 env); 2928 send_packet_to_cadet_channel (state,
2929 env);
2857} 2930}
2858 2931
2859 2932
@@ -2869,11 +2942,11 @@ udp_from_helper(const struct GNUNET_TUN_UdpHeader *udp,
2869 * be the original destination address) 2942 * be the original destination address)
2870 */ 2943 */
2871static void 2944static void
2872tcp_from_helper(const struct GNUNET_TUN_TcpHeader *tcp, 2945tcp_from_helper (const struct GNUNET_TUN_TcpHeader *tcp,
2873 size_t pktlen, 2946 size_t pktlen,
2874 int af, 2947 int af,
2875 const void *destination_ip, 2948 const void *destination_ip,
2876 const void *source_ip) 2949 const void *source_ip)
2877{ 2950{
2878 struct ChannelState *state; 2951 struct ChannelState *state;
2879 char buf[pktlen] GNUNET_ALIGN; 2952 char buf[pktlen] GNUNET_ALIGN;
@@ -2885,62 +2958,64 @@ tcp_from_helper(const struct GNUNET_TUN_TcpHeader *tcp,
2885 { 2958 {
2886 char sbuf[INET6_ADDRSTRLEN]; 2959 char sbuf[INET6_ADDRSTRLEN];
2887 char dbuf[INET6_ADDRSTRLEN]; 2960 char dbuf[INET6_ADDRSTRLEN];
2888 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 2961 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2889 "Received TCP packet with %u bytes going from %s:%u to %s:%u\n", 2962 "Received TCP packet with %u bytes going from %s:%u to %s:%u\n",
2890 (unsigned int)(pktlen - sizeof(struct GNUNET_TUN_TcpHeader)), 2963 (unsigned int) (pktlen - sizeof(struct GNUNET_TUN_TcpHeader)),
2891 inet_ntop(af, 2964 inet_ntop (af,
2892 source_ip, 2965 source_ip,
2893 sbuf, sizeof(sbuf)), 2966 sbuf, sizeof(sbuf)),
2894 (unsigned int)ntohs(tcp->source_port), 2967 (unsigned int) ntohs (tcp->source_port),
2895 inet_ntop(af, 2968 inet_ntop (af,
2896 destination_ip, 2969 destination_ip,
2897 dbuf, sizeof(dbuf)), 2970 dbuf, sizeof(dbuf)),
2898 (unsigned int)ntohs(tcp->destination_port)); 2971 (unsigned int) ntohs (tcp->destination_port));
2899 } 2972 }
2900 2973
2901 if (pktlen < sizeof(struct GNUNET_TUN_TcpHeader)) 2974 if (pktlen < sizeof(struct GNUNET_TUN_TcpHeader))
2902 { 2975 {
2903 /* blame kernel */ 2976 /* blame kernel */
2904 GNUNET_break(0); 2977 GNUNET_break (0);
2905 return; 2978 return;
2906 } 2979 }
2907 state = get_redirect_state(af, 2980 state = get_redirect_state (af,
2908 IPPROTO_TCP, 2981 IPPROTO_TCP,
2909 source_ip, 2982 source_ip,
2910 ntohs(tcp->source_port), 2983 ntohs (tcp->source_port),
2911 destination_ip, 2984 destination_ip,
2912 ntohs(tcp->destination_port), 2985 ntohs (tcp->destination_port),
2913 NULL); 2986 NULL);
2914 if (NULL == state) 2987 if (NULL == state)
2915 { 2988 {
2916 GNUNET_log(GNUNET_ERROR_TYPE_INFO, 2989 GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2917 _("TCP Packet dropped, have no matching connection information\n")); 2990 _ (
2991 "TCP Packet dropped, have no matching connection information\n"));
2918 2992
2919 return; 2993 return;
2920 } 2994 }
2921 /* mug port numbers and crc to avoid information leakage; 2995 /* mug port numbers and crc to avoid information leakage;
2922 sender will need to lookup the correct values anyway */ 2996 sender will need to lookup the correct values anyway */
2923 GNUNET_memcpy(buf, tcp, pktlen); 2997 GNUNET_memcpy (buf, tcp, pktlen);
2924 mtcp = (struct GNUNET_TUN_TcpHeader *)buf; 2998 mtcp = (struct GNUNET_TUN_TcpHeader *) buf;
2925 mtcp->source_port = 0; 2999 mtcp->source_port = 0;
2926 mtcp->destination_port = 0; 3000 mtcp->destination_port = 0;
2927 mtcp->crc = 0; 3001 mtcp->crc = 0;
2928 3002
2929 mlen = sizeof(struct GNUNET_EXIT_TcpDataMessage) + (pktlen - sizeof(struct GNUNET_TUN_TcpHeader)); 3003 mlen = sizeof(struct GNUNET_EXIT_TcpDataMessage) + (pktlen - sizeof(struct
3004 GNUNET_TUN_TcpHeader));
2930 if (mlen >= GNUNET_MAX_MESSAGE_SIZE) 3005 if (mlen >= GNUNET_MAX_MESSAGE_SIZE)
2931 { 3006 {
2932 GNUNET_break(0); 3007 GNUNET_break (0);
2933 return; 3008 return;
2934 } 3009 }
2935 env = GNUNET_MQ_msg_extra(tdm, 3010 env = GNUNET_MQ_msg_extra (tdm,
2936 pktlen - sizeof(struct GNUNET_TUN_TcpHeader), 3011 pktlen - sizeof(struct GNUNET_TUN_TcpHeader),
2937 GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_VPN); 3012 GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_VPN);
2938 tdm->reserved = htonl(0); 3013 tdm->reserved = htonl (0);
2939 GNUNET_memcpy(&tdm->tcp_header, 3014 GNUNET_memcpy (&tdm->tcp_header,
2940 buf, 3015 buf,
2941 pktlen); 3016 pktlen);
2942 send_packet_to_cadet_channel(state, 3017 send_packet_to_cadet_channel (state,
2943 env); 3018 env);
2944} 3019}
2945 3020
2946 3021
@@ -2951,150 +3026,155 @@ tcp_from_helper(const struct GNUNET_TUN_TcpHeader *tcp,
2951 * @param message message received from helper 3026 * @param message message received from helper
2952 */ 3027 */
2953static int 3028static int
2954message_token(void *cls GNUNET_UNUSED, 3029message_token (void *cls GNUNET_UNUSED,
2955 const struct GNUNET_MessageHeader *message) 3030 const struct GNUNET_MessageHeader *message)
2956{ 3031{
2957 const struct GNUNET_TUN_Layer2PacketHeader *pkt_tun; 3032 const struct GNUNET_TUN_Layer2PacketHeader *pkt_tun;
2958 size_t size; 3033 size_t size;
2959 3034
2960 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 3035 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2961 "Got %u-byte message of type %u from gnunet-helper-exit\n", 3036 "Got %u-byte message of type %u from gnunet-helper-exit\n",
2962 ntohs(message->size), 3037 ntohs (message->size),
2963 ntohs(message->type)); 3038 ntohs (message->type));
2964 GNUNET_STATISTICS_update(stats, 3039 GNUNET_STATISTICS_update (stats,
2965 gettext_noop("# Packets received from TUN"), 3040 gettext_noop ("# Packets received from TUN"),
2966 1, GNUNET_NO); 3041 1, GNUNET_NO);
2967 if (ntohs(message->type) != GNUNET_MESSAGE_TYPE_VPN_HELPER) 3042 if (ntohs (message->type) != GNUNET_MESSAGE_TYPE_VPN_HELPER)
2968 { 3043 {
2969 GNUNET_break(0); 3044 GNUNET_break (0);
2970 return GNUNET_OK; 3045 return GNUNET_OK;
2971 } 3046 }
2972 size = ntohs(message->size); 3047 size = ntohs (message->size);
2973 if (size < sizeof(struct GNUNET_TUN_Layer2PacketHeader) + sizeof(struct GNUNET_MessageHeader)) 3048 if (size < sizeof(struct GNUNET_TUN_Layer2PacketHeader) + sizeof(struct
2974 { 3049 GNUNET_MessageHeader))
2975 GNUNET_break(0); 3050 {
2976 return GNUNET_OK; 3051 GNUNET_break (0);
2977 } 3052 return GNUNET_OK;
2978 GNUNET_STATISTICS_update(stats, 3053 }
2979 gettext_noop("# Bytes received from TUN"), 3054 GNUNET_STATISTICS_update (stats,
2980 size, GNUNET_NO); 3055 gettext_noop ("# Bytes received from TUN"),
2981 pkt_tun = (const struct GNUNET_TUN_Layer2PacketHeader *)&message[1]; 3056 size, GNUNET_NO);
2982 size -= sizeof(struct GNUNET_TUN_Layer2PacketHeader) + sizeof(struct GNUNET_MessageHeader); 3057 pkt_tun = (const struct GNUNET_TUN_Layer2PacketHeader *) &message[1];
2983 switch (ntohs(pkt_tun->proto)) 3058 size -= sizeof(struct GNUNET_TUN_Layer2PacketHeader) + sizeof(struct
2984 { 3059 GNUNET_MessageHeader);
2985 case ETH_P_IPV4: 3060 switch (ntohs (pkt_tun->proto))
3061 {
3062 case ETH_P_IPV4:
2986 { 3063 {
2987 const struct GNUNET_TUN_IPv4Header *pkt4; 3064 const struct GNUNET_TUN_IPv4Header *pkt4;
2988 3065
2989 if (size < sizeof(struct GNUNET_TUN_IPv4Header)) 3066 if (size < sizeof(struct GNUNET_TUN_IPv4Header))
2990 { 3067 {
2991 /* Kernel to blame? */ 3068 /* Kernel to blame? */
2992 GNUNET_break(0); 3069 GNUNET_break (0);
2993 return GNUNET_OK; 3070 return GNUNET_OK;
2994 } 3071 }
2995 pkt4 = (const struct GNUNET_TUN_IPv4Header *)&pkt_tun[1]; 3072 pkt4 = (const struct GNUNET_TUN_IPv4Header *) &pkt_tun[1];
2996 if (size != ntohs(pkt4->total_length)) 3073 if (size != ntohs (pkt4->total_length))
2997 { 3074 {
2998 /* Kernel to blame? */ 3075 /* Kernel to blame? */
2999 GNUNET_break(0); 3076 GNUNET_break (0);
3000 return GNUNET_OK; 3077 return GNUNET_OK;
3001 } 3078 }
3002 if (pkt4->header_length * 4 != sizeof(struct GNUNET_TUN_IPv4Header)) 3079 if (pkt4->header_length * 4 != sizeof(struct GNUNET_TUN_IPv4Header))
3003 { 3080 {
3004 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 3081 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3005 _("IPv4 packet options received. Ignored.\n")); 3082 _ ("IPv4 packet options received. Ignored.\n"));
3006 return GNUNET_OK; 3083 return GNUNET_OK;
3007 } 3084 }
3008 3085
3009 size -= sizeof(struct GNUNET_TUN_IPv4Header); 3086 size -= sizeof(struct GNUNET_TUN_IPv4Header);
3010 switch (pkt4->protocol) 3087 switch (pkt4->protocol)
3011 { 3088 {
3012 case IPPROTO_UDP: 3089 case IPPROTO_UDP:
3013 udp_from_helper((const struct GNUNET_TUN_UdpHeader *)&pkt4[1], size, 3090 udp_from_helper ((const struct GNUNET_TUN_UdpHeader *) &pkt4[1], size,
3014 AF_INET, 3091 AF_INET,
3015 &pkt4->destination_address, 3092 &pkt4->destination_address,
3016 &pkt4->source_address); 3093 &pkt4->source_address);
3017 break; 3094 break;
3018 3095
3019 case IPPROTO_TCP: 3096 case IPPROTO_TCP:
3020 tcp_from_helper((const struct GNUNET_TUN_TcpHeader *)&pkt4[1], size, 3097 tcp_from_helper ((const struct GNUNET_TUN_TcpHeader *) &pkt4[1], size,
3098 AF_INET,
3099 &pkt4->destination_address,
3100 &pkt4->source_address);
3101 break;
3102
3103 case IPPROTO_ICMP:
3104 icmp_from_helper ((const struct GNUNET_TUN_IcmpHeader *) &pkt4[1], size,
3021 AF_INET, 3105 AF_INET,
3022 &pkt4->destination_address, 3106 &pkt4->destination_address,
3023 &pkt4->source_address); 3107 &pkt4->source_address);
3024 break; 3108 break;
3025 3109
3026 case IPPROTO_ICMP: 3110 default:
3027 icmp_from_helper((const struct GNUNET_TUN_IcmpHeader *)&pkt4[1], size, 3111 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3028 AF_INET, 3112 _ (
3029 &pkt4->destination_address, 3113 "IPv4 packet with unsupported next header %u received. Ignored.\n"),
3030 &pkt4->source_address); 3114 (int) pkt4->protocol);
3031 break; 3115 return GNUNET_OK;
3032 3116 }
3033 default:
3034 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
3035 _("IPv4 packet with unsupported next header %u received. Ignored.\n"),
3036 (int)pkt4->protocol);
3037 return GNUNET_OK;
3038 }
3039 } 3117 }
3040 break; 3118 break;
3041 3119
3042 case ETH_P_IPV6: 3120 case ETH_P_IPV6:
3043 { 3121 {
3044 const struct GNUNET_TUN_IPv6Header *pkt6; 3122 const struct GNUNET_TUN_IPv6Header *pkt6;
3045 3123
3046 if (size < sizeof(struct GNUNET_TUN_IPv6Header)) 3124 if (size < sizeof(struct GNUNET_TUN_IPv6Header))
3047 { 3125 {
3048 /* Kernel to blame? */ 3126 /* Kernel to blame? */
3049 GNUNET_break(0); 3127 GNUNET_break (0);
3050 return GNUNET_OK; 3128 return GNUNET_OK;
3051 } 3129 }
3052 pkt6 = (struct GNUNET_TUN_IPv6Header *)&pkt_tun[1]; 3130 pkt6 = (struct GNUNET_TUN_IPv6Header *) &pkt_tun[1];
3053 if (size != ntohs(pkt6->payload_length) + sizeof(struct GNUNET_TUN_IPv6Header)) 3131 if (size != ntohs (pkt6->payload_length) + sizeof(struct
3054 { 3132 GNUNET_TUN_IPv6Header))
3055 /* Kernel to blame? */ 3133 {
3056 GNUNET_break(0); 3134 /* Kernel to blame? */
3057 return GNUNET_OK; 3135 GNUNET_break (0);
3058 } 3136 return GNUNET_OK;
3137 }
3059 size -= sizeof(struct GNUNET_TUN_IPv6Header); 3138 size -= sizeof(struct GNUNET_TUN_IPv6Header);
3060 switch (pkt6->next_header) 3139 switch (pkt6->next_header)
3061 { 3140 {
3062 case IPPROTO_UDP: 3141 case IPPROTO_UDP:
3063 udp_from_helper((const struct GNUNET_TUN_UdpHeader *)&pkt6[1], size, 3142 udp_from_helper ((const struct GNUNET_TUN_UdpHeader *) &pkt6[1], size,
3064 AF_INET6, 3143 AF_INET6,
3065 &pkt6->destination_address, 3144 &pkt6->destination_address,
3066 &pkt6->source_address); 3145 &pkt6->source_address);
3067 break; 3146 break;
3147
3148 case IPPROTO_TCP:
3149 tcp_from_helper ((const struct GNUNET_TUN_TcpHeader *) &pkt6[1], size,
3150 AF_INET6,
3151 &pkt6->destination_address,
3152 &pkt6->source_address);
3153 break;
3068 3154
3069 case IPPROTO_TCP: 3155 case IPPROTO_ICMPV6:
3070 tcp_from_helper((const struct GNUNET_TUN_TcpHeader *)&pkt6[1], size, 3156 icmp_from_helper ((const struct GNUNET_TUN_IcmpHeader *) &pkt6[1], size,
3071 AF_INET6, 3157 AF_INET6,
3072 &pkt6->destination_address, 3158 &pkt6->destination_address,
3073 &pkt6->source_address); 3159 &pkt6->source_address);
3074 break; 3160 break;
3075 3161
3076 case IPPROTO_ICMPV6: 3162 default:
3077 icmp_from_helper((const struct GNUNET_TUN_IcmpHeader *)&pkt6[1], size, 3163 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3078 AF_INET6, 3164 _ (
3079 &pkt6->destination_address, 3165 "IPv6 packet with unsupported next header %d received. Ignored.\n"),
3080 &pkt6->source_address); 3166 pkt6->next_header);
3081 break; 3167 return GNUNET_OK;
3082 3168 }
3083 default:
3084 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
3085 _("IPv6 packet with unsupported next header %d received. Ignored.\n"),
3086 pkt6->next_header);
3087 return GNUNET_OK;
3088 }
3089 } 3169 }
3090 break; 3170 break;
3091 3171
3092 default: 3172 default:
3093 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 3173 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3094 _("Packet from unknown protocol %u received. Ignored.\n"), 3174 _ ("Packet from unknown protocol %u received. Ignored.\n"),
3095 ntohs(pkt_tun->proto)); 3175 ntohs (pkt_tun->proto));
3096 break; 3176 break;
3097 } 3177 }
3098 return GNUNET_OK; 3178 return GNUNET_OK;
3099} 3179}
3100 3180
@@ -3108,21 +3188,21 @@ message_token(void *cls GNUNET_UNUSED,
3108 * @return initial channel context for the channel 3188 * @return initial channel context for the channel
3109 */ 3189 */
3110static void * 3190static void *
3111new_channel(void *cls, 3191new_channel (void *cls,
3112 struct GNUNET_CADET_Channel *channel, 3192 struct GNUNET_CADET_Channel *channel,
3113 const struct GNUNET_PeerIdentity *initiator) 3193 const struct GNUNET_PeerIdentity *initiator)
3114{ 3194{
3115 struct ChannelState *s = GNUNET_new(struct ChannelState); 3195 struct ChannelState *s = GNUNET_new (struct ChannelState);
3116 3196
3117 s->is_dns = GNUNET_SYSERR; 3197 s->is_dns = GNUNET_SYSERR;
3118 s->peer = *initiator; 3198 s->peer = *initiator;
3119 GNUNET_STATISTICS_update(stats, 3199 GNUNET_STATISTICS_update (stats,
3120 gettext_noop("# Inbound CADET channels created"), 3200 gettext_noop ("# Inbound CADET channels created"),
3121 1, 3201 1,
3122 GNUNET_NO); 3202 GNUNET_NO);
3123 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 3203 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3124 "Received inbound channel from `%s'\n", 3204 "Received inbound channel from `%s'\n",
3125 GNUNET_i2s(initiator)); 3205 GNUNET_i2s (initiator));
3126 s->channel = channel; 3206 s->channel = channel;
3127 return s; 3207 return s;
3128} 3208}
@@ -3136,11 +3216,11 @@ new_channel(void *cls,
3136 * @param value value to free 3216 * @param value value to free
3137 */ 3217 */
3138static int 3218static int
3139free_iterate(void *cls, 3219free_iterate (void *cls,
3140 const struct GNUNET_HashCode * hash, 3220 const struct GNUNET_HashCode *hash,
3141 void *value) 3221 void *value)
3142{ 3222{
3143 GNUNET_free(value); 3223 GNUNET_free (value);
3144 return GNUNET_YES; 3224 return GNUNET_YES;
3145} 3225}
3146 3226
@@ -3155,7 +3235,7 @@ free_iterate(void *cls,
3155 * @param tc scheduler context 3235 * @param tc scheduler context
3156 */ 3236 */
3157static void 3237static void
3158dummy_task(void *cls) 3238dummy_task (void *cls)
3159{ 3239{
3160 /* just terminate */ 3240 /* just terminate */
3161} 3241}
@@ -3167,101 +3247,101 @@ dummy_task(void *cls)
3167 * @param cls NULL 3247 * @param cls NULL
3168 */ 3248 */
3169static void 3249static void
3170cleanup(void *cls) 3250cleanup (void *cls)
3171{ 3251{
3172 unsigned int i; 3252 unsigned int i;
3173 3253
3174 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 3254 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3175 "Exit service is shutting down now\n"); 3255 "Exit service is shutting down now\n");
3176 3256
3177 if (NULL != helper_handle) 3257 if (NULL != helper_handle)
3178 { 3258 {
3179 GNUNET_HELPER_stop(helper_handle, GNUNET_NO); 3259 GNUNET_HELPER_stop (helper_handle, GNUNET_NO);
3180 helper_handle = NULL; 3260 helper_handle = NULL;
3181 } 3261 }
3182 if (NULL != regex4) 3262 if (NULL != regex4)
3183 { 3263 {
3184 GNUNET_REGEX_announce_cancel(regex4); 3264 GNUNET_REGEX_announce_cancel (regex4);
3185 regex4 = NULL; 3265 regex4 = NULL;
3186 } 3266 }
3187 if (NULL != regex6) 3267 if (NULL != regex6)
3188 { 3268 {
3189 GNUNET_REGEX_announce_cancel(regex6); 3269 GNUNET_REGEX_announce_cancel (regex6);
3190 regex6 = NULL; 3270 regex6 = NULL;
3191 } 3271 }
3192 if (NULL != services) 3272 if (NULL != services)
3193 { 3273 {
3194 GNUNET_CONTAINER_multihashmap_iterate(services, 3274 GNUNET_CONTAINER_multihashmap_iterate (services,
3195 &free_service_record, 3275 &free_service_record,
3196 NULL); 3276 NULL);
3197 GNUNET_CONTAINER_multihashmap_destroy(services); 3277 GNUNET_CONTAINER_multihashmap_destroy (services);
3198 } 3278 }
3199 if (NULL != dns_port) 3279 if (NULL != dns_port)
3200 { 3280 {
3201 GNUNET_CADET_close_port(dns_port); 3281 GNUNET_CADET_close_port (dns_port);
3202 dns_port = NULL; 3282 dns_port = NULL;
3203 } 3283 }
3204 if (NULL != cadet_port4) 3284 if (NULL != cadet_port4)
3205 { 3285 {
3206 GNUNET_CADET_close_port(cadet_port4); 3286 GNUNET_CADET_close_port (cadet_port4);
3207 cadet_port4 = NULL; 3287 cadet_port4 = NULL;
3208 } 3288 }
3209 if (NULL != cadet_port6) 3289 if (NULL != cadet_port6)
3210 { 3290 {
3211 GNUNET_CADET_close_port(cadet_port6); 3291 GNUNET_CADET_close_port (cadet_port6);
3212 cadet_port6 = NULL; 3292 cadet_port6 = NULL;
3213 } 3293 }
3214 if (NULL != cadet_handle) 3294 if (NULL != cadet_handle)
3215 { 3295 {
3216 GNUNET_CADET_disconnect(cadet_handle); 3296 GNUNET_CADET_disconnect (cadet_handle);
3217 cadet_handle = NULL; 3297 cadet_handle = NULL;
3218 } 3298 }
3219 if (NULL != connections_map) 3299 if (NULL != connections_map)
3220 { 3300 {
3221 GNUNET_CONTAINER_multihashmap_iterate(connections_map, 3301 GNUNET_CONTAINER_multihashmap_iterate (connections_map,
3222 &free_iterate, 3302 &free_iterate,
3223 NULL); 3303 NULL);
3224 GNUNET_CONTAINER_multihashmap_destroy(connections_map); 3304 GNUNET_CONTAINER_multihashmap_destroy (connections_map);
3225 connections_map = NULL; 3305 connections_map = NULL;
3226 } 3306 }
3227 if (NULL != connections_heap) 3307 if (NULL != connections_heap)
3228 { 3308 {
3229 GNUNET_CONTAINER_heap_destroy(connections_heap); 3309 GNUNET_CONTAINER_heap_destroy (connections_heap);
3230 connections_heap = NULL; 3310 connections_heap = NULL;
3231 } 3311 }
3232 if (NULL != dnsstub) 3312 if (NULL != dnsstub)
3233 { 3313 {
3234 GNUNET_DNSSTUB_stop(dnsstub); 3314 GNUNET_DNSSTUB_stop (dnsstub);
3235 dnsstub = NULL; 3315 dnsstub = NULL;
3236 } 3316 }
3237 if (NULL != peer_key) 3317 if (NULL != peer_key)
3238 { 3318 {
3239 GNUNET_free(peer_key); 3319 GNUNET_free (peer_key);
3240 peer_key = NULL; 3320 peer_key = NULL;
3241 } 3321 }
3242 if (NULL != dht_task) 3322 if (NULL != dht_task)
3243 { 3323 {
3244 GNUNET_SCHEDULER_cancel(dht_task); 3324 GNUNET_SCHEDULER_cancel (dht_task);
3245 dht_task = NULL; 3325 dht_task = NULL;
3246 } 3326 }
3247 if (NULL != dht_put) 3327 if (NULL != dht_put)
3248 { 3328 {
3249 GNUNET_DHT_put_cancel(dht_put); 3329 GNUNET_DHT_put_cancel (dht_put);
3250 dht_put = NULL; 3330 dht_put = NULL;
3251 } 3331 }
3252 if (NULL != dht) 3332 if (NULL != dht)
3253 { 3333 {
3254 GNUNET_DHT_disconnect(dht); 3334 GNUNET_DHT_disconnect (dht);
3255 dht = NULL; 3335 dht = NULL;
3256 } 3336 }
3257 if (NULL != stats) 3337 if (NULL != stats)
3258 { 3338 {
3259 GNUNET_STATISTICS_destroy(stats, 3339 GNUNET_STATISTICS_destroy (stats,
3260 GNUNET_NO); 3340 GNUNET_NO);
3261 stats = NULL; 3341 stats = NULL;
3262 } 3342 }
3263 for (i = 0; i < 8; i++) 3343 for (i = 0; i < 8; i++)
3264 GNUNET_free_non_null(exit_argv[i]); 3344 GNUNET_free_non_null (exit_argv[i]);
3265} 3345}
3266 3346
3267 3347
@@ -3273,9 +3353,9 @@ cleanup(void *cls)
3273 * @param name DNS name of the service 3353 * @param name DNS name of the service
3274 */ 3354 */
3275static void 3355static void
3276add_services(int proto, 3356add_services (int proto,
3277 char *cpy, 3357 char *cpy,
3278 const char *name) 3358 const char *name)
3279{ 3359{
3280 char *redirect; 3360 char *redirect;
3281 char *hostname; 3361 char *hostname;
@@ -3284,144 +3364,150 @@ add_services(int proto,
3284 char *n; 3364 char *n;
3285 size_t slen; 3365 size_t slen;
3286 3366
3287 slen = strlen(name); 3367 slen = strlen (name);
3288 GNUNET_assert(slen >= 8); 3368 GNUNET_assert (slen >= 8);
3289 n = GNUNET_strndup(name, slen - 8 /* remove .gnunet. */); 3369 n = GNUNET_strndup (name, slen - 8 /* remove .gnunet. */);
3290 3370
3291 for (redirect = strtok(cpy, " ;"); redirect != NULL; 3371 for (redirect = strtok (cpy, " ;"); redirect != NULL;
3292 redirect = strtok(NULL, " ;")) 3372 redirect = strtok (NULL, " ;"))
3373 {
3374 if (NULL == (hostname = strstr (redirect, ":")))
3293 { 3375 {
3294 if (NULL == (hostname = strstr(redirect, ":"))) 3376 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3295 { 3377 _ (
3296 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 3378 "Option `%s' for domain `%s' is not formatted correctly!\n"),
3297 _("Option `%s' for domain `%s' is not formatted correctly!\n"), 3379 redirect,
3298 redirect, 3380 name);
3299 name); 3381 continue;
3300 continue; 3382 }
3301 } 3383 hostname[0] = '\0';
3302 hostname[0] = '\0'; 3384 hostname++;
3303 hostname++; 3385 if (NULL == (hostport = strstr (hostname, ":")))
3304 if (NULL == (hostport = strstr(hostname, ":"))) 3386 {
3305 { 3387 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3306 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 3388 _ (
3307 _("Option `%s' for domain `%s' is not formatted correctly!\n"), 3389 "Option `%s' for domain `%s' is not formatted correctly!\n"),
3308 redirect, 3390 redirect,
3309 name); 3391 name);
3310 continue; 3392 continue;
3311 } 3393 }
3312 hostport[0] = '\0'; 3394 hostport[0] = '\0';
3313 hostport++; 3395 hostport++;
3314 3396
3315 int local_port = atoi(redirect); 3397 int local_port = atoi (redirect);
3316 int remote_port = atoi(hostport); 3398 int remote_port = atoi (hostport);
3317 3399
3318 if (!((local_port > 0) && (local_port < 65536))) 3400 if (! ((local_port > 0) && (local_port < 65536)))
3319 { 3401 {
3320 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 3402 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3321 _("`%s' is not a valid port number (for domain `%s')!"), 3403 _ ("`%s' is not a valid port number (for domain `%s')!"),
3322 redirect, 3404 redirect,
3323 name); 3405 name);
3324 continue; 3406 continue;
3325 } 3407 }
3326 if (!((remote_port > 0) && (remote_port < 65536))) 3408 if (! ((remote_port > 0) && (remote_port < 65536)))
3409 {
3410 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3411 _ ("`%s' is not a valid port number (for domain `%s')!"),
3412 hostport,
3413 name);
3414 continue;
3415 }
3416
3417 serv = GNUNET_new (struct LocalService);
3418 serv->address.proto = proto;
3419 serv->address.port = remote_port;
3420 if (0 == strcmp ("localhost4",
3421 hostname))
3422 {
3423 const char *ip4addr = exit_argv[5];
3424
3425 serv->address.af = AF_INET;
3426 GNUNET_assert (1 == inet_pton (AF_INET,
3427 ip4addr,
3428 &serv->address.address.ipv4));
3429 }
3430 else if (0 == strcmp ("localhost6",
3431 hostname))
3432 {
3433 const char *ip6addr = exit_argv[3];
3434
3435 serv->address.af = AF_INET6;
3436 GNUNET_assert (1 == inet_pton (AF_INET6,
3437 ip6addr,
3438 &serv->address.address.ipv6));
3439 }
3440 else
3441 {
3442 struct addrinfo *res;
3443 int ret;
3444
3445 ret = getaddrinfo (hostname,
3446 NULL,
3447 NULL,
3448 &res);
3449 if ((0 != ret) || (NULL == res))
3450 {
3451 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3452 _ (
3453 "No addresses found for hostname `%s' of service `%s'!\n"),
3454 hostname,
3455 n);
3456 GNUNET_free (serv);
3457 continue;
3458 }
3459
3460 serv->address.af = res->ai_family;
3461 switch (res->ai_family)
3462 {
3463 case AF_INET:
3464 if (! ipv4_enabled)
3327 { 3465 {
3328 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 3466 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3329 _("`%s' is not a valid port number (for domain `%s')!"), 3467 _ (
3330 hostport, 3468 "Service `%s' configured for IPv4, but IPv4 is disabled!\n"),
3331 name); 3469 n);
3470 freeaddrinfo (res);
3471 GNUNET_free (serv);
3332 continue; 3472 continue;
3333 } 3473 }
3474 serv->address.address.ipv4
3475 = ((struct sockaddr_in *) res->ai_addr)->sin_addr;
3476 break;
3334 3477
3335 serv = GNUNET_new(struct LocalService); 3478 case AF_INET6:
3336 serv->address.proto = proto; 3479 if (! ipv6_enabled)
3337 serv->address.port = remote_port;
3338 if (0 == strcmp("localhost4",
3339 hostname))
3340 { 3480 {
3341 const char *ip4addr = exit_argv[5]; 3481 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3342 3482 _ (
3343 serv->address.af = AF_INET; 3483 "Service `%s' configured for IPv4, but IPv4 is disabled!\n"),
3344 GNUNET_assert(1 == inet_pton(AF_INET, 3484 n);
3345 ip4addr, 3485 freeaddrinfo (res);
3346 &serv->address.address.ipv4)); 3486 GNUNET_free (serv);
3487 continue;
3347 } 3488 }
3348 else if (0 == strcmp("localhost6", 3489 serv->address.address.ipv6
3349 hostname)) 3490 = ((struct sockaddr_in6 *) res->ai_addr)->sin6_addr;
3350 { 3491 break;
3351 const char *ip6addr = exit_argv[3];
3352 3492
3353 serv->address.af = AF_INET6; 3493 default:
3354 GNUNET_assert(1 == inet_pton(AF_INET6, 3494 freeaddrinfo (res);
3355 ip6addr, 3495 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
3356 &serv->address.address.ipv6)); 3496 _ (
3357 } 3497 "No IP addresses found for hostname `%s' of service `%s'!\n"),
3358 else 3498 hostname,
3359 { 3499 n);
3360 struct addrinfo *res; 3500 GNUNET_free (serv);
3361 int ret; 3501 continue;
3362 3502 }
3363 ret = getaddrinfo(hostname, 3503 freeaddrinfo (res);
3364 NULL,
3365 NULL,
3366 &res);
3367 if ((0 != ret) || (NULL == res))
3368 {
3369 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
3370 _("No addresses found for hostname `%s' of service `%s'!\n"),
3371 hostname,
3372 n);
3373 GNUNET_free(serv);
3374 continue;
3375 }
3376
3377 serv->address.af = res->ai_family;
3378 switch (res->ai_family)
3379 {
3380 case AF_INET:
3381 if (!ipv4_enabled)
3382 {
3383 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
3384 _("Service `%s' configured for IPv4, but IPv4 is disabled!\n"),
3385 n);
3386 freeaddrinfo(res);
3387 GNUNET_free(serv);
3388 continue;
3389 }
3390 serv->address.address.ipv4
3391 = ((struct sockaddr_in *)res->ai_addr)->sin_addr;
3392 break;
3393
3394 case AF_INET6:
3395 if (!ipv6_enabled)
3396 {
3397 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
3398 _("Service `%s' configured for IPv4, but IPv4 is disabled!\n"),
3399 n);
3400 freeaddrinfo(res);
3401 GNUNET_free(serv);
3402 continue;
3403 }
3404 serv->address.address.ipv6
3405 = ((struct sockaddr_in6 *)res->ai_addr)->sin6_addr;
3406 break;
3407
3408 default:
3409 freeaddrinfo(res);
3410 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
3411 _("No IP addresses found for hostname `%s' of service `%s'!\n"),
3412 hostname,
3413 n);
3414 GNUNET_free(serv);
3415 continue;
3416 }
3417 freeaddrinfo(res);
3418 }
3419 store_service(proto,
3420 n,
3421 local_port,
3422 serv);
3423 } 3504 }
3424 GNUNET_free(n); 3505 store_service (proto,
3506 n,
3507 local_port,
3508 serv);
3509 }
3510 GNUNET_free (n);
3425} 3511}
3426 3512
3427 3513
@@ -3432,36 +3518,36 @@ add_services(int proto,
3432 * @param section name of section in config 3518 * @param section name of section in config
3433 */ 3519 */
3434static void 3520static void
3435read_service_conf(void *cls, 3521read_service_conf (void *cls,
3436 const char *section) 3522 const char *section)
3437{ 3523{
3438 char *cpy; 3524 char *cpy;
3439 3525
3440 if ((strlen(section) < 8) || 3526 if ((strlen (section) < 8) ||
3441 (0 != strcmp(".gnunet.", section + (strlen(section) - 8)))) 3527 (0 != strcmp (".gnunet.", section + (strlen (section) - 8))))
3442 return; 3528 return;
3443 if (GNUNET_OK == 3529 if (GNUNET_OK ==
3444 GNUNET_CONFIGURATION_get_value_string(cfg, 3530 GNUNET_CONFIGURATION_get_value_string (cfg,
3445 section, 3531 section,
3446 "UDP_REDIRECTS", 3532 "UDP_REDIRECTS",
3447 &cpy)) 3533 &cpy))
3448 { 3534 {
3449 add_services(IPPROTO_UDP, 3535 add_services (IPPROTO_UDP,
3450 cpy, 3536 cpy,
3451 section); 3537 section);
3452 GNUNET_free(cpy); 3538 GNUNET_free (cpy);
3453 } 3539 }
3454 if (GNUNET_OK == 3540 if (GNUNET_OK ==
3455 GNUNET_CONFIGURATION_get_value_string(cfg, 3541 GNUNET_CONFIGURATION_get_value_string (cfg,
3456 section, 3542 section,
3457 "TCP_REDIRECTS", 3543 "TCP_REDIRECTS",
3458 &cpy)) 3544 &cpy))
3459 { 3545 {
3460 add_services(IPPROTO_TCP, 3546 add_services (IPPROTO_TCP,
3461 cpy, 3547 cpy,
3462 section); 3548 section);
3463 GNUNET_free(cpy); 3549 GNUNET_free (cpy);
3464 } 3550 }
3465} 3551}
3466 3552
3467 3553
@@ -3472,7 +3558,7 @@ read_service_conf(void *cls,
3472 * @param cls closure 3558 * @param cls closure
3473 */ 3559 */
3474static void 3560static void
3475do_dht_put(void *cls); 3561do_dht_put (void *cls);
3476 3562
3477 3563
3478/** 3564/**
@@ -3482,7 +3568,7 @@ do_dht_put(void *cls);
3482 * @param cls closure, NULL 3568 * @param cls closure, NULL
3483 */ 3569 */
3484static void 3570static void
3485dht_put_cont(void *cls) 3571dht_put_cont (void *cls)
3486{ 3572{
3487 dht_put = NULL; 3573 dht_put = NULL;
3488} 3574}
@@ -3495,37 +3581,37 @@ dht_put_cont(void *cls)
3495 * @param cls closure 3581 * @param cls closure
3496 */ 3582 */
3497static void 3583static void
3498do_dht_put(void *cls) 3584do_dht_put (void *cls)
3499{ 3585{
3500 struct GNUNET_TIME_Absolute expiration; 3586 struct GNUNET_TIME_Absolute expiration;
3501 3587
3502 dht_task = GNUNET_SCHEDULER_add_delayed(DHT_PUT_FREQUENCY, 3588 dht_task = GNUNET_SCHEDULER_add_delayed (DHT_PUT_FREQUENCY,
3503 &do_dht_put, 3589 &do_dht_put,
3504 NULL); 3590 NULL);
3505 expiration = GNUNET_TIME_absolute_ntoh(dns_advertisement.expiration_time); 3591 expiration = GNUNET_TIME_absolute_ntoh (dns_advertisement.expiration_time);
3506 if (GNUNET_TIME_absolute_get_remaining(expiration).rel_value_us < 3592 if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us <
3507 GNUNET_TIME_UNIT_HOURS.rel_value_us) 3593 GNUNET_TIME_UNIT_HOURS.rel_value_us)
3508 { 3594 {
3509 /* refresh advertisement */ 3595 /* refresh advertisement */
3510 expiration = GNUNET_TIME_relative_to_absolute(DNS_ADVERTISEMENT_TIMEOUT); 3596 expiration = GNUNET_TIME_relative_to_absolute (DNS_ADVERTISEMENT_TIMEOUT);
3511 dns_advertisement.expiration_time = GNUNET_TIME_absolute_hton(expiration); 3597 dns_advertisement.expiration_time = GNUNET_TIME_absolute_hton (expiration);
3512 GNUNET_assert(GNUNET_OK == 3598 GNUNET_assert (GNUNET_OK ==
3513 GNUNET_CRYPTO_eddsa_sign(peer_key, 3599 GNUNET_CRYPTO_eddsa_sign (peer_key,
3514 &dns_advertisement.purpose, 3600 &dns_advertisement.purpose,
3515 &dns_advertisement.signature)); 3601 &dns_advertisement.signature));
3516 } 3602 }
3517 if (NULL != dht_put) 3603 if (NULL != dht_put)
3518 GNUNET_DHT_put_cancel(dht_put); 3604 GNUNET_DHT_put_cancel (dht_put);
3519 dht_put = GNUNET_DHT_put(dht, 3605 dht_put = GNUNET_DHT_put (dht,
3520 &dht_put_key, 3606 &dht_put_key,
3521 1 /* replication */, 3607 1 /* replication */,
3522 GNUNET_DHT_RO_NONE, 3608 GNUNET_DHT_RO_NONE,
3523 GNUNET_BLOCK_TYPE_DNS, 3609 GNUNET_BLOCK_TYPE_DNS,
3524 sizeof(struct GNUNET_DNS_Advertisement), 3610 sizeof(struct GNUNET_DNS_Advertisement),
3525 &dns_advertisement, 3611 &dns_advertisement,
3526 expiration, 3612 expiration,
3527 &dht_put_cont, 3613 &dht_put_cont,
3528 NULL); 3614 NULL);
3529} 3615}
3530 3616
3531 3617
@@ -3534,48 +3620,52 @@ do_dht_put(void *cls)
3534 * are supported by the OS) according to our configuration. 3620 * are supported by the OS) according to our configuration.
3535 */ 3621 */
3536static void 3622static void
3537parse_ip_options() 3623parse_ip_options ()
3538{ 3624{
3539 ipv4_exit = GNUNET_CONFIGURATION_get_value_yesno(cfg, 3625 ipv4_exit = GNUNET_CONFIGURATION_get_value_yesno (cfg,
3540 "exit", 3626 "exit",
3541 "EXIT_IPV4"); 3627 "EXIT_IPV4");
3542 ipv6_exit = GNUNET_CONFIGURATION_get_value_yesno(cfg, 3628 ipv6_exit = GNUNET_CONFIGURATION_get_value_yesno (cfg,
3543 "exit", 3629 "exit",
3544 "EXIT_IPV6"); 3630 "EXIT_IPV6");
3545 ipv4_enabled = GNUNET_CONFIGURATION_get_value_yesno(cfg, 3631 ipv4_enabled = GNUNET_CONFIGURATION_get_value_yesno (cfg,
3546 "exit", 3632 "exit",
3547 "ENABLE_IPV4"); 3633 "ENABLE_IPV4");
3548 ipv6_enabled = GNUNET_CONFIGURATION_get_value_yesno(cfg, 3634 ipv6_enabled = GNUNET_CONFIGURATION_get_value_yesno (cfg,
3549 "exit", 3635 "exit",
3550 "ENABLE_IPV6"); 3636 "ENABLE_IPV6");
3551 if ((ipv4_exit || ipv4_enabled) && 3637 if ((ipv4_exit || ipv4_enabled) &&
3552 GNUNET_OK != GNUNET_NETWORK_test_pf(PF_INET)) 3638 (GNUNET_OK != GNUNET_NETWORK_test_pf (PF_INET)) )
3553 { 3639 {
3554 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 3640 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3555 _("This system does not support IPv4, will disable IPv4 functions despite them being enabled in the configuration\n")); 3641 _ (
3556 ipv4_exit = GNUNET_NO; 3642 "This system does not support IPv4, will disable IPv4 functions despite them being enabled in the configuration\n"));
3557 ipv4_enabled = GNUNET_NO; 3643 ipv4_exit = GNUNET_NO;
3558 } 3644 ipv4_enabled = GNUNET_NO;
3645 }
3559 if ((ipv6_exit || ipv6_enabled) && 3646 if ((ipv6_exit || ipv6_enabled) &&
3560 GNUNET_OK != GNUNET_NETWORK_test_pf(PF_INET6)) 3647 (GNUNET_OK != GNUNET_NETWORK_test_pf (PF_INET6)) )
3561 { 3648 {
3562 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 3649 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3563 _("This system does not support IPv6, will disable IPv6 functions despite them being enabled in the configuration\n")); 3650 _ (
3564 ipv6_exit = GNUNET_NO; 3651 "This system does not support IPv6, will disable IPv6 functions despite them being enabled in the configuration\n"));
3565 ipv6_enabled = GNUNET_NO; 3652 ipv6_exit = GNUNET_NO;
3566 } 3653 ipv6_enabled = GNUNET_NO;
3567 if (ipv4_exit && (!ipv4_enabled)) 3654 }
3568 { 3655 if (ipv4_exit && (! ipv4_enabled))
3569 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 3656 {
3570 _("Cannot enable IPv4 exit but disable IPv4 on TUN interface, will use ENABLE_IPv4=YES\n")); 3657 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3571 ipv4_enabled = GNUNET_YES; 3658 _ (
3572 } 3659 "Cannot enable IPv4 exit but disable IPv4 on TUN interface, will use ENABLE_IPv4=YES\n"));
3573 if (ipv6_exit && (!ipv6_enabled)) 3660 ipv4_enabled = GNUNET_YES;
3574 { 3661 }
3575 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 3662 if (ipv6_exit && (! ipv6_enabled))
3576 _("Cannot enable IPv6 exit but disable IPv6 on TUN interface, will use ENABLE_IPv6=YES\n")); 3663 {
3577 ipv6_enabled = GNUNET_YES; 3664 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3578 } 3665 _ (
3666 "Cannot enable IPv6 exit but disable IPv6 on TUN interface, will use ENABLE_IPv6=YES\n"));
3667 ipv6_enabled = GNUNET_YES;
3668 }
3579} 3669}
3580 3670
3581 3671
@@ -3584,71 +3674,74 @@ parse_ip_options()
3584 * advertise the DNS exit (if applicable). 3674 * advertise the DNS exit (if applicable).
3585 */ 3675 */
3586static void 3676static void
3587advertise_dns_exit() 3677advertise_dns_exit ()
3588{ 3678{
3589 struct GNUNET_MQ_MessageHandler handlers[] = { 3679 struct GNUNET_MQ_MessageHandler handlers[] = {
3590 GNUNET_MQ_hd_var_size(dns_request, 3680 GNUNET_MQ_hd_var_size (dns_request,
3591 GNUNET_MESSAGE_TYPE_VPN_DNS_TO_INTERNET, 3681 GNUNET_MESSAGE_TYPE_VPN_DNS_TO_INTERNET,
3592 struct DnsResponseMessage, 3682 struct DnsResponseMessage,
3593 NULL), 3683 NULL),
3594 GNUNET_MQ_handler_end() 3684 GNUNET_MQ_handler_end ()
3595 }; 3685 };
3596 char *dns_exit; 3686 char *dns_exit;
3597 struct GNUNET_HashCode port; 3687 struct GNUNET_HashCode port;
3598 3688
3599 if (GNUNET_YES != 3689 if (GNUNET_YES !=
3600 GNUNET_CONFIGURATION_get_value_yesno(cfg, 3690 GNUNET_CONFIGURATION_get_value_yesno (cfg,
3601 "exit", 3691 "exit",
3602 "EXIT_DNS")) 3692 "EXIT_DNS"))
3603 return; 3693 return;
3604 GNUNET_assert(NULL != (dnsstub = GNUNET_DNSSTUB_start(128))); 3694 GNUNET_assert (NULL != (dnsstub = GNUNET_DNSSTUB_start (128)));
3605 dns_exit = NULL; 3695 dns_exit = NULL;
3606 /* TODO: support using multiple DNS resolvers */ 3696 /* TODO: support using multiple DNS resolvers */
3607 if ((GNUNET_OK != 3697 if ((GNUNET_OK !=
3608 GNUNET_CONFIGURATION_get_value_string(cfg, 3698 GNUNET_CONFIGURATION_get_value_string (cfg,
3609 "exit", 3699 "exit",
3610 "DNS_RESOLVER", 3700 "DNS_RESOLVER",
3611 &dns_exit)) || 3701 &dns_exit)) ||
3612 (GNUNET_OK != 3702 (GNUNET_OK !=
3613 GNUNET_DNSSTUB_add_dns_ip(dnsstub, 3703 GNUNET_DNSSTUB_add_dns_ip (dnsstub,
3614 dns_exit))) 3704 dns_exit)))
3615 { 3705 {
3616 GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR, 3706 GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
3617 "dns", 3707 "dns",
3618 "DNS_RESOLVER", 3708 "DNS_RESOLVER",
3619 _("need a valid IPv4 or IPv6 address\n")); 3709 _ ("need a valid IPv4 or IPv6 address\n"));
3620 GNUNET_free_non_null(dns_exit); 3710 GNUNET_free_non_null (dns_exit);
3621 return; 3711 return;
3622 } 3712 }
3623 /* open port */ 3713 /* open port */
3624 GNUNET_CRYPTO_hash(GNUNET_APPLICATION_PORT_INTERNET_RESOLVER, 3714 GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_INTERNET_RESOLVER,
3625 strlen(GNUNET_APPLICATION_PORT_INTERNET_RESOLVER), 3715 strlen (GNUNET_APPLICATION_PORT_INTERNET_RESOLVER),
3626 &port); 3716 &port);
3627 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 3717 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3628 "Opening CADET port %s for DNS exit service\n", 3718 "Opening CADET port %s for DNS exit service\n",
3629 GNUNET_h2s(&port)); 3719 GNUNET_h2s (&port));
3630 dns_port = GNUNET_CADET_open_port(cadet_handle, 3720 dns_port = GNUNET_CADET_open_port (cadet_handle,
3631 &port, 3721 &port,
3632 &new_channel, 3722 &new_channel,
3633 NULL, 3723 NULL,
3634 NULL, 3724 NULL,
3635 &clean_channel, 3725 &clean_channel,
3636 handlers); 3726 handlers);
3637 /* advertise exit */ 3727 /* advertise exit */
3638 dht = GNUNET_DHT_connect(cfg, 3728 dht = GNUNET_DHT_connect (cfg,
3639 1); 3729 1);
3640 peer_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg); 3730 peer_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
3641 GNUNET_CRYPTO_eddsa_key_get_public(peer_key, 3731 GNUNET_CRYPTO_eddsa_key_get_public (peer_key,
3642 &dns_advertisement.peer.public_key); 3732 &dns_advertisement.peer.public_key);
3643 dns_advertisement.purpose.size = htonl(sizeof(struct GNUNET_DNS_Advertisement) - 3733 dns_advertisement.purpose.size = htonl (sizeof(struct
3644 sizeof(struct GNUNET_CRYPTO_EddsaSignature)); 3734 GNUNET_DNS_Advertisement)
3645 dns_advertisement.purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_DNS_RECORD); 3735 - sizeof(struct
3646 GNUNET_CRYPTO_hash("dns", 3736 GNUNET_CRYPTO_EddsaSignature));
3647 strlen("dns"), 3737 dns_advertisement.purpose.purpose = htonl (
3648 &dht_put_key); 3738 GNUNET_SIGNATURE_PURPOSE_DNS_RECORD);
3649 dht_task = GNUNET_SCHEDULER_add_now(&do_dht_put, 3739 GNUNET_CRYPTO_hash ("dns",
3650 NULL); 3740 strlen ("dns"),
3651 GNUNET_free(dns_exit); 3741 &dht_put_key);
3742 dht_task = GNUNET_SCHEDULER_add_now (&do_dht_put,
3743 NULL);
3744 GNUNET_free (dns_exit);
3652} 3745}
3653 3746
3654 3747
@@ -3658,7 +3751,7 @@ advertise_dns_exit()
3658 * @return #GNUNET_OK on success, #GNUNET_SYSERR if we should shutdown 3751 * @return #GNUNET_OK on success, #GNUNET_SYSERR if we should shutdown
3659 */ 3752 */
3660static int 3753static int
3661setup_exit_helper_args() 3754setup_exit_helper_args ()
3662{ 3755{
3663 char *exit_ifname; 3756 char *exit_ifname;
3664 char *tun_ifname; 3757 char *tun_ifname;
@@ -3667,133 +3760,133 @@ setup_exit_helper_args()
3667 char *ipv4addr; 3760 char *ipv4addr;
3668 char *ipv4mask; 3761 char *ipv4mask;
3669 3762
3670 exit_argv[0] = GNUNET_strdup("exit-gnunet"); 3763 exit_argv[0] = GNUNET_strdup ("exit-gnunet");
3671 if (GNUNET_SYSERR == 3764 if (GNUNET_SYSERR ==
3672 GNUNET_CONFIGURATION_get_value_string(cfg, 3765 GNUNET_CONFIGURATION_get_value_string (cfg,
3673 "exit", 3766 "exit",
3674 "TUN_IFNAME", 3767 "TUN_IFNAME",
3675 &tun_ifname)) 3768 &tun_ifname))
3676 { 3769 {
3677 GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, 3770 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
3678 "EXIT", 3771 "EXIT",
3679 "TUN_IFNAME"); 3772 "TUN_IFNAME");
3680 return GNUNET_SYSERR; 3773 return GNUNET_SYSERR;
3681 } 3774 }
3682 exit_argv[1] = tun_ifname; 3775 exit_argv[1] = tun_ifname;
3683 if (ipv4_enabled) 3776 if (ipv4_enabled)
3777 {
3778 if (GNUNET_SYSERR ==
3779 GNUNET_CONFIGURATION_get_value_string (cfg,
3780 "exit",
3781 "EXIT_IFNAME",
3782 &exit_ifname))
3684 { 3783 {
3685 if (GNUNET_SYSERR == 3784 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
3686 GNUNET_CONFIGURATION_get_value_string(cfg, 3785 "EXIT",
3687 "exit", 3786 "EXIT_IFNAME");
3688 "EXIT_IFNAME", 3787 return GNUNET_SYSERR;
3689 &exit_ifname))
3690 {
3691 GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
3692 "EXIT",
3693 "EXIT_IFNAME");
3694 return GNUNET_SYSERR;
3695 }
3696 exit_argv[2] = exit_ifname;
3697 } 3788 }
3789 exit_argv[2] = exit_ifname;
3790 }
3698 else 3791 else
3699 { 3792 {
3700 exit_argv[2] = GNUNET_strdup("-"); 3793 exit_argv[2] = GNUNET_strdup ("-");
3701 } 3794 }
3702 3795
3703 if (GNUNET_YES == ipv6_enabled) 3796 if (GNUNET_YES == ipv6_enabled)
3704 { 3797 {
3705 ipv6addr = NULL; 3798 ipv6addr = NULL;
3706 if ((GNUNET_SYSERR == 3799 if (((GNUNET_SYSERR ==
3707 GNUNET_CONFIGURATION_get_value_string(cfg, 3800 GNUNET_CONFIGURATION_get_value_string (cfg,
3708 "exit", 3801 "exit",
3709 "IPV6ADDR", 3802 "IPV6ADDR",
3710 &ipv6addr) || 3803 &ipv6addr))||
3711 (1 != inet_pton(AF_INET6, 3804 (1 != inet_pton (AF_INET6,
3712 ipv6addr, 3805 ipv6addr,
3713 &exit_ipv6addr)))) 3806 &exit_ipv6addr))))
3714 { 3807 {
3715 GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, 3808 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
3716 "EXIT", 3809 "EXIT",
3717 "IPV6ADDR"); 3810 "IPV6ADDR");
3718 GNUNET_free_non_null(ipv6addr); 3811 GNUNET_free_non_null (ipv6addr);
3719 return GNUNET_SYSERR; 3812 return GNUNET_SYSERR;
3720 } 3813 }
3721 exit_argv[3] = ipv6addr; 3814 exit_argv[3] = ipv6addr;
3722 if (GNUNET_SYSERR == 3815 if (GNUNET_SYSERR ==
3723 GNUNET_CONFIGURATION_get_value_string(cfg, 3816 GNUNET_CONFIGURATION_get_value_string (cfg,
3817 "exit",
3818 "IPV6PREFIX",
3819 &ipv6prefix_s))
3820 {
3821 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
3822 "EXIT",
3823 "IPV6PREFIX");
3824 return GNUNET_SYSERR;
3825 }
3826 exit_argv[4] = ipv6prefix_s;
3827 if ((GNUNET_OK !=
3828 GNUNET_CONFIGURATION_get_value_number (cfg,
3724 "exit", 3829 "exit",
3725 "IPV6PREFIX", 3830 "IPV6PREFIX",
3726 &ipv6prefix_s)) 3831 &ipv6prefix)) ||
3727 { 3832 (ipv6prefix >= 127))
3728 GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
3729 "EXIT",
3730 "IPV6PREFIX");
3731 return GNUNET_SYSERR;
3732 }
3733 exit_argv[4] = ipv6prefix_s;
3734 if ((GNUNET_OK !=
3735 GNUNET_CONFIGURATION_get_value_number(cfg,
3736 "exit",
3737 "IPV6PREFIX",
3738 &ipv6prefix)) ||
3739 (ipv6prefix >= 127))
3740 {
3741 GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR,
3742 "EXIT",
3743 "IPV6PREFIX",
3744 _("Must be a number"));
3745 return GNUNET_SYSERR;
3746 }
3747 }
3748 else
3749 { 3833 {
3750 /* IPv6 explicitly disabled */ 3834 GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
3751 exit_argv[3] = GNUNET_strdup("-"); 3835 "EXIT",
3752 exit_argv[4] = GNUNET_strdup("-"); 3836 "IPV6PREFIX",
3837 _ ("Must be a number"));
3838 return GNUNET_SYSERR;
3753 } 3839 }
3840 }
3841 else
3842 {
3843 /* IPv6 explicitly disabled */
3844 exit_argv[3] = GNUNET_strdup ("-");
3845 exit_argv[4] = GNUNET_strdup ("-");
3846 }
3754 if (GNUNET_YES == ipv4_enabled) 3847 if (GNUNET_YES == ipv4_enabled)
3755 { 3848 {
3756 ipv4addr = NULL; 3849 ipv4addr = NULL;
3757 if ((GNUNET_SYSERR == 3850 if (((GNUNET_SYSERR ==
3758 GNUNET_CONFIGURATION_get_value_string(cfg, 3851 GNUNET_CONFIGURATION_get_value_string (cfg,
3759 "exit", 3852 "exit",
3760 "IPV4ADDR", 3853 "IPV4ADDR",
3761 &ipv4addr) || 3854 &ipv4addr))||
3762 (1 != inet_pton(AF_INET, 3855 (1 != inet_pton (AF_INET,
3763 ipv4addr, 3856 ipv4addr,
3764 &exit_ipv4addr)))) 3857 &exit_ipv4addr))))
3765 { 3858 {
3766 GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, 3859 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
3767 "EXIT", 3860 "EXIT",
3768 "IPV4ADDR"); 3861 "IPV4ADDR");
3769 GNUNET_free_non_null(ipv4addr); 3862 GNUNET_free_non_null (ipv4addr);
3770 return GNUNET_SYSERR; 3863 return GNUNET_SYSERR;
3771 } 3864 }
3772 exit_argv[5] = ipv4addr; 3865 exit_argv[5] = ipv4addr;
3773 ipv4mask = NULL; 3866 ipv4mask = NULL;
3774 if ((GNUNET_SYSERR == 3867 if (((GNUNET_SYSERR ==
3775 GNUNET_CONFIGURATION_get_value_string(cfg, 3868 GNUNET_CONFIGURATION_get_value_string (cfg,
3776 "exit", 3869 "exit",
3777 "IPV4MASK", 3870 "IPV4MASK",
3778 &ipv4mask) || 3871 &ipv4mask))||
3779 (1 != inet_pton(AF_INET, 3872 (1 != inet_pton (AF_INET,
3780 ipv4mask, 3873 ipv4mask,
3781 &exit_ipv4mask)))) 3874 &exit_ipv4mask))))
3782 {
3783 GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
3784 "EXIT",
3785 "IPV4MASK");
3786 GNUNET_free_non_null(ipv4mask);
3787 return GNUNET_SYSERR;
3788 }
3789 exit_argv[6] = ipv4mask;
3790 }
3791 else
3792 { 3875 {
3793 /* IPv4 explicitly disabled */ 3876 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
3794 exit_argv[5] = GNUNET_strdup("-"); 3877 "EXIT",
3795 exit_argv[6] = GNUNET_strdup("-"); 3878 "IPV4MASK");
3879 GNUNET_free_non_null (ipv4mask);
3880 return GNUNET_SYSERR;
3796 } 3881 }
3882 exit_argv[6] = ipv4mask;
3883 }
3884 else
3885 {
3886 /* IPv4 explicitly disabled */
3887 exit_argv[5] = GNUNET_strdup ("-");
3888 exit_argv[6] = GNUNET_strdup ("-");
3889 }
3797 exit_argv[7] = NULL; 3890 exit_argv[7] = NULL;
3798 return GNUNET_OK; 3891 return GNUNET_OK;
3799} 3892}
@@ -3808,29 +3901,29 @@ setup_exit_helper_args()
3808 * @param cfg_ configuration 3901 * @param cfg_ configuration
3809 */ 3902 */
3810static void 3903static void
3811run(void *cls, 3904run (void *cls,
3812 char *const *args, 3905 char *const *args,
3813 const char *cfgfile, 3906 const char *cfgfile,
3814 const struct GNUNET_CONFIGURATION_Handle *cfg_) 3907 const struct GNUNET_CONFIGURATION_Handle *cfg_)
3815{ 3908{
3816 struct GNUNET_MQ_MessageHandler handlers[] = { 3909 struct GNUNET_MQ_MessageHandler handlers[] = {
3817 GNUNET_MQ_hd_var_size(icmp_remote, 3910 GNUNET_MQ_hd_var_size (icmp_remote,
3818 GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_INTERNET, 3911 GNUNET_MESSAGE_TYPE_VPN_ICMP_TO_INTERNET,
3819 struct GNUNET_EXIT_IcmpInternetMessage, 3912 struct GNUNET_EXIT_IcmpInternetMessage,
3820 NULL), 3913 NULL),
3821 GNUNET_MQ_hd_var_size(udp_remote, 3914 GNUNET_MQ_hd_var_size (udp_remote,
3822 GNUNET_MESSAGE_TYPE_VPN_UDP_TO_INTERNET, 3915 GNUNET_MESSAGE_TYPE_VPN_UDP_TO_INTERNET,
3823 struct GNUNET_EXIT_UdpInternetMessage, 3916 struct GNUNET_EXIT_UdpInternetMessage,
3824 NULL), 3917 NULL),
3825 GNUNET_MQ_hd_var_size(tcp_remote, 3918 GNUNET_MQ_hd_var_size (tcp_remote,
3826 GNUNET_MESSAGE_TYPE_VPN_TCP_TO_INTERNET_START, 3919 GNUNET_MESSAGE_TYPE_VPN_TCP_TO_INTERNET_START,
3827 struct GNUNET_EXIT_TcpInternetStartMessage, 3920 struct GNUNET_EXIT_TcpInternetStartMessage,
3828 NULL), 3921 NULL),
3829 GNUNET_MQ_hd_var_size(tcp_data, 3922 GNUNET_MQ_hd_var_size (tcp_data,
3830 GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_EXIT, 3923 GNUNET_MESSAGE_TYPE_VPN_TCP_DATA_TO_EXIT,
3831 struct GNUNET_EXIT_TcpDataMessage, 3924 struct GNUNET_EXIT_TcpDataMessage,
3832 NULL), 3925 NULL),
3833 GNUNET_MQ_handler_end() 3926 GNUNET_MQ_handler_end ()
3834 }; 3927 };
3835 struct GNUNET_HashCode port; 3928 struct GNUNET_HashCode port;
3836 char *policy; 3929 char *policy;
@@ -3840,157 +3933,159 @@ run(void *cls,
3840 3933
3841 cfg = cfg_; 3934 cfg = cfg_;
3842 if (GNUNET_OK != 3935 if (GNUNET_OK !=
3843 GNUNET_CONFIGURATION_get_value_number(cfg, 3936 GNUNET_CONFIGURATION_get_value_number (cfg,
3844 "exit", 3937 "exit",
3845 "MAX_CONNECTIONS", 3938 "MAX_CONNECTIONS",
3846 &max_connections)) 3939 &max_connections))
3847 max_connections = 1024; 3940 max_connections = 1024;
3848 parse_ip_options(); 3941 parse_ip_options ();
3849 binary = GNUNET_OS_get_suid_binary_path(cfg, "gnunet-helper-exit"); 3942 binary = GNUNET_OS_get_suid_binary_path (cfg, "gnunet-helper-exit");
3850 if ((ipv4_exit) || (ipv6_exit)) 3943 if ((ipv4_exit) || (ipv6_exit))
3944 {
3945 if (GNUNET_YES !=
3946 GNUNET_OS_check_helper_binary (binary,
3947 GNUNET_YES,
3948 "gnunet-vpn - - - 169.1.3.7 255.255.255.0")) // no nat, ipv4 only
3851 { 3949 {
3852 if (GNUNET_YES != 3950 GNUNET_free (binary);
3853 GNUNET_OS_check_helper_binary(binary, 3951 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3854 GNUNET_YES, 3952 _ (
3855 "gnunet-vpn - - - 169.1.3.7 255.255.255.0")) //no nat, ipv4 only 3953 "`%s' is not SUID or the path is invalid, EXIT will not work\n"),
3856 { 3954 "gnunet-helper-exit");
3857 GNUNET_free(binary); 3955 GNUNET_SCHEDULER_add_shutdown (&dummy_task,
3858 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 3956 NULL);
3859 _("`%s' is not SUID or the path is invalid, EXIT will not work\n"), 3957 global_ret = 1;
3860 "gnunet-helper-exit");
3861 GNUNET_SCHEDULER_add_shutdown(&dummy_task,
3862 NULL);
3863 global_ret = 1;
3864 return;
3865 }
3866 }
3867 if (!(ipv4_enabled || ipv6_enabled))
3868 {
3869 GNUNET_free(binary);
3870 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
3871 _("No useful service enabled. Exiting.\n"));
3872 GNUNET_SCHEDULER_shutdown();
3873 return; 3958 return;
3874 } 3959 }
3960 }
3961 if (! (ipv4_enabled || ipv6_enabled))
3962 {
3963 GNUNET_free (binary);
3964 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3965 _ ("No useful service enabled. Exiting.\n"));
3966 GNUNET_SCHEDULER_shutdown ();
3967 return;
3968 }
3875 3969
3876 GNUNET_SCHEDULER_add_shutdown(&cleanup, 3970 GNUNET_SCHEDULER_add_shutdown (&cleanup,
3877 NULL); 3971 NULL);
3878 stats = GNUNET_STATISTICS_create("exit", 3972 stats = GNUNET_STATISTICS_create ("exit",
3879 cfg); 3973 cfg);
3880 cadet_handle = GNUNET_CADET_connect(cfg); 3974 cadet_handle = GNUNET_CADET_connect (cfg);
3881 if (NULL == cadet_handle) 3975 if (NULL == cadet_handle)
3882 { 3976 {
3883 GNUNET_free(binary); 3977 GNUNET_free (binary);
3884 GNUNET_SCHEDULER_shutdown(); 3978 GNUNET_SCHEDULER_shutdown ();
3885 return; 3979 return;
3886 } 3980 }
3887 advertise_dns_exit(); 3981 advertise_dns_exit ();
3888 if (GNUNET_OK != 3982 if (GNUNET_OK !=
3889 setup_exit_helper_args()) 3983 setup_exit_helper_args ())
3890 { 3984 {
3891 GNUNET_free(binary); 3985 GNUNET_free (binary);
3892 GNUNET_SCHEDULER_shutdown(); 3986 GNUNET_SCHEDULER_shutdown ();
3893 return; 3987 return;
3894 } 3988 }
3895 3989
3896 services = GNUNET_CONTAINER_multihashmap_create(65536, 3990 services = GNUNET_CONTAINER_multihashmap_create (65536,
3897 GNUNET_NO); 3991 GNUNET_NO);
3898 connections_map = GNUNET_CONTAINER_multihashmap_create(65536, 3992 connections_map = GNUNET_CONTAINER_multihashmap_create (65536,
3899 GNUNET_NO); 3993 GNUNET_NO);
3900 connections_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); 3994 connections_heap = GNUNET_CONTAINER_heap_create (
3901 GNUNET_CONFIGURATION_iterate_sections(cfg, 3995 GNUNET_CONTAINER_HEAP_ORDER_MIN);
3902 &read_service_conf, 3996 GNUNET_CONFIGURATION_iterate_sections (cfg,
3903 NULL); 3997 &read_service_conf,
3998 NULL);
3904 3999
3905 /* Cadet handle acquired, now open ports and announce regular 4000 /* Cadet handle acquired, now open ports and announce regular
3906 expressions matching our exit */ 4001 expressions matching our exit */
3907 if ((GNUNET_YES == ipv4_enabled) && 4002 if ((GNUNET_YES == ipv4_enabled) &&
3908 (GNUNET_YES == ipv4_exit)) 4003 (GNUNET_YES == ipv4_exit))
4004 {
4005 GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_IPV4_GATEWAY,
4006 strlen (GNUNET_APPLICATION_PORT_IPV4_GATEWAY),
4007 &port);
4008 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4009 "Opening CADET port %s for IPv4 gateway service\n",
4010 GNUNET_h2s (&port));
4011 cadet_port4 = GNUNET_CADET_open_port (cadet_handle,
4012 &port,
4013 &new_channel,
4014 NULL,
4015 NULL,
4016 &clean_channel,
4017 handlers);
4018 policy = NULL;
4019 if (GNUNET_OK !=
4020 GNUNET_CONFIGURATION_get_value_string (cfg,
4021 "exit",
4022 "EXIT_RANGE_IPV4_POLICY",
4023 &policy))
4024 regex = NULL;
4025 else
4026 regex = GNUNET_TUN_ipv4policy2regex (policy);
4027 GNUNET_free_non_null (policy);
4028 if (NULL != regex)
3909 { 4029 {
3910 GNUNET_CRYPTO_hash(GNUNET_APPLICATION_PORT_IPV4_GATEWAY, 4030 (void) GNUNET_asprintf (&prefixed_regex,
3911 strlen(GNUNET_APPLICATION_PORT_IPV4_GATEWAY), 4031 "%s%s",
3912 &port); 4032 GNUNET_APPLICATION_TYPE_EXIT_REGEX_PREFIX,
3913 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 4033 regex);
3914 "Opening CADET port %s for IPv4 gateway service\n", 4034 regex4 = GNUNET_REGEX_announce (cfg,
3915 GNUNET_h2s(&port)); 4035 prefixed_regex,
3916 cadet_port4 = GNUNET_CADET_open_port(cadet_handle, 4036 REGEX_REFRESH_FREQUENCY,
3917 &port, 4037 REGEX_MAX_PATH_LEN_IPV4);
3918 &new_channel, 4038 GNUNET_free (regex);
3919 NULL, 4039 GNUNET_free (prefixed_regex);
3920 NULL,
3921 &clean_channel,
3922 handlers);
3923 policy = NULL;
3924 if (GNUNET_OK !=
3925 GNUNET_CONFIGURATION_get_value_string(cfg,
3926 "exit",
3927 "EXIT_RANGE_IPV4_POLICY",
3928 &policy))
3929 regex = NULL;
3930 else
3931 regex = GNUNET_TUN_ipv4policy2regex(policy);
3932 GNUNET_free_non_null(policy);
3933 if (NULL != regex)
3934 {
3935 (void)GNUNET_asprintf(&prefixed_regex,
3936 "%s%s",
3937 GNUNET_APPLICATION_TYPE_EXIT_REGEX_PREFIX,
3938 regex);
3939 regex4 = GNUNET_REGEX_announce(cfg,
3940 prefixed_regex,
3941 REGEX_REFRESH_FREQUENCY,
3942 REGEX_MAX_PATH_LEN_IPV4);
3943 GNUNET_free(regex);
3944 GNUNET_free(prefixed_regex);
3945 }
3946 } 4040 }
4041 }
3947 4042
3948 if ((GNUNET_YES == ipv6_enabled) && (GNUNET_YES == ipv6_exit)) 4043 if ((GNUNET_YES == ipv6_enabled) && (GNUNET_YES == ipv6_exit))
4044 {
4045 GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_IPV6_GATEWAY,
4046 strlen (GNUNET_APPLICATION_PORT_IPV6_GATEWAY),
4047 &port);
4048 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
4049 "Opening CADET port %s for IPv6 gateway service\n",
4050 GNUNET_h2s (&port));
4051 cadet_port6 = GNUNET_CADET_open_port (cadet_handle,
4052 &port,
4053 &new_channel,
4054 NULL,
4055 NULL,
4056 &clean_channel,
4057 handlers);
4058 policy = NULL;
4059 if (GNUNET_OK !=
4060 GNUNET_CONFIGURATION_get_value_string (cfg,
4061 "exit",
4062 "EXIT_RANGE_IPV6_POLICY",
4063 &policy))
4064 regex = NULL;
4065 else
4066 regex = GNUNET_TUN_ipv6policy2regex (policy);
4067 GNUNET_free_non_null (policy);
4068 if (NULL != regex)
3949 { 4069 {
3950 GNUNET_CRYPTO_hash(GNUNET_APPLICATION_PORT_IPV6_GATEWAY, 4070 (void) GNUNET_asprintf (&prefixed_regex,
3951 strlen(GNUNET_APPLICATION_PORT_IPV6_GATEWAY), 4071 "%s%s",
3952 &port); 4072 GNUNET_APPLICATION_TYPE_EXIT_REGEX_PREFIX,
3953 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 4073 regex);
3954 "Opening CADET port %s for IPv6 gateway service\n", 4074 regex6 = GNUNET_REGEX_announce (cfg,
3955 GNUNET_h2s(&port)); 4075 prefixed_regex,
3956 cadet_port6 = GNUNET_CADET_open_port(cadet_handle, 4076 REGEX_REFRESH_FREQUENCY,
3957 &port, 4077 REGEX_MAX_PATH_LEN_IPV6);
3958 &new_channel, 4078 GNUNET_free (regex);
3959 NULL, 4079 GNUNET_free (prefixed_regex);
3960 NULL,
3961 &clean_channel,
3962 handlers);
3963 policy = NULL;
3964 if (GNUNET_OK !=
3965 GNUNET_CONFIGURATION_get_value_string(cfg,
3966 "exit",
3967 "EXIT_RANGE_IPV6_POLICY",
3968 &policy))
3969 regex = NULL;
3970 else
3971 regex = GNUNET_TUN_ipv6policy2regex(policy);
3972 GNUNET_free_non_null(policy);
3973 if (NULL != regex)
3974 {
3975 (void)GNUNET_asprintf(&prefixed_regex,
3976 "%s%s",
3977 GNUNET_APPLICATION_TYPE_EXIT_REGEX_PREFIX,
3978 regex);
3979 regex6 = GNUNET_REGEX_announce(cfg,
3980 prefixed_regex,
3981 REGEX_REFRESH_FREQUENCY,
3982 REGEX_MAX_PATH_LEN_IPV6);
3983 GNUNET_free(regex);
3984 GNUNET_free(prefixed_regex);
3985 }
3986 } 4080 }
3987 helper_handle = GNUNET_HELPER_start(GNUNET_NO, 4081 }
3988 binary, 4082 helper_handle = GNUNET_HELPER_start (GNUNET_NO,
3989 exit_argv, 4083 binary,
3990 &message_token, 4084 exit_argv,
3991 NULL, 4085 &message_token,
3992 NULL); 4086 NULL,
3993 GNUNET_free(binary); 4087 NULL);
4088 GNUNET_free (binary);
3994} 4089}
3995 4090
3996 4091
@@ -4002,28 +4097,29 @@ run(void *cls,
4002 * @return 0 ok, 1 on error 4097 * @return 0 ok, 1 on error
4003 */ 4098 */
4004int 4099int
4005main(int argc, 4100main (int argc,
4006 char *const *argv) 4101 char *const *argv)
4007{ 4102{
4008 static const struct GNUNET_GETOPT_CommandLineOption options[] = { 4103 static const struct GNUNET_GETOPT_CommandLineOption options[] = {
4009 GNUNET_GETOPT_OPTION_END 4104 GNUNET_GETOPT_OPTION_END
4010 }; 4105 };
4011 4106
4012 if (GNUNET_OK != 4107 if (GNUNET_OK !=
4013 GNUNET_STRINGS_get_utf8_args(argc, 4108 GNUNET_STRINGS_get_utf8_args (argc,
4014 argv, 4109 argv,
4015 &argc, 4110 &argc,
4016 &argv)) 4111 &argv))
4017 return 2; 4112 return 2;
4018 4113
4019 return (GNUNET_OK == 4114 return (GNUNET_OK ==
4020 GNUNET_PROGRAM_run(argc, 4115 GNUNET_PROGRAM_run (argc,
4021 argv, 4116 argv,
4022 "gnunet-daemon-exit", 4117 "gnunet-daemon-exit",
4023 gettext_noop("Daemon to run to provide an IP exit node for the VPN"), 4118 gettext_noop (
4024 options, 4119 "Daemon to run to provide an IP exit node for the VPN"),
4025 &run, 4120 options,
4026 NULL)) ? global_ret : 1; 4121 &run,
4122 NULL)) ? global_ret : 1;
4027} 4123}
4028 4124
4029 4125
diff --git a/src/exit/gnunet-helper-exit.c b/src/exit/gnunet-helper-exit.c
index 297a17813..ca187afa6 100644
--- a/src/exit/gnunet-helper-exit.c
+++ b/src/exit/gnunet-helper-exit.c
@@ -81,7 +81,8 @@ static const char *sbin_iptables;
81/** 81/**
82 * This is in linux/include/net/ipv6.h, but not always exported... 82 * This is in linux/include/net/ipv6.h, but not always exported...
83 */ 83 */
84struct in6_ifreq { 84struct in6_ifreq
85{
85 struct in6_addr ifr6_addr; 86 struct in6_addr ifr6_addr;
86 uint32_t ifr6_prefixlen; /* __u32 in the original */ 87 uint32_t ifr6_prefixlen; /* __u32 in the original */
87 int ifr6_ifindex; 88 int ifr6_ifindex;
@@ -97,22 +98,22 @@ struct in6_ifreq {
97 * @param flags open flags (O_RDONLY, O_WRONLY) 98 * @param flags open flags (O_RDONLY, O_WRONLY)
98 */ 99 */
99static void 100static void
100open_dev_null(int target_fd, 101open_dev_null (int target_fd,
101 int flags) 102 int flags)
102{ 103{
103 int fd; 104 int fd;
104 105
105 fd = open("/dev/null", flags); 106 fd = open ("/dev/null", flags);
106 if (-1 == fd) 107 if (-1 == fd)
107 abort(); 108 abort ();
108 if (fd == target_fd) 109 if (fd == target_fd)
109 return; 110 return;
110 if (-1 == dup2(fd, target_fd)) 111 if (-1 == dup2 (fd, target_fd))
111 { 112 {
112 (void)close(fd); 113 (void) close (fd);
113 abort(); 114 abort ();
114 } 115 }
115 (void)close(fd); 116 (void) close (fd);
116} 117}
117 118
118 119
@@ -124,50 +125,50 @@ open_dev_null(int target_fd,
124 * @return 0 on success, 1 on any error 125 * @return 0 on success, 1 on any error
125 */ 126 */
126static int 127static int
127fork_and_exec(const char *file, 128fork_and_exec (const char *file,
128 char *const cmd[]) 129 char *const cmd[])
129{ 130{
130 int status; 131 int status;
131 pid_t pid; 132 pid_t pid;
132 pid_t ret; 133 pid_t ret;
133 134
134 pid = fork(); 135 pid = fork ();
135 if (-1 == pid) 136 if (-1 == pid)
136 { 137 {
137 fprintf(stderr, 138 fprintf (stderr,
138 "fork failed: %s\n", 139 "fork failed: %s\n",
139 strerror(errno)); 140 strerror (errno));
140 return 1; 141 return 1;
141 } 142 }
142 if (0 == pid) 143 if (0 == pid)
143 { 144 {
144 /* we are the child process */ 145 /* we are the child process */
145 /* close stdin/stdout to not cause interference 146 /* close stdin/stdout to not cause interference
146 with the helper's main protocol! */ 147 with the helper's main protocol! */
147 (void)close(0); 148 (void) close (0);
148 open_dev_null(0, O_RDONLY); 149 open_dev_null (0, O_RDONLY);
149 (void)close(1); 150 (void) close (1);
150 open_dev_null(1, O_WRONLY); 151 open_dev_null (1, O_WRONLY);
151 (void)execv(file, cmd); 152 (void) execv (file, cmd);
152 /* can only get here on error */ 153 /* can only get here on error */
153 fprintf(stderr, 154 fprintf (stderr,
154 "exec `%s' failed: %s\n", 155 "exec `%s' failed: %s\n",
155 file, 156 file,
156 strerror(errno)); 157 strerror (errno));
157 _exit(1); 158 _exit (1);
158 } 159 }
159 /* keep running waitpid as long as the only error we get is 'EINTR' */ 160 /* keep running waitpid as long as the only error we get is 'EINTR' */
160 while ((-1 == (ret = waitpid(pid, &status, 0))) && 161 while ((-1 == (ret = waitpid (pid, &status, 0))) &&
161 (errno == EINTR)) 162 (errno == EINTR))
162 ; 163 ;
163 if (-1 == ret) 164 if (-1 == ret)
164 { 165 {
165 fprintf(stderr, 166 fprintf (stderr,
166 "waitpid failed: %s\n", 167 "waitpid failed: %s\n",
167 strerror(errno)); 168 strerror (errno));
168 return 1; 169 return 1;
169 } 170 }
170 if (!(WIFEXITED(status) && (0 == WEXITSTATUS(status)))) 171 if (! (WIFEXITED (status) && (0 == WEXITSTATUS (status))))
171 return 1; 172 return 1;
172 /* child process completed and returned success, we're happy */ 173 /* child process completed and returned success, we're happy */
173 return 0; 174 return 0;
@@ -182,46 +183,46 @@ fork_and_exec(const char *file,
182 * @return the fd to the tun or -1 on error 183 * @return the fd to the tun or -1 on error
183 */ 184 */
184static int 185static int
185init_tun(char *dev) 186init_tun (char *dev)
186{ 187{
187 struct ifreq ifr; 188 struct ifreq ifr;
188 int fd; 189 int fd;
189 190
190 if (NULL == dev) 191 if (NULL == dev)
191 { 192 {
192 errno = EINVAL; 193 errno = EINVAL;
193 return -1; 194 return -1;
194 } 195 }
195 196
196 if (-1 == (fd = open("/dev/net/tun", O_RDWR))) 197 if (-1 == (fd = open ("/dev/net/tun", O_RDWR)))
197 { 198 {
198 fprintf(stderr, "Error opening `%s': %s\n", "/dev/net/tun", 199 fprintf (stderr, "Error opening `%s': %s\n", "/dev/net/tun",
199 strerror(errno)); 200 strerror (errno));
200 return -1; 201 return -1;
201 } 202 }
202 203
203 if (fd >= FD_SETSIZE) 204 if (fd >= FD_SETSIZE)
204 { 205 {
205 fprintf(stderr, "File descriptor to large: %d", fd); 206 fprintf (stderr, "File descriptor to large: %d", fd);
206 (void)close(fd); 207 (void) close (fd);
207 return -1; 208 return -1;
208 } 209 }
209 210
210 memset(&ifr, 0, sizeof(ifr)); 211 memset (&ifr, 0, sizeof(ifr));
211 ifr.ifr_flags = IFF_TUN; 212 ifr.ifr_flags = IFF_TUN;
212 213
213 if ('\0' != *dev) 214 if ('\0' != *dev)
214 strncpy(ifr.ifr_name, dev, IFNAMSIZ); 215 strncpy (ifr.ifr_name, dev, IFNAMSIZ);
215 216
216 if (-1 == ioctl(fd, TUNSETIFF, (void *)&ifr)) 217 if (-1 == ioctl (fd, TUNSETIFF, (void *) &ifr))
217 { 218 {
218 fprintf(stderr, 219 fprintf (stderr,
219 "Error with ioctl on `%s': %s\n", "/dev/net/tun", 220 "Error with ioctl on `%s': %s\n", "/dev/net/tun",
220 strerror(errno)); 221 strerror (errno));
221 (void)close(fd); 222 (void) close (fd);
222 return -1; 223 return -1;
223 } 224 }
224 strcpy(dev, ifr.ifr_name); 225 strcpy (dev, ifr.ifr_name);
225 return fd; 226 return fd;
226} 227}
227 228
@@ -234,7 +235,7 @@ init_tun(char *dev)
234 * @param prefix_len the length of the network-prefix 235 * @param prefix_len the length of the network-prefix
235 */ 236 */
236static void 237static void
237set_address6(const char *dev, const char *address, unsigned long prefix_len) 238set_address6 (const char *dev, const char *address, unsigned long prefix_len)
238{ 239{
239 struct ifreq ifr; 240 struct ifreq ifr;
240 struct sockaddr_in6 sa6; 241 struct sockaddr_in6 sa6;
@@ -244,34 +245,34 @@ set_address6(const char *dev, const char *address, unsigned long prefix_len)
244 /* 245 /*
245 * parse the new address 246 * parse the new address
246 */ 247 */
247 memset(&sa6, 0, sizeof(struct sockaddr_in6)); 248 memset (&sa6, 0, sizeof(struct sockaddr_in6));
248 sa6.sin6_family = AF_INET6; 249 sa6.sin6_family = AF_INET6;
249 if (1 != inet_pton(AF_INET6, address, &sa6.sin6_addr)) 250 if (1 != inet_pton (AF_INET6, address, &sa6.sin6_addr))
250 { 251 {
251 fprintf(stderr, "Failed to parse address `%s': %s\n", address, 252 fprintf (stderr, "Failed to parse address `%s': %s\n", address,
252 strerror(errno)); 253 strerror (errno));
253 exit(1); 254 exit (1);
254 } 255 }
255 256
256 if (-1 == (fd = socket(PF_INET6, SOCK_DGRAM, 0))) 257 if (-1 == (fd = socket (PF_INET6, SOCK_DGRAM, 0)))
257 { 258 {
258 fprintf(stderr, "Error creating socket: %s\n", strerror(errno)); 259 fprintf (stderr, "Error creating socket: %s\n", strerror (errno));
259 exit(1); 260 exit (1);
260 } 261 }
261 262
262 memset(&ifr, 0, sizeof(struct ifreq)); 263 memset (&ifr, 0, sizeof(struct ifreq));
263 /* 264 /*
264 * Get the index of the if 265 * Get the index of the if
265 */ 266 */
266 strncpy(ifr.ifr_name, dev, IFNAMSIZ); 267 strncpy (ifr.ifr_name, dev, IFNAMSIZ);
267 if (-1 == ioctl(fd, SIOGIFINDEX, &ifr)) 268 if (-1 == ioctl (fd, SIOGIFINDEX, &ifr))
268 { 269 {
269 fprintf(stderr, "ioctl failed at %d: %s\n", __LINE__, strerror(errno)); 270 fprintf (stderr, "ioctl failed at %d: %s\n", __LINE__, strerror (errno));
270 (void)close(fd); 271 (void) close (fd);
271 exit(1); 272 exit (1);
272 } 273 }
273 274
274 memset(&ifr6, 0, sizeof(struct in6_ifreq)); 275 memset (&ifr6, 0, sizeof(struct in6_ifreq));
275 ifr6.ifr6_addr = sa6.sin6_addr; 276 ifr6.ifr6_addr = sa6.sin6_addr;
276 ifr6.ifr6_ifindex = ifr.ifr_ifindex; 277 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
277 ifr6.ifr6_prefixlen = prefix_len; 278 ifr6.ifr6_prefixlen = prefix_len;
@@ -279,42 +280,42 @@ set_address6(const char *dev, const char *address, unsigned long prefix_len)
279 /* 280 /*
280 * Set the address 281 * Set the address
281 */ 282 */
282 if (-1 == ioctl(fd, SIOCSIFADDR, &ifr6)) 283 if (-1 == ioctl (fd, SIOCSIFADDR, &ifr6))
283 { 284 {
284 fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, 285 fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
285 strerror(errno)); 286 strerror (errno));
286 (void)close(fd); 287 (void) close (fd);
287 exit(1); 288 exit (1);
288 } 289 }
289 290
290 /* 291 /*
291 * Get the flags 292 * Get the flags
292 */ 293 */
293 if (-1 == ioctl(fd, SIOCGIFFLAGS, &ifr)) 294 if (-1 == ioctl (fd, SIOCGIFFLAGS, &ifr))
294 { 295 {
295 fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, 296 fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
296 strerror(errno)); 297 strerror (errno));
297 (void)close(fd); 298 (void) close (fd);
298 exit(1); 299 exit (1);
299 } 300 }
300 301
301 /* 302 /*
302 * Add the UP and RUNNING flags 303 * Add the UP and RUNNING flags
303 */ 304 */
304 ifr.ifr_flags |= IFF_UP | IFF_RUNNING; 305 ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
305 if (-1 == ioctl(fd, SIOCSIFFLAGS, &ifr)) 306 if (-1 == ioctl (fd, SIOCSIFFLAGS, &ifr))
306 { 307 {
307 fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, 308 fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
308 strerror(errno)); 309 strerror (errno));
309 (void)close(fd); 310 (void) close (fd);
310 exit(1); 311 exit (1);
311 } 312 }
312 313
313 if (0 != close(fd)) 314 if (0 != close (fd))
314 { 315 {
315 fprintf(stderr, "close failed: %s\n", strerror(errno)); 316 fprintf (stderr, "close failed: %s\n", strerror (errno));
316 exit(1); 317 exit (1);
317 } 318 }
318} 319}
319 320
320 321
@@ -326,96 +327,96 @@ set_address6(const char *dev, const char *address, unsigned long prefix_len)
326 * @param mask the netmask 327 * @param mask the netmask
327 */ 328 */
328static void 329static void
329set_address4(const char *dev, const char *address, const char *mask) 330set_address4 (const char *dev, const char *address, const char *mask)
330{ 331{
331 int fd; 332 int fd;
332 struct sockaddr_in *addr; 333 struct sockaddr_in *addr;
333 struct ifreq ifr; 334 struct ifreq ifr;
334 335
335 memset(&ifr, 0, sizeof(struct ifreq)); 336 memset (&ifr, 0, sizeof(struct ifreq));
336 addr = (struct sockaddr_in *)&(ifr.ifr_addr); 337 addr = (struct sockaddr_in *) &(ifr.ifr_addr);
337 addr->sin_family = AF_INET; 338 addr->sin_family = AF_INET;
338 339
339 /* 340 /*
340 * Parse the address 341 * Parse the address
341 */ 342 */
342 if (1 != inet_pton(AF_INET, address, &addr->sin_addr.s_addr)) 343 if (1 != inet_pton (AF_INET, address, &addr->sin_addr.s_addr))
343 { 344 {
344 fprintf(stderr, "Failed to parse address `%s': %s\n", address, 345 fprintf (stderr, "Failed to parse address `%s': %s\n", address,
345 strerror(errno)); 346 strerror (errno));
346 exit(1); 347 exit (1);
347 } 348 }
348 349
349 if (-1 == (fd = socket(PF_INET, SOCK_DGRAM, 0))) 350 if (-1 == (fd = socket (PF_INET, SOCK_DGRAM, 0)))
350 { 351 {
351 fprintf(stderr, "Error creating socket: %s\n", strerror(errno)); 352 fprintf (stderr, "Error creating socket: %s\n", strerror (errno));
352 exit(1); 353 exit (1);
353 } 354 }
354 355
355 strncpy(ifr.ifr_name, dev, IFNAMSIZ); 356 strncpy (ifr.ifr_name, dev, IFNAMSIZ);
356 357
357 /* 358 /*
358 * Set the address 359 * Set the address
359 */ 360 */
360 if (-1 == ioctl(fd, SIOCSIFADDR, &ifr)) 361 if (-1 == ioctl (fd, SIOCSIFADDR, &ifr))
361 { 362 {
362 fprintf(stderr, "ioctl failed at %d: %s\n", __LINE__, strerror(errno)); 363 fprintf (stderr, "ioctl failed at %d: %s\n", __LINE__, strerror (errno));
363 (void)close(fd); 364 (void) close (fd);
364 exit(1); 365 exit (1);
365 } 366 }
366 367
367 /* 368 /*
368 * Parse the netmask 369 * Parse the netmask
369 */ 370 */
370 addr = (struct sockaddr_in *)&(ifr.ifr_netmask); 371 addr = (struct sockaddr_in *) &(ifr.ifr_netmask);
371 if (1 != inet_pton(AF_INET, mask, &addr->sin_addr.s_addr)) 372 if (1 != inet_pton (AF_INET, mask, &addr->sin_addr.s_addr))
372 { 373 {
373 fprintf(stderr, "Failed to parse address `%s': %s\n", mask, 374 fprintf (stderr, "Failed to parse address `%s': %s\n", mask,
374 strerror(errno)); 375 strerror (errno));
375 (void)close(fd); 376 (void) close (fd);
376 exit(1); 377 exit (1);
377 } 378 }
378 379
379 /* 380 /*
380 * Set the netmask 381 * Set the netmask
381 */ 382 */
382 if (-1 == ioctl(fd, SIOCSIFNETMASK, &ifr)) 383 if (-1 == ioctl (fd, SIOCSIFNETMASK, &ifr))
383 { 384 {
384 fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, 385 fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
385 strerror(errno)); 386 strerror (errno));
386 (void)close(fd); 387 (void) close (fd);
387 exit(1); 388 exit (1);
388 } 389 }
389 390
390 /* 391 /*
391 * Get the flags 392 * Get the flags
392 */ 393 */
393 if (-1 == ioctl(fd, SIOCGIFFLAGS, &ifr)) 394 if (-1 == ioctl (fd, SIOCGIFFLAGS, &ifr))
394 { 395 {
395 fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, 396 fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
396 strerror(errno)); 397 strerror (errno));
397 (void)close(fd); 398 (void) close (fd);
398 exit(1); 399 exit (1);
399 } 400 }
400 401
401 /* 402 /*
402 * Add the UP and RUNNING flags 403 * Add the UP and RUNNING flags
403 */ 404 */
404 ifr.ifr_flags |= IFF_UP | IFF_RUNNING; 405 ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
405 if (-1 == ioctl(fd, SIOCSIFFLAGS, &ifr)) 406 if (-1 == ioctl (fd, SIOCSIFFLAGS, &ifr))
406 { 407 {
407 fprintf(stderr, "ioctl failed at line %d: %s\n", __LINE__, 408 fprintf (stderr, "ioctl failed at line %d: %s\n", __LINE__,
408 strerror(errno)); 409 strerror (errno));
409 (void)close(fd); 410 (void) close (fd);
410 exit(1); 411 exit (1);
411 } 412 }
412 413
413 if (0 != close(fd)) 414 if (0 != close (fd))
414 { 415 {
415 fprintf(stderr, "close failed: %s\n", strerror(errno)); 416 fprintf (stderr, "close failed: %s\n", strerror (errno));
416 (void)close(fd); 417 (void) close (fd);
417 exit(1); 418 exit (1);
418 } 419 }
419} 420}
420 421
421 422
@@ -425,7 +426,7 @@ set_address4(const char *dev, const char *address, const char *mask)
425 * @param fd_tun tunnel FD 426 * @param fd_tun tunnel FD
426 */ 427 */
427static void 428static void
428run(int fd_tun) 429run (int fd_tun)
429{ 430{
430 /* 431 /*
431 * The buffer filled by reading from fd_tun 432 * The buffer filled by reading from fd_tun
@@ -452,188 +453,188 @@ run(int fd_tun)
452 int write_open = 1; 453 int write_open = 1;
453 454
454 while ((1 == read_open) && (1 == write_open)) 455 while ((1 == read_open) && (1 == write_open))
455 { 456 {
456 FD_ZERO(&fds_w); 457 FD_ZERO (&fds_w);
457 FD_ZERO(&fds_r); 458 FD_ZERO (&fds_r);
458 459
459 /* 460 /*
460 * We are supposed to read and the buffer is empty 461 * We are supposed to read and the buffer is empty
461 * -> select on read from tun 462 * -> select on read from tun
462 */ 463 */
463 if (read_open && (0 == buftun_size)) 464 if (read_open && (0 == buftun_size))
464 FD_SET(fd_tun, &fds_r); 465 FD_SET (fd_tun, &fds_r);
465 466
466 /* 467 /*
467 * We are supposed to read and the buffer is not empty 468 * We are supposed to read and the buffer is not empty
468 * -> select on write to stdout 469 * -> select on write to stdout
469 */ 470 */
470 if (read_open && (0 != buftun_size)) 471 if (read_open && (0 != buftun_size))
471 FD_SET(1, &fds_w); 472 FD_SET (1, &fds_w);
472 473
473 /* 474 /*
474 * We are supposed to write and the buffer is empty 475 * We are supposed to write and the buffer is empty
475 * -> select on read from stdin 476 * -> select on read from stdin
476 */ 477 */
477 if (write_open && (NULL == bufin_read)) 478 if (write_open && (NULL == bufin_read))
478 FD_SET(0, &fds_r); 479 FD_SET (0, &fds_r);
479 480
480 /* 481 /*
481 * We are supposed to write and the buffer is not empty 482 * We are supposed to write and the buffer is not empty
482 * -> select on write to tun 483 * -> select on write to tun
483 */ 484 */
484 if (write_open && (NULL != bufin_read)) 485 if (write_open && (NULL != bufin_read))
485 FD_SET(fd_tun, &fds_w); 486 FD_SET (fd_tun, &fds_w);
486 487
487 int r = select(fd_tun + 1, &fds_r, &fds_w, NULL, NULL); 488 int r = select (fd_tun + 1, &fds_r, &fds_w, NULL, NULL);
488 489
489 if (-1 == r) 490 if (-1 == r)
491 {
492 if (EINTR == errno)
493 continue;
494 fprintf (stderr, "select failed: %s\n", strerror (errno));
495 exit (1);
496 }
497
498 if (r > 0)
499 {
500 if (FD_ISSET (fd_tun, &fds_r))
501 {
502 buftun_size =
503 read (fd_tun, buftun + sizeof(struct GNUNET_MessageHeader),
504 MAX_SIZE - sizeof(struct GNUNET_MessageHeader));
505 if (-1 == buftun_size)
490 { 506 {
491 if (EINTR == errno) 507 fprintf (stderr,
492 continue; 508 "read-error: %s\n",
493 fprintf(stderr, "select failed: %s\n", strerror(errno)); 509 strerror (errno));
494 exit(1); 510 shutdown (fd_tun, SHUT_RD);
511 shutdown (1, SHUT_WR);
512 read_open = 0;
513 buftun_size = 0;
495 } 514 }
496 515 else if (0 == buftun_size)
497 if (r > 0)
498 { 516 {
499 if (FD_ISSET(fd_tun, &fds_r))
500 {
501 buftun_size =
502 read(fd_tun, buftun + sizeof(struct GNUNET_MessageHeader),
503 MAX_SIZE - sizeof(struct GNUNET_MessageHeader));
504 if (-1 == buftun_size)
505 {
506 fprintf(stderr,
507 "read-error: %s\n",
508 strerror(errno));
509 shutdown(fd_tun, SHUT_RD);
510 shutdown(1, SHUT_WR);
511 read_open = 0;
512 buftun_size = 0;
513 }
514 else if (0 == buftun_size)
515 {
516#if DEBUG 517#if DEBUG
517 fprintf(stderr, "EOF on tun\n"); 518 fprintf (stderr, "EOF on tun\n");
518#endif 519#endif
519 shutdown(fd_tun, SHUT_RD); 520 shutdown (fd_tun, SHUT_RD);
520 shutdown(1, SHUT_WR); 521 shutdown (1, SHUT_WR);
521 read_open = 0; 522 read_open = 0;
522 buftun_size = 0; 523 buftun_size = 0;
523 } 524 }
524 else 525 else
525 { 526 {
526 buftun_read = buftun; 527 buftun_read = buftun;
527 struct GNUNET_MessageHeader *hdr = 528 struct GNUNET_MessageHeader *hdr =
528 (struct GNUNET_MessageHeader *)buftun; 529 (struct GNUNET_MessageHeader *) buftun;
529 buftun_size += sizeof(struct GNUNET_MessageHeader); 530 buftun_size += sizeof(struct GNUNET_MessageHeader);
530 hdr->type = htons(GNUNET_MESSAGE_TYPE_VPN_HELPER); 531 hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_HELPER);
531 hdr->size = htons(buftun_size); 532 hdr->size = htons (buftun_size);
532 } 533 }
533 } 534 }
534 else if (FD_ISSET(1, &fds_w)) 535 else if (FD_ISSET (1, &fds_w))
535 { 536 {
536 ssize_t written = write(1, buftun_read, buftun_size); 537 ssize_t written = write (1, buftun_read, buftun_size);
537 538
538 if (-1 == written) 539 if (-1 == written)
539 { 540 {
540#if !DEBUG 541#if ! DEBUG
541 if (errno != EPIPE) 542 if (errno != EPIPE)
542#endif 543#endif
543 fprintf(stderr, 544 fprintf (stderr,
544 "write-error to stdout: %s\n", 545 "write-error to stdout: %s\n",
545 strerror(errno)); 546 strerror (errno));
546 shutdown(fd_tun, SHUT_RD); 547 shutdown (fd_tun, SHUT_RD);
547 shutdown(1, SHUT_WR); 548 shutdown (1, SHUT_WR);
548 read_open = 0; 549 read_open = 0;
549 buftun_size = 0; 550 buftun_size = 0;
550 } 551 }
551 else if (0 == written) 552 else if (0 == written)
552 { 553 {
553 fprintf(stderr, "write returned 0!?\n"); 554 fprintf (stderr, "write returned 0!?\n");
554 exit(1); 555 exit (1);
555 } 556 }
556 else 557 else
557 { 558 {
558 buftun_size -= written; 559 buftun_size -= written;
559 buftun_read += written; 560 buftun_read += written;
560 } 561 }
561 } 562 }
562 563
563 if (FD_ISSET(0, &fds_r)) 564 if (FD_ISSET (0, &fds_r))
564 { 565 {
565 bufin_size = read(0, bufin + bufin_rpos, MAX_SIZE - bufin_rpos); 566 bufin_size = read (0, bufin + bufin_rpos, MAX_SIZE - bufin_rpos);
566 if (-1 == bufin_size) 567 if (-1 == bufin_size)
567 { 568 {
568 fprintf(stderr, "read-error: %s\n", strerror(errno)); 569 fprintf (stderr, "read-error: %s\n", strerror (errno));
569 shutdown(0, SHUT_RD); 570 shutdown (0, SHUT_RD);
570 shutdown(fd_tun, SHUT_WR); 571 shutdown (fd_tun, SHUT_WR);
571 write_open = 0; 572 write_open = 0;
572 bufin_size = 0; 573 bufin_size = 0;
573 } 574 }
574 else if (0 == bufin_size) 575 else if (0 == bufin_size)
575 { 576 {
576#if DEBUG 577#if DEBUG
577 fprintf(stderr, "EOF on stdin\n"); 578 fprintf (stderr, "EOF on stdin\n");
578#endif 579#endif
579 shutdown(0, SHUT_RD); 580 shutdown (0, SHUT_RD);
580 shutdown(fd_tun, SHUT_WR); 581 shutdown (fd_tun, SHUT_WR);
581 write_open = 0; 582 write_open = 0;
582 bufin_size = 0; 583 bufin_size = 0;
583 } 584 }
584 else 585 else
585 { 586 {
586 struct GNUNET_MessageHeader *hdr; 587 struct GNUNET_MessageHeader *hdr;
587 588
588PROCESS_BUFFER: 589PROCESS_BUFFER:
589 bufin_rpos += bufin_size; 590 bufin_rpos += bufin_size;
590 if (bufin_rpos < sizeof(struct GNUNET_MessageHeader)) 591 if (bufin_rpos < sizeof(struct GNUNET_MessageHeader))
591 continue; 592 continue;
592 hdr = (struct GNUNET_MessageHeader *)bufin; 593 hdr = (struct GNUNET_MessageHeader *) bufin;
593 if (ntohs(hdr->type) != GNUNET_MESSAGE_TYPE_VPN_HELPER) 594 if (ntohs (hdr->type) != GNUNET_MESSAGE_TYPE_VPN_HELPER)
594 { 595 {
595 fprintf(stderr, "protocol violation!\n"); 596 fprintf (stderr, "protocol violation!\n");
596 exit(1); 597 exit (1);
597 } 598 }
598 if (ntohs(hdr->size) > bufin_rpos) 599 if (ntohs (hdr->size) > bufin_rpos)
599 continue; 600 continue;
600 bufin_read = bufin + sizeof(struct GNUNET_MessageHeader); 601 bufin_read = bufin + sizeof(struct GNUNET_MessageHeader);
601 bufin_size = ntohs(hdr->size) - sizeof(struct GNUNET_MessageHeader); 602 bufin_size = ntohs (hdr->size) - sizeof(struct GNUNET_MessageHeader);
602 bufin_rpos -= bufin_size + sizeof(struct GNUNET_MessageHeader); 603 bufin_rpos -= bufin_size + sizeof(struct GNUNET_MessageHeader);
603 } 604 }
604 } 605 }
605 else if (FD_ISSET(fd_tun, &fds_w)) 606 else if (FD_ISSET (fd_tun, &fds_w))
606 { 607 {
607 ssize_t written = write(fd_tun, bufin_read, bufin_size); 608 ssize_t written = write (fd_tun, bufin_read, bufin_size);
608 609
609 if (-1 == written) 610 if (-1 == written)
610 { 611 {
611 fprintf(stderr, "write-error to tun: %s\n", strerror(errno)); 612 fprintf (stderr, "write-error to tun: %s\n", strerror (errno));
612 shutdown(0, SHUT_RD); 613 shutdown (0, SHUT_RD);
613 shutdown(fd_tun, SHUT_WR); 614 shutdown (fd_tun, SHUT_WR);
614 write_open = 0; 615 write_open = 0;
615 bufin_size = 0; 616 bufin_size = 0;
616 }
617 else if (0 == written)
618 {
619 fprintf(stderr, "write returned 0!?\n");
620 exit(1);
621 }
622 else
623 {
624 bufin_size -= written;
625 bufin_read += written;
626 if (0 == bufin_size)
627 {
628 memmove(bufin, bufin_read, bufin_rpos);
629 bufin_read = NULL; /* start reading again */
630 bufin_size = 0;
631 goto PROCESS_BUFFER;
632 }
633 }
634 }
635 } 617 }
618 else if (0 == written)
619 {
620 fprintf (stderr, "write returned 0!?\n");
621 exit (1);
622 }
623 else
624 {
625 bufin_size -= written;
626 bufin_read += written;
627 if (0 == bufin_size)
628 {
629 memmove (bufin, bufin_read, bufin_rpos);
630 bufin_read = NULL; /* start reading again */
631 bufin_size = 0;
632 goto PROCESS_BUFFER;
633 }
634 }
635 }
636 } 636 }
637 }
637} 638}
638 639
639 640
@@ -651,166 +652,164 @@ PROCESS_BUFFER:
651 * 6: IPv4 netmask ("255.255.0.0") [ignored if #4 is "-"] 652 * 6: IPv4 netmask ("255.255.0.0") [ignored if #4 is "-"]
652 */ 653 */
653int 654int
654main(int argc, char **argv) 655main (int argc, char **argv)
655{ 656{
656 char dev[IFNAMSIZ]; 657 char dev[IFNAMSIZ];
657 int fd_tun; 658 int fd_tun;
658 int global_ret; 659 int global_ret;
659 660
660 if (7 != argc) 661 if (7 != argc)
661 { 662 {
662 fprintf(stderr, "Fatal: must supply 6 arguments!\n"); 663 fprintf (stderr, "Fatal: must supply 6 arguments!\n");
663 return 1; 664 return 1;
664 } 665 }
665 if ((0 == strcmp(argv[3], "-")) && 666 if ((0 == strcmp (argv[3], "-")) &&
666 (0 == strcmp(argv[5], "-"))) 667 (0 == strcmp (argv[5], "-")))
667 { 668 {
668 fprintf(stderr, "Fatal: disabling both IPv4 and IPv6 makes no sense.\n"); 669 fprintf (stderr, "Fatal: disabling both IPv4 and IPv6 makes no sense.\n");
669 return 1; 670 return 1;
670 } 671 }
671 if (0 != strcmp(argv[2], "-")) 672 if (0 != strcmp (argv[2], "-"))
672 { 673 {
673#ifdef IPTABLES 674#ifdef IPTABLES
674 if (0 == access(IPTABLES, X_OK)) 675 if (0 == access (IPTABLES, X_OK))
675 sbin_iptables = IPTABLES; 676 sbin_iptables = IPTABLES;
676 else 677 else
677#endif 678#endif
678 if (0 == access("/sbin/iptables", X_OK)) 679 if (0 == access ("/sbin/iptables", X_OK))
679 sbin_iptables = "/sbin/iptables"; 680 sbin_iptables = "/sbin/iptables";
680 else if (0 == access("/usr/sbin/iptables", X_OK)) 681 else if (0 == access ("/usr/sbin/iptables", X_OK))
681 sbin_iptables = "/usr/sbin/iptables"; 682 sbin_iptables = "/usr/sbin/iptables";
682 else 683 else
683 { 684 {
684 fprintf(stderr, 685 fprintf (stderr,
685 "Fatal: executable iptables not found in approved directories: %s\n", 686 "Fatal: executable iptables not found in approved directories: %s\n",
686 strerror(errno)); 687 strerror (errno));
687 return 1; 688 return 1;
688 } 689 }
689#ifdef SYSCTL 690#ifdef SYSCTL
690 if (0 == access(SYSCTL, X_OK)) 691 if (0 == access (SYSCTL, X_OK))
691 sbin_sysctl = SYSCTL; 692 sbin_sysctl = SYSCTL;
692 else 693 else
693#endif 694#endif
694 if (0 == access("/sbin/sysctl", X_OK)) 695 if (0 == access ("/sbin/sysctl", X_OK))
695 sbin_sysctl = "/sbin/sysctl"; 696 sbin_sysctl = "/sbin/sysctl";
696 else if (0 == access("/usr/sbin/sysctl", X_OK)) 697 else if (0 == access ("/usr/sbin/sysctl", X_OK))
697 sbin_sysctl = "/usr/sbin/sysctl"; 698 sbin_sysctl = "/usr/sbin/sysctl";
698 else 699 else
699 { 700 {
700 fprintf(stderr, 701 fprintf (stderr,
701 "Fatal: executable sysctl not found in approved directories: %s\n", 702 "Fatal: executable sysctl not found in approved directories: %s\n",
702 strerror(errno)); 703 strerror (errno));
703 return 1; 704 return 1;
704 }
705 } 705 }
706 }
706 707
707 strncpy(dev, argv[1], IFNAMSIZ); 708 strncpy (dev, argv[1], IFNAMSIZ);
708 dev[IFNAMSIZ - 1] = '\0'; 709 dev[IFNAMSIZ - 1] = '\0';
709 710
710 if (-1 == (fd_tun = init_tun(dev))) 711 if (-1 == (fd_tun = init_tun (dev)))
712 {
713 fprintf (stderr,
714 "Fatal: could not initialize tun-interface `%s' with IPv6 %s/%s and IPv4 %s/%s\n",
715 dev,
716 argv[3],
717 argv[4],
718 argv[5],
719 argv[6]);
720 return 1;
721 }
722
723 if (0 != strcmp (argv[3], "-"))
724 {
711 { 725 {
712 fprintf(stderr, 726 const char *address = argv[3];
713 "Fatal: could not initialize tun-interface `%s' with IPv6 %s/%s and IPv4 %s/%s\n", 727 long prefix_len = atol (argv[4]);
714 dev,
715 argv[3],
716 argv[4],
717 argv[5],
718 argv[6]);
719 return 1;
720 }
721 728
722 if (0 != strcmp(argv[3], "-")) 729 if ((prefix_len < 1) || (prefix_len > 127))
730 {
731 fprintf (stderr, "Fatal: prefix_len out of range\n");
732 return 1;
733 }
734 set_address6 (dev, address, prefix_len);
735 }
736 if (0 != strcmp (argv[2], "-"))
723 { 737 {
738 char *const sysctl_args[] = {
739 "sysctl", "-w", "net.ipv6.conf.all.forwarding=1", NULL
740 };
741 if (0 != fork_and_exec (sbin_sysctl,
742 sysctl_args))
724 { 743 {
725 const char *address = argv[3]; 744 fprintf (stderr,
726 long prefix_len = atol(argv[4]); 745 "Failed to enable IPv6 forwarding. Will continue anyway.\n");
727
728 if ((prefix_len < 1) || (prefix_len > 127))
729 {
730 fprintf(stderr, "Fatal: prefix_len out of range\n");
731 return 1;
732 }
733 set_address6(dev, address, prefix_len);
734 } 746 }
735 if (0 != strcmp(argv[2], "-"))
736 {
737 char *const sysctl_args[] =
738 {
739 "sysctl", "-w", "net.ipv6.conf.all.forwarding=1", NULL
740 };
741 if (0 != fork_and_exec(sbin_sysctl,
742 sysctl_args))
743 {
744 fprintf(stderr,
745 "Failed to enable IPv6 forwarding. Will continue anyway.\n");
746 }
747 }
748 } 747 }
748 }
749 749
750 if (0 != strcmp(argv[5], "-")) 750 if (0 != strcmp (argv[5], "-"))
751 {
751 { 752 {
752 { 753 const char *address = argv[5];
753 const char *address = argv[5]; 754 const char *mask = argv[6];
754 const char *mask = argv[6];
755 755
756 set_address4(dev, address, mask); 756 set_address4 (dev, address, mask);
757 }
758 if (0 != strcmp (argv[2], "-"))
759 {
760 {
761 char *const sysctl_args[] = {
762 "sysctl", "-w", "net.ipv4.ip_forward=1", NULL
763 };
764 if (0 != fork_and_exec (sbin_sysctl,
765 sysctl_args))
766 {
767 fprintf (stderr,
768 "Failed to enable IPv4 forwarding. Will continue anyway.\n");
769 }
757 } 770 }
758 if (0 != strcmp(argv[2], "-")) 771 {
772 char *const iptables_args[] = {
773 "iptables", "-t", "nat", "-A", "POSTROUTING", "-o", argv[2], "-j",
774 "MASQUERADE", NULL
775 };
776 if (0 != fork_and_exec (sbin_iptables,
777 iptables_args))
759 { 778 {
760 { 779 fprintf (stderr,
761 char *const sysctl_args[] = 780 "Failed to enable IPv4 masquerading (NAT). Will continue anyway.\n");
762 {
763 "sysctl", "-w", "net.ipv4.ip_forward=1", NULL
764 };
765 if (0 != fork_and_exec(sbin_sysctl,
766 sysctl_args))
767 {
768 fprintf(stderr,
769 "Failed to enable IPv4 forwarding. Will continue anyway.\n");
770 }
771 }
772 {
773 char *const iptables_args[] =
774 {
775 "iptables", "-t", "nat", "-A", "POSTROUTING", "-o", argv[2], "-j", "MASQUERADE", NULL
776 };
777 if (0 != fork_and_exec(sbin_iptables,
778 iptables_args))
779 {
780 fprintf(stderr,
781 "Failed to enable IPv4 masquerading (NAT). Will continue anyway.\n");
782 }
783 }
784 } 781 }
782 }
785 } 783 }
784 }
786 785
787 uid_t uid = getuid(); 786 uid_t uid = getuid ();
788#ifdef HAVE_SETRESUID 787#ifdef HAVE_SETRESUID
789 if (0 != setresuid(uid, uid, uid)) 788 if (0 != setresuid (uid, uid, uid))
790 { 789 {
791 fprintf(stderr, "Failed to setresuid: %s\n", strerror(errno)); 790 fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno));
792 global_ret = 2; 791 global_ret = 2;
793 goto cleanup; 792 goto cleanup;
794 } 793 }
795#else 794#else
796 if (0 != (setuid(uid) | seteuid(uid))) 795 if (0 != (setuid (uid) | seteuid (uid)))
797 { 796 {
798 fprintf(stderr, "Failed to setuid: %s\n", strerror(errno)); 797 fprintf (stderr, "Failed to setuid: %s\n", strerror (errno));
799 global_ret = 2; 798 global_ret = 2;
800 goto cleanup; 799 goto cleanup;
801 } 800 }
802#endif 801#endif
803 802
804 if (SIG_ERR == signal(SIGPIPE, SIG_IGN)) 803 if (SIG_ERR == signal (SIGPIPE, SIG_IGN))
805 { 804 {
806 fprintf(stderr, "Failed to protect against SIGPIPE: %s\n", 805 fprintf (stderr, "Failed to protect against SIGPIPE: %s\n",
807 strerror(errno)); 806 strerror (errno));
808 /* no exit, we might as well die with SIGPIPE should it ever happen */ 807 /* no exit, we might as well die with SIGPIPE should it ever happen */
809 } 808 }
810 run(fd_tun); 809 run (fd_tun);
811 global_ret = 0; 810 global_ret = 0;
812cleanup: 811cleanup:
813 (void)close(fd_tun); 812 (void) close (fd_tun);
814 return global_ret; 813 return global_ret;
815} 814}
816 815