diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/transport/Makefile.am | 19 | ||||
-rw-r--r-- | src/transport/gnunet-nat-server.c | 1 | ||||
-rw-r--r-- | src/transport/plugin_transport_udp.c | 1604 | ||||
-rw-r--r-- | src/transport/plugin_transport_udp_nat.c | 1676 | ||||
-rw-r--r-- | src/transport/test_transport_api_udp_nat_peer1.conf | 7 | ||||
-rw-r--r-- | src/transport/test_transport_api_udp_nat_peer2.conf | 6 | ||||
-rw-r--r-- | src/transport/test_transport_api_udp_peer2.conf | 10 |
7 files changed, 1167 insertions, 2156 deletions
diff --git a/src/transport/Makefile.am b/src/transport/Makefile.am index da925bc0d..42952fa6c 100644 --- a/src/transport/Makefile.am +++ b/src/transport/Makefile.am | |||
@@ -72,7 +72,6 @@ gnunet_service_transport_LDADD = \ | |||
72 | plugin_LTLIBRARIES = \ | 72 | plugin_LTLIBRARIES = \ |
73 | libgnunet_plugin_transport_tcp.la \ | 73 | libgnunet_plugin_transport_tcp.la \ |
74 | libgnunet_plugin_transport_udp.la \ | 74 | libgnunet_plugin_transport_udp.la \ |
75 | libgnunet_plugin_transport_udp_nat.la \ | ||
76 | $(HTTP_PLUGIN_LA) \ | 75 | $(HTTP_PLUGIN_LA) \ |
77 | libgnunet_plugin_transport_template.la | 76 | libgnunet_plugin_transport_template.la |
78 | # TODO: add http, nat, etc. | 77 | # TODO: add http, nat, etc. |
@@ -104,15 +103,15 @@ libgnunet_plugin_transport_udp_la_LIBADD = \ | |||
104 | libgnunet_plugin_transport_udp_la_LDFLAGS = \ | 103 | libgnunet_plugin_transport_udp_la_LDFLAGS = \ |
105 | $(GN_PLUGIN_LDFLAGS) | 104 | $(GN_PLUGIN_LDFLAGS) |
106 | 105 | ||
107 | libgnunet_plugin_transport_udp_nat_la_SOURCES = \ | 106 | #libgnunet_plugin_transport_udp_nat_la_SOURCES = \ |
108 | plugin_transport_udp_nat.c | 107 | # plugin_transport_udp_nat.c |
109 | libgnunet_plugin_transport_udp_nat_la_LIBADD = \ | 108 | #libgnunet_plugin_transport_udp_nat_la_LIBADD = \ |
110 | $(top_builddir)/src/hello/libgnunethello.la \ | 109 | # $(top_builddir)/src/hello/libgnunethello.la \ |
111 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ | 110 | # $(top_builddir)/src/statistics/libgnunetstatistics.la \ |
112 | $(top_builddir)/src/peerinfo/libgnunetpeerinfo.la \ | 111 | # $(top_builddir)/src/peerinfo/libgnunetpeerinfo.la \ |
113 | $(top_builddir)/src/util/libgnunetutil.la | 112 | # $(top_builddir)/src/util/libgnunetutil.la |
114 | libgnunet_plugin_transport_udp_nat_la_LDFLAGS = \ | 113 | #libgnunet_plugin_transport_udp_nat_la_LDFLAGS = \ |
115 | $(GN_PLUGIN_LDFLAGS) | 114 | # $(GN_PLUGIN_LDFLAGS) |
116 | 115 | ||
117 | if HAVE_MHD | 116 | if HAVE_MHD |
118 | libgnunet_plugin_transport_http_la_SOURCES = \ | 117 | libgnunet_plugin_transport_http_la_SOURCES = \ |
diff --git a/src/transport/gnunet-nat-server.c b/src/transport/gnunet-nat-server.c index 8f39ab374..9bef4dbc8 100644 --- a/src/transport/gnunet-nat-server.c +++ b/src/transport/gnunet-nat-server.c | |||
@@ -248,6 +248,7 @@ process_icmp_response () | |||
248 | memcpy (&ip_pkt, &buf[off], sizeof (ip_pkt)); | 248 | memcpy (&ip_pkt, &buf[off], sizeof (ip_pkt)); |
249 | off += sizeof (ip_pkt); | 249 | off += sizeof (ip_pkt); |
250 | 250 | ||
251 | have_udp = 0; | ||
251 | if (ip_pkt.proto == IPPROTO_UDP) | 252 | if (ip_pkt.proto == IPPROTO_UDP) |
252 | { | 253 | { |
253 | have_udp = 1; | 254 | have_udp = 1; |
diff --git a/src/transport/plugin_transport_udp.c b/src/transport/plugin_transport_udp.c index 4de3f2c44..d66725957 100644 --- a/src/transport/plugin_transport_udp.c +++ b/src/transport/plugin_transport_udp.c | |||
@@ -20,9 +20,21 @@ | |||
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file transport/plugin_transport_udp.c | 22 | * @file transport/plugin_transport_udp.c |
23 | * @brief Implementation of the UDP transport service | 23 | * @brief Implementation of the UDP NAT punching |
24 | * transport service | ||
24 | * @author Christian Grothoff | 25 | * @author Christian Grothoff |
25 | * @author Nathan Evans | 26 | * @author Nathan Evans |
27 | * | ||
28 | * The idea with this transport is to connect gnunet peers to each other | ||
29 | * when ONE is behind a NAT. This is based on pwnat (http://samy.pl/pwnat) | ||
30 | * created by Samy Kamkar. When configured with the PWNAT options, this | ||
31 | * transport will start a server daemon which sends dummy ICMP and UDP | ||
32 | * messages out to a predefined address (typically 1.2.3.4). | ||
33 | * | ||
34 | * When a non-NAT'd peer (the client) learns of the NAT'd peer (the server) | ||
35 | * address, it will send ICMP RESPONSES to the NAT'd peers external address. | ||
36 | * The NAT box should forward these faked responses to the server, which | ||
37 | * can then connect directly to the non-NAT'd peer. | ||
26 | */ | 38 | */ |
27 | 39 | ||
28 | #include "platform.h" | 40 | #include "platform.h" |
@@ -40,26 +52,37 @@ | |||
40 | #include "plugin_transport.h" | 52 | #include "plugin_transport.h" |
41 | #include "transport.h" | 53 | #include "transport.h" |
42 | 54 | ||
43 | #define DEBUG_UDP GNUNET_NO | 55 | #define DEBUG_UDP GNUNET_YES |
44 | 56 | ||
45 | /** | 57 | #define MAX_PROBES 20 |
58 | |||
59 | /* | ||
46 | * Transport cost to peer, always 1 for UDP (direct connection) | 60 | * Transport cost to peer, always 1 for UDP (direct connection) |
47 | */ | 61 | */ |
48 | #define UDP_DIRECT_DISTANCE 1 | 62 | #define UDP_DIRECT_DISTANCE 1 |
49 | 63 | ||
50 | /** | 64 | /** |
65 | * Handle for request of hostname resolution, non-NULL if pending. | ||
66 | */ | ||
67 | static struct GNUNET_RESOLVER_RequestHandle *hostname_dns; | ||
68 | |||
69 | /** | ||
51 | * How long until we give up on transmitting the welcome message? | 70 | * How long until we give up on transmitting the welcome message? |
52 | */ | 71 | */ |
53 | #define HOSTNAME_RESOLVE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) | 72 | #define HOSTNAME_RESOLVE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) |
54 | 73 | ||
74 | /** | ||
75 | * Starting port for listening and sending, eventually a config value | ||
76 | */ | ||
77 | #define UDP_NAT_DEFAULT_PORT 22086 | ||
55 | 78 | ||
56 | /** | 79 | /** |
57 | * Message-Packet header. | 80 | * UDP Message-Packet header. |
58 | */ | 81 | */ |
59 | struct UDPMessage | 82 | struct UDPMessage |
60 | { | 83 | { |
61 | /** | 84 | /** |
62 | * size of the message, in bytes, including this header. | 85 | * Message header. |
63 | */ | 86 | */ |
64 | struct GNUNET_MessageHeader header; | 87 | struct GNUNET_MessageHeader header; |
65 | 88 | ||
@@ -71,61 +94,188 @@ struct UDPMessage | |||
71 | }; | 94 | }; |
72 | 95 | ||
73 | 96 | ||
74 | /** | 97 | /* Forward definition */ |
75 | * Network format for IPv4 addresses. | 98 | struct Plugin; |
76 | */ | 99 | |
77 | struct IPv4UdpAddress | 100 | struct PrettyPrinterContext |
101 | { | ||
102 | GNUNET_TRANSPORT_AddressStringCallback asc; | ||
103 | void *asc_cls; | ||
104 | uint16_t port; | ||
105 | }; | ||
106 | |||
107 | struct MessageQueue | ||
78 | { | 108 | { |
79 | /** | 109 | /** |
80 | * IPv4 address, in network byte order. | 110 | * Linked List |
111 | */ | ||
112 | struct MessageQueue *next; | ||
113 | |||
114 | /** | ||
115 | * Session this message belongs to | ||
116 | */ | ||
117 | struct PeerSession *session; | ||
118 | |||
119 | /** | ||
120 | * Actual message to be sent | ||
121 | */ | ||
122 | char *msgbuf; | ||
123 | |||
124 | /** | ||
125 | * Size of message buffer to be sent | ||
81 | */ | 126 | */ |
82 | uint32_t ipv4_addr; | 127 | size_t msgbuf_size; |
83 | 128 | ||
84 | /** | 129 | /** |
85 | * Port number, in network byte order. | 130 | * When to discard this message |
86 | */ | 131 | */ |
87 | uint16_t u_port; | 132 | struct GNUNET_TIME_Absolute timeout; |
133 | |||
134 | /** | ||
135 | * Continuation to call when this message goes out | ||
136 | */ | ||
137 | GNUNET_TRANSPORT_TransmitContinuation cont; | ||
138 | |||
139 | /** | ||
140 | * closure for continuation | ||
141 | */ | ||
142 | void *cont_cls; | ||
88 | 143 | ||
89 | }; | 144 | }; |
90 | 145 | ||
146 | /** | ||
147 | * UDP NAT Probe message definition | ||
148 | */ | ||
149 | struct UDP_NAT_ProbeMessage | ||
150 | { | ||
151 | /** | ||
152 | * Message header | ||
153 | */ | ||
154 | struct GNUNET_MessageHeader header; | ||
155 | |||
156 | }; | ||
91 | 157 | ||
92 | /** | 158 | /** |
93 | * Network format for IPv6 addresses. | 159 | * UDP NAT Probe message reply definition |
94 | */ | 160 | */ |
95 | struct IPv6UdpAddress | 161 | struct UDP_NAT_ProbeMessageReply |
96 | { | 162 | { |
97 | /** | 163 | /** |
98 | * IPv6 address. | 164 | * Message header |
99 | */ | 165 | */ |
100 | struct in6_addr ipv6_addr; | 166 | struct GNUNET_MessageHeader header; |
167 | |||
168 | }; | ||
169 | |||
101 | 170 | ||
171 | /** | ||
172 | * UDP NAT Probe message confirm definition | ||
173 | */ | ||
174 | struct UDP_NAT_ProbeMessageConfirmation | ||
175 | { | ||
102 | /** | 176 | /** |
103 | * Port number, in network byte order. | 177 | * Message header |
104 | */ | 178 | */ |
105 | uint16_t u6_port; | 179 | struct GNUNET_MessageHeader header; |
106 | 180 | ||
107 | }; | 181 | }; |
108 | 182 | ||
109 | 183 | ||
184 | |||
110 | /** | 185 | /** |
111 | * | 186 | * UDP NAT "Session" |
112 | */ | 187 | */ |
113 | struct PrettyPrinterContext | 188 | struct PeerSession |
114 | { | 189 | { |
190 | |||
115 | /** | 191 | /** |
116 | * | 192 | * Stored in a linked list. |
117 | */ | 193 | */ |
118 | GNUNET_TRANSPORT_AddressStringCallback asc; | 194 | struct PeerSession *next; |
119 | 195 | ||
120 | /** | 196 | /** |
121 | * Closure for 'asc'. | 197 | * Pointer to the global plugin struct. |
122 | */ | 198 | */ |
123 | void *asc_cls; | 199 | struct Plugin *plugin; |
124 | 200 | ||
125 | /** | 201 | /** |
126 | * | 202 | * To whom are we talking to (set to our identity |
203 | * if we are still waiting for the welcome message) | ||
127 | */ | 204 | */ |
128 | uint16_t port; | 205 | struct GNUNET_PeerIdentity target; |
206 | |||
207 | /** | ||
208 | * Address of the other peer (either based on our 'connect' | ||
209 | * call or on our 'accept' call). | ||
210 | */ | ||
211 | void *connect_addr; | ||
212 | |||
213 | /** | ||
214 | * Length of connect_addr. | ||
215 | */ | ||
216 | size_t connect_alen; | ||
217 | |||
218 | /** | ||
219 | * Are we still expecting the welcome message? (GNUNET_YES/GNUNET_NO) | ||
220 | */ | ||
221 | int expecting_welcome; | ||
222 | |||
223 | /** | ||
224 | * From which socket do we need to send to this peer? | ||
225 | */ | ||
226 | struct GNUNET_NETWORK_Handle *sock; | ||
227 | |||
228 | /* | ||
229 | * Queue of messages for this peer, in the case that | ||
230 | * we have to await a connection... | ||
231 | */ | ||
232 | struct MessageQueue *messages; | ||
233 | |||
234 | }; | ||
235 | |||
236 | struct UDP_NAT_Probes | ||
237 | { | ||
238 | |||
239 | /** | ||
240 | * Linked list | ||
241 | */ | ||
242 | struct UDP_NAT_Probes *next; | ||
243 | |||
244 | /** | ||
245 | * Address string that the server process returned to us | ||
246 | */ | ||
247 | char *address_string; | ||
248 | |||
249 | /** | ||
250 | * Timeout for this set of probes | ||
251 | */ | ||
252 | struct GNUNET_TIME_Absolute timeout; | ||
253 | |||
254 | /** | ||
255 | * Count of how many probes we've attempted | ||
256 | */ | ||
257 | int count; | ||
258 | |||
259 | /** | ||
260 | * The plugin this probe belongs to | ||
261 | */ | ||
262 | struct Plugin *plugin; | ||
263 | |||
264 | /** | ||
265 | * The task used to send these probes | ||
266 | */ | ||
267 | GNUNET_SCHEDULER_TaskIdentifier task; | ||
268 | |||
269 | /** | ||
270 | * Network address (always ipv4) | ||
271 | */ | ||
272 | struct sockaddr_in sock_addr; | ||
273 | |||
274 | /** | ||
275 | * The port to send this probe to, 0 to choose randomly | ||
276 | */ | ||
277 | int port; | ||
278 | |||
129 | }; | 279 | }; |
130 | 280 | ||
131 | 281 | ||
@@ -144,218 +294,428 @@ struct Plugin | |||
144 | */ | 294 | */ |
145 | struct GNUNET_SERVICE_Context *service; | 295 | struct GNUNET_SERVICE_Context *service; |
146 | 296 | ||
297 | /* | ||
298 | * Session of peers with whom we are currently connected | ||
299 | */ | ||
300 | struct PeerSession *sessions; | ||
301 | |||
147 | /** | 302 | /** |
148 | * Handle for request of hostname resolution, non-NULL if pending. | 303 | * Handle for request of hostname resolution, non-NULL if pending. |
149 | */ | 304 | */ |
150 | struct GNUNET_RESOLVER_RequestHandle *hostname_dns; | 305 | struct GNUNET_RESOLVER_RequestHandle *hostname_dns; |
151 | 306 | ||
152 | /** | 307 | /** |
308 | * ID of task used to update our addresses when one expires. | ||
309 | */ | ||
310 | GNUNET_SCHEDULER_TaskIdentifier address_update_task; | ||
311 | |||
312 | /** | ||
313 | * ID of select task | ||
314 | */ | ||
315 | GNUNET_SCHEDULER_TaskIdentifier select_task; | ||
316 | |||
317 | /** | ||
318 | * Port to listen on. | ||
319 | */ | ||
320 | uint16_t port; | ||
321 | |||
322 | /** | ||
323 | * The external address given to us by the user. Must be actual | ||
324 | * outside visible address for NAT punching to work. | ||
325 | */ | ||
326 | char *external_address; | ||
327 | |||
328 | /** | ||
329 | * The internal address given to us by the user (or discovered). | ||
330 | */ | ||
331 | char *internal_address; | ||
332 | |||
333 | /* | ||
153 | * FD Read set | 334 | * FD Read set |
154 | */ | 335 | */ |
155 | struct GNUNET_NETWORK_FDSet *rs; | 336 | struct GNUNET_NETWORK_FDSet *rs; |
156 | 337 | ||
338 | /* | ||
339 | * stdout pipe handle for the gnunet-nat-server process | ||
340 | */ | ||
341 | struct GNUNET_DISK_PipeHandle *server_stdout; | ||
342 | |||
343 | /* | ||
344 | * stdout file handle (for reading) for the gnunet-nat-server process | ||
345 | */ | ||
346 | const struct GNUNET_DISK_FileHandle *server_stdout_handle; | ||
347 | |||
157 | /** | 348 | /** |
158 | * ID of task used to update our addresses when one expires. | 349 | * ID of select gnunet-nat-server stdout read task |
159 | */ | 350 | */ |
160 | GNUNET_SCHEDULER_TaskIdentifier address_update_task; | 351 | GNUNET_SCHEDULER_TaskIdentifier server_read_task; |
161 | 352 | ||
162 | /** | 353 | /** |
163 | * ID of select task | 354 | * Is this transport configured to be behind a NAT? |
164 | */ | 355 | */ |
165 | GNUNET_SCHEDULER_TaskIdentifier select_task; | 356 | int behind_nat; |
166 | 357 | ||
167 | /** | 358 | /** |
168 | * Port that we are actually listening on. | 359 | * The process id of the server process (if behind NAT) |
169 | */ | 360 | */ |
170 | uint16_t open_port; | 361 | pid_t server_pid; |
171 | 362 | ||
172 | /** | 363 | /** |
173 | * Port that the user said we would have visible to the | 364 | * Probes in flight |
174 | * rest of the world. | ||
175 | */ | 365 | */ |
176 | uint16_t adv_port; | 366 | struct UDP_NAT_Probes *probes; |
367 | |||
368 | }; | ||
369 | |||
177 | 370 | ||
371 | struct UDP_Sock_Info | ||
372 | { | ||
373 | /* The network handle */ | ||
374 | struct GNUNET_NETWORK_Handle *desc; | ||
375 | |||
376 | /* The port we bound to */ | ||
377 | int port; | ||
178 | }; | 378 | }; |
179 | 379 | ||
180 | /* *********** globals ************* */ | 380 | /* *********** globals ************* */ |
181 | 381 | ||
182 | /** | 382 | /** |
183 | * The socket that we transmit all data with | 383 | * the socket that we transmit all data with |
384 | */ | ||
385 | static struct UDP_Sock_Info udp_sock; | ||
386 | |||
387 | |||
388 | /** | ||
389 | * Forward declaration. | ||
184 | */ | 390 | */ |
185 | static struct GNUNET_NETWORK_Handle *udp_sock; | 391 | void |
392 | udp_probe_continuation (void *cls, const struct GNUNET_PeerIdentity *target, int result); | ||
393 | |||
186 | 394 | ||
187 | /** | 395 | /** |
188 | * Disconnect from a remote node. | 396 | * Disconnect from a remote node. Clean up session if we have one for this peer |
189 | * | 397 | * |
190 | * @param cls closure ('struct Plugin'), unused | 398 | * @param cls closure for this call (should be handle to Plugin) |
191 | * @param target peer do disconnect | 399 | * @param target the peeridentity of the peer to disconnect |
192 | * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed | 400 | * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed |
193 | */ | 401 | */ |
194 | void | 402 | void |
195 | udp_disconnect (void *cls, | 403 | udp_disconnect (void *cls, const struct GNUNET_PeerIdentity *target) |
196 | const struct GNUNET_PeerIdentity *target) | ||
197 | { | 404 | { |
198 | /* nothing to do, UDP is stateless */ | 405 | /** TODO: Implement! */ |
406 | return; | ||
199 | } | 407 | } |
200 | 408 | ||
201 | /** | 409 | /** |
202 | * Shutdown the server process (stop receiving inbound traffic). Maybe | 410 | * Shutdown the server process (stop receiving inbound traffic). Maybe |
203 | * restarted later! | 411 | * restarted later! |
204 | * | 412 | * |
205 | * @param cls closure, the 'struct Plugin*' | 413 | * @param cls Handle to the plugin for this transport |
414 | * | ||
415 | * @return returns the number of sockets successfully closed, | ||
416 | * should equal the number of sockets successfully opened | ||
206 | */ | 417 | */ |
207 | static int | 418 | static int |
208 | udp_transport_server_stop (void *cls) | 419 | udp_transport_server_stop (void *cls) |
209 | { | 420 | { |
210 | struct Plugin *plugin = cls; | 421 | struct Plugin *plugin = cls; |
211 | int ret; | 422 | int ret; |
423 | int ok; | ||
212 | 424 | ||
213 | GNUNET_assert (udp_sock != NULL); | 425 | ret = 0; |
214 | if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK) | 426 | if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK) |
215 | { | 427 | { |
216 | GNUNET_SCHEDULER_cancel (plugin->env->sched, plugin->select_task); | 428 | GNUNET_SCHEDULER_cancel (plugin->env->sched, plugin->select_task); |
217 | plugin->select_task = GNUNET_SCHEDULER_NO_TASK; | 429 | plugin->select_task = GNUNET_SCHEDULER_NO_TASK; |
218 | } | 430 | } |
219 | 431 | ||
220 | ret = GNUNET_NETWORK_socket_close (udp_sock); | 432 | |
221 | if (ret != GNUNET_SYSERR) | 433 | ok = GNUNET_NETWORK_socket_close (udp_sock.desc); |
222 | udp_sock = NULL; | 434 | if (ok == GNUNET_OK) |
435 | udp_sock.desc = NULL; | ||
436 | ret += ok; | ||
437 | |||
438 | |||
439 | if (plugin->behind_nat == GNUNET_YES) | ||
440 | { | ||
441 | if (0 != PLIBC_KILL (plugin->server_pid, SIGTERM)) | ||
442 | { | ||
443 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | ||
444 | } | ||
445 | GNUNET_OS_process_wait (plugin->server_pid); | ||
446 | } | ||
447 | |||
448 | if (ret != GNUNET_OK) | ||
449 | return GNUNET_SYSERR; | ||
223 | return ret; | 450 | return ret; |
224 | } | 451 | } |
225 | 452 | ||
453 | |||
454 | struct PeerSession * | ||
455 | find_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *peer) | ||
456 | { | ||
457 | struct PeerSession *pos; | ||
458 | |||
459 | pos = plugin->sessions; | ||
460 | while (pos != NULL) | ||
461 | { | ||
462 | if (memcmp(&pos->target, peer, sizeof(struct GNUNET_PeerIdentity)) == 0) | ||
463 | return pos; | ||
464 | pos = pos->next; | ||
465 | } | ||
466 | |||
467 | return pos; | ||
468 | } | ||
469 | |||
470 | |||
226 | /** | 471 | /** |
227 | * Function that can be used by the transport service to transmit | 472 | * Actually send out the message, assume we've got the address and |
228 | * a message using the plugin. | 473 | * send_handle squared away! |
229 | * | 474 | * |
230 | * @param cls closure, the 'struct Plugin*' | 475 | * @param cls closure |
476 | * @param send_handle which handle to send message on | ||
231 | * @param target who should receive this message (ignored by UDP) | 477 | * @param target who should receive this message (ignored by UDP) |
232 | * @param msgbuf one or more GNUNET_MessageHeader(s) strung together | 478 | * @param msgbuf one or more GNUNET_MessageHeader(s) strung together |
233 | * @param msgbuf_size the size of the msgbuf to send | 479 | * @param msgbuf_size the size of the msgbuf to send |
234 | * @param priority how important is the message (ignored by UDP) | 480 | * @param priority how important is the message (ignored by UDP) |
235 | * @param timeout when should we time out (give up) if we can not transmit? | 481 | * @param timeout when should we time out (give up) if we can not transmit? |
236 | * @param session which session must be used (always NULL for UDP) | ||
237 | * @param addr the addr to send the message to, needs to be a sockaddr for us | 482 | * @param addr the addr to send the message to, needs to be a sockaddr for us |
238 | * @param addrlen the len of addr | 483 | * @param addrlen the len of addr |
239 | * @param force_address GNUNET_YES if the plugin MUST use the given address, | ||
240 | * GNUNET_NO means the plugin may use any other address and | ||
241 | * GNUNET_SYSERR means that only reliable existing | ||
242 | * bi-directional connections should be used (regardless | ||
243 | * of address) | ||
244 | * @param cont continuation to call once the message has | 484 | * @param cont continuation to call once the message has |
245 | * been transmitted (or if the transport is ready | 485 | * been transmitted (or if the transport is ready |
246 | * for the next transmission call; or if the | 486 | * for the next transmission call; or if the |
247 | * peer disconnected...) | 487 | * peer disconnected...) |
248 | * @param cont_cls closure for cont | 488 | * @param cont_cls closure for cont |
249 | * | 489 | * @return the number of bytes written |
250 | * @return the number of bytes written, -1 on error (in this case, cont is not called) | ||
251 | */ | 490 | */ |
252 | static ssize_t | 491 | static ssize_t |
253 | udp_plugin_send (void *cls, | 492 | udp_real_send (void *cls, |
254 | const struct GNUNET_PeerIdentity *target, | 493 | struct GNUNET_NETWORK_Handle *send_handle, |
255 | const char *msgbuf, | 494 | const struct GNUNET_PeerIdentity *target, |
256 | size_t msgbuf_size, | 495 | const char *msgbuf, |
257 | unsigned int priority, | 496 | size_t msgbuf_size, |
258 | struct GNUNET_TIME_Relative timeout, | 497 | unsigned int priority, |
259 | struct Session *session, | 498 | struct GNUNET_TIME_Relative timeout, |
260 | const void *addr, | 499 | const void *addr, |
261 | size_t addrlen, | 500 | size_t addrlen, |
262 | int force_address, | 501 | GNUNET_TRANSPORT_TransmitContinuation cont, |
263 | GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) | 502 | void *cont_cls) |
264 | { | 503 | { |
265 | struct Plugin *plugin = cls; | 504 | struct Plugin *plugin = cls; |
266 | struct UDPMessage *message; | 505 | struct UDPMessage *message; |
267 | int ssize; | 506 | int ssize; |
268 | ssize_t sent; | 507 | ssize_t sent; |
269 | const void *sb; | ||
270 | size_t sbs; | ||
271 | struct sockaddr_in a4; | ||
272 | struct sockaddr_in6 a6; | ||
273 | const struct IPv4UdpAddress *t4; | ||
274 | const struct IPv6UdpAddress *t6; | ||
275 | 508 | ||
276 | GNUNET_assert (NULL == session); | 509 | if ((addr == NULL) || (addrlen == 0)) |
277 | GNUNET_assert(udp_sock != NULL); | ||
278 | if ( (addr == NULL) || (addrlen == 0) ) | ||
279 | { | 510 | { |
280 | #if DEBUG_UDP | 511 | #if DEBUG_UDP_NAT |
281 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | 512 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ |
282 | ("udp_plugin_send called without address, returning!\n")); | 513 | ("udp_plugin_send called without address, returning!\n")); |
283 | #endif | 514 | #endif |
284 | return -1; /* Can never send if we don't have an address!! */ | 515 | cont (cont_cls, target, GNUNET_SYSERR); |
285 | } | 516 | return 0; /* Can never send if we don't have an address!! */ |
286 | if (force_address == GNUNET_SYSERR) | ||
287 | return -1; /* never reliable */ | ||
288 | |||
289 | if (addrlen == sizeof (struct IPv6UdpAddress)) | ||
290 | { | ||
291 | t6 = addr; | ||
292 | memset (&a6, 0, sizeof (a6)); | ||
293 | #if HAVE_SOCKADDR_IN_SIN_LEN | ||
294 | a6.sin6_len = sizeof (a6); | ||
295 | #endif | ||
296 | a6.sin6_family = AF_INET6; | ||
297 | a6.sin6_port = t6->u6_port; | ||
298 | memcpy (&a6.sin6_addr, | ||
299 | &t6->ipv6_addr, | ||
300 | sizeof (struct in6_addr)); | ||
301 | sb = &a6; | ||
302 | sbs = sizeof (a6); | ||
303 | } | ||
304 | else if (addrlen == sizeof (struct IPv4UdpAddress)) | ||
305 | { | ||
306 | t4 = addr; | ||
307 | memset (&a4, 0, sizeof (a4)); | ||
308 | #if HAVE_SOCKADDR_IN_SIN_LEN | ||
309 | a4.sin_len = sizeof (a4); | ||
310 | #endif | ||
311 | a4.sin_family = AF_INET; | ||
312 | a4.sin_port = t4->u_port; | ||
313 | a4.sin_addr.s_addr = t4->ipv4_addr; | ||
314 | sb = &a4; | ||
315 | sbs = sizeof (a4); | ||
316 | } | ||
317 | else | ||
318 | { | ||
319 | GNUNET_break_op (0); | ||
320 | return -1; | ||
321 | } | 517 | } |
322 | 518 | ||
323 | /* Build the message to be sent */ | 519 | /* Build the message to be sent */ |
324 | message = GNUNET_malloc (sizeof (struct UDPMessage) + msgbuf_size); | 520 | message = GNUNET_malloc (sizeof (struct UDPMessage) + msgbuf_size); |
325 | ssize = sizeof (struct UDPMessage) + msgbuf_size; | 521 | ssize = sizeof (struct UDPMessage) + msgbuf_size; |
326 | 522 | ||
327 | #if DEBUG_UDP | ||
328 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", | ||
329 | "In udp_send, ssize is %d, sending message to `%s'\n", | ||
330 | ssize, | ||
331 | GNUNET_a2s(sb, sbs)); | ||
332 | #endif | ||
333 | message->header.size = htons (ssize); | 523 | message->header.size = htons (ssize); |
334 | message->header.type = htons (0); | 524 | message->header.type = htons (0); |
335 | memcpy (&message->sender, plugin->env->my_identity, | 525 | memcpy (&message->sender, plugin->env->my_identity, |
336 | sizeof (struct GNUNET_PeerIdentity)); | 526 | sizeof (struct GNUNET_PeerIdentity)); |
337 | memcpy (&message[1], msgbuf, msgbuf_size); | 527 | memcpy (&message[1], msgbuf, msgbuf_size); |
528 | |||
529 | /* Actually send the message */ | ||
338 | sent = | 530 | sent = |
339 | GNUNET_NETWORK_socket_sendto (udp_sock, message, ssize, | 531 | GNUNET_NETWORK_socket_sendto (send_handle, message, ssize, |
340 | sb, sbs); | 532 | addr, |
341 | if ( (cont != NULL) && | 533 | addrlen); |
342 | (sent != -1) ) | 534 | |
343 | cont (cont_cls, target, GNUNET_OK); | 535 | if (cont != NULL) |
536 | { | ||
537 | if (sent == GNUNET_SYSERR) | ||
538 | cont (cont_cls, target, GNUNET_SYSERR); | ||
539 | else | ||
540 | { | ||
541 | cont (cont_cls, target, GNUNET_OK); | ||
542 | } | ||
543 | } | ||
544 | |||
344 | GNUNET_free (message); | 545 | GNUNET_free (message); |
345 | return sent; | 546 | return sent; |
346 | } | 547 | } |
347 | 548 | ||
549 | /** | ||
550 | * We learned about a peer (possibly behind NAT) so run the | ||
551 | * gnunet-nat-client to send dummy ICMP responses | ||
552 | * | ||
553 | * @param plugin the plugin for this transport | ||
554 | * @param addr the address of the peer | ||
555 | * @param addrlen the length of the address | ||
556 | */ | ||
557 | void | ||
558 | run_gnunet_nat_client (struct Plugin *plugin, const char *addr, size_t addrlen) | ||
559 | { | ||
560 | char inet4[INET_ADDRSTRLEN]; | ||
561 | char *address_as_string; | ||
562 | char *port_as_string; | ||
563 | pid_t pid; | ||
564 | const struct sockaddr *sa = (const struct sockaddr *)addr; | ||
565 | |||
566 | if (addrlen < sizeof (struct sockaddr)) | ||
567 | return; | ||
568 | switch (sa->sa_family) | ||
569 | { | ||
570 | case AF_INET: | ||
571 | if (addrlen != sizeof (struct sockaddr_in)) | ||
572 | return; | ||
573 | inet_ntop (AF_INET, | ||
574 | &((struct sockaddr_in *) sa)->sin_addr, | ||
575 | inet4, INET_ADDRSTRLEN); | ||
576 | address_as_string = GNUNET_strdup (inet4); | ||
577 | break; | ||
578 | case AF_INET6: | ||
579 | default: | ||
580 | return; | ||
581 | } | ||
582 | |||
583 | GNUNET_asprintf(&port_as_string, "%d", plugin->port); | ||
584 | #if DEBUG_UDP_NAT | ||
585 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
586 | _("Running gnunet-nat-client with arguments: %s %s %d\n"), plugin->external_address, address_as_string, plugin->port); | ||
587 | #endif | ||
588 | /* Start the server process */ | ||
589 | pid = GNUNET_OS_start_process(NULL, NULL, "gnunet-nat-client", "gnunet-nat-client", plugin->external_address, address_as_string, port_as_string, NULL); | ||
590 | GNUNET_free(address_as_string); | ||
591 | GNUNET_free(port_as_string); | ||
592 | GNUNET_OS_process_wait (pid); | ||
593 | } | ||
594 | |||
595 | /** | ||
596 | * Function that can be used by the transport service to transmit | ||
597 | * a message using the plugin. | ||
598 | * | ||
599 | * @param cls closure | ||
600 | * @param target who should receive this message (ignored by UDP) | ||
601 | * @param msgbuf one or more GNUNET_MessageHeader(s) strung together | ||
602 | * @param msgbuf_size the size of the msgbuf to send | ||
603 | * @param priority how important is the message (ignored by UDP) | ||
604 | * @param timeout when should we time out (give up) if we can not transmit? | ||
605 | * @param session identifier used for this session (can be NULL) | ||
606 | * @param addr the addr to send the message to, needs to be a sockaddr for us | ||
607 | * @param addrlen the len of addr | ||
608 | * @param force_address not used, we had better have an address to send to | ||
609 | * because we are stateless!! | ||
610 | * @param cont continuation to call once the message has | ||
611 | * been transmitted (or if the transport is ready | ||
612 | * for the next transmission call; or if the | ||
613 | * peer disconnected...) | ||
614 | * @param cont_cls closure for cont | ||
615 | * | ||
616 | * @return the number of bytes written (may return 0 and the message can | ||
617 | * still be transmitted later!) | ||
618 | */ | ||
619 | static ssize_t | ||
620 | udp_plugin_send (void *cls, | ||
621 | const struct GNUNET_PeerIdentity *target, | ||
622 | const char *msgbuf, | ||
623 | size_t msgbuf_size, | ||
624 | unsigned int priority, | ||
625 | struct GNUNET_TIME_Relative timeout, | ||
626 | struct Session *session, | ||
627 | const void *addr, | ||
628 | size_t addrlen, | ||
629 | int force_address, | ||
630 | GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) | ||
631 | { | ||
632 | struct Plugin *plugin = cls; | ||
633 | ssize_t sent; | ||
634 | struct MessageQueue *temp_message; | ||
635 | struct PeerSession *peer_session; | ||
636 | struct sockaddr_in *sockaddr = (struct sockaddr_in *)addr; | ||
637 | int other_peer_natd; | ||
638 | |||
639 | GNUNET_assert (NULL == session); | ||
640 | other_peer_natd = GNUNET_NO; | ||
641 | if ((sockaddr->sin_family == AF_INET) && (ntohs(sockaddr->sin_port) == 0)) | ||
642 | { | ||
643 | other_peer_natd = GNUNET_YES; | ||
644 | } | ||
645 | |||
646 | sent = 0; | ||
647 | |||
648 | if (other_peer_natd == GNUNET_YES) | ||
649 | { | ||
650 | peer_session = find_session(plugin, target); | ||
651 | if (peer_session == NULL) /* We have a new peer to add */ | ||
652 | { | ||
653 | /* | ||
654 | * The first time, we can assume we have no knowledge of a | ||
655 | * working port for this peer, call the ICMP/UDP message sender | ||
656 | * and wait... | ||
657 | */ | ||
658 | peer_session = GNUNET_malloc(sizeof(struct PeerSession)); | ||
659 | peer_session->connect_addr = GNUNET_malloc(addrlen); | ||
660 | memcpy(peer_session->connect_addr, addr, addrlen); | ||
661 | peer_session->connect_alen = addrlen; | ||
662 | peer_session->plugin = plugin; | ||
663 | peer_session->sock = NULL; | ||
664 | memcpy(&peer_session->target, target, sizeof(struct GNUNET_PeerIdentity)); | ||
665 | peer_session->expecting_welcome = GNUNET_YES; | ||
666 | |||
667 | peer_session->next = plugin->sessions; | ||
668 | plugin->sessions = peer_session; | ||
669 | |||
670 | peer_session->messages = GNUNET_malloc(sizeof(struct MessageQueue)); | ||
671 | peer_session->messages->msgbuf = GNUNET_malloc(msgbuf_size); | ||
672 | memcpy(peer_session->messages->msgbuf, msgbuf, msgbuf_size); | ||
673 | peer_session->messages->msgbuf_size = msgbuf_size; | ||
674 | peer_session->messages->next = NULL; | ||
675 | peer_session->messages->timeout = GNUNET_TIME_relative_to_absolute(timeout); | ||
676 | peer_session->messages->cont = cont; | ||
677 | peer_session->messages->cont_cls = cont_cls; | ||
678 | #if DEBUG_UDP_NAT | ||
679 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
680 | _("Other peer is NAT'd, set up peer session for peer %s\n"), GNUNET_i2s(target)); | ||
681 | #endif | ||
682 | run_gnunet_nat_client(plugin, addr, addrlen); | ||
683 | } | ||
684 | else | ||
685 | { | ||
686 | if (peer_session->expecting_welcome == GNUNET_NO) /* We are "connected" */ | ||
687 | { | ||
688 | sent = udp_real_send(cls, peer_session->sock, target, msgbuf, msgbuf_size, priority, timeout, peer_session->connect_addr, peer_session->connect_alen, cont, cont_cls); | ||
689 | } | ||
690 | else /* Haven't gotten a response from this peer, queue message */ | ||
691 | { | ||
692 | temp_message = GNUNET_malloc(sizeof(struct MessageQueue)); | ||
693 | temp_message->msgbuf = GNUNET_malloc(msgbuf_size); | ||
694 | memcpy(temp_message->msgbuf, msgbuf, msgbuf_size); | ||
695 | temp_message->msgbuf_size = msgbuf_size; | ||
696 | temp_message->timeout = GNUNET_TIME_relative_to_absolute(timeout); | ||
697 | temp_message->cont = cont; | ||
698 | temp_message->cont_cls = cont_cls; | ||
699 | temp_message->next = peer_session->messages; | ||
700 | peer_session->messages = temp_message; | ||
701 | } | ||
702 | } | ||
703 | } | ||
704 | else /* Other peer not behind a NAT, so we can just send the message as is */ | ||
705 | { | ||
706 | sent = udp_real_send(cls, udp_sock.desc, target, msgbuf, msgbuf_size, priority, timeout, addr, addrlen, cont, cont_cls); | ||
707 | } | ||
708 | |||
709 | if (sent == GNUNET_SYSERR) | ||
710 | return 0; | ||
711 | |||
712 | return sent; | ||
713 | } | ||
714 | |||
348 | 715 | ||
349 | /** | 716 | /** |
350 | * Add the IP of our network interface to the list of | 717 | * Add the IP of our network interface to the list of |
351 | * our external IP addresses. | 718 | * our external IP addresses. |
352 | * | ||
353 | * @param cls closure (the 'struct Plugin*') | ||
354 | * @param name name of the interface (can be NULL for unknown) | ||
355 | * @param isDefault is this presumably the default interface | ||
356 | * @param addr address of this interface (can be NULL for unknown or unassigned) | ||
357 | * @param addrlen length of the address | ||
358 | * @return GNUNET_OK to continue iterating | ||
359 | */ | 719 | */ |
360 | static int | 720 | static int |
361 | process_interfaces (void *cls, | 721 | process_interfaces (void *cls, |
@@ -365,47 +725,39 @@ process_interfaces (void *cls, | |||
365 | { | 725 | { |
366 | struct Plugin *plugin = cls; | 726 | struct Plugin *plugin = cls; |
367 | int af; | 727 | int af; |
368 | struct IPv4UdpAddress t4; | 728 | struct sockaddr_in *v4; |
369 | struct IPv6UdpAddress t6; | 729 | struct sockaddr_in6 *v6; |
370 | void *arg; | ||
371 | uint16_t args; | ||
372 | 730 | ||
373 | af = addr->sa_family; | 731 | af = addr->sa_family; |
374 | if (af == AF_INET) | 732 | if (af == AF_INET) |
375 | { | 733 | { |
376 | t4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr; | 734 | v4 = (struct sockaddr_in *) addr; |
377 | t4.u_port = htons (plugin->adv_port); | 735 | if (plugin->behind_nat == GNUNET_YES) |
378 | arg = &t4; | 736 | { |
379 | args = sizeof (t4); | 737 | GNUNET_assert(inet_pton(AF_INET, plugin->external_address, &v4->sin_addr) == GNUNET_OK); |
380 | } | 738 | v4->sin_port = htons (0); /* Indicates to receiver we are behind NAT */ |
381 | else if (af == AF_INET6) | 739 | } |
382 | { | 740 | else |
383 | if (IN6_IS_ADDR_LINKLOCAL (&((struct sockaddr_in6 *) addr)->sin6_addr)) | 741 | v4->sin_port = htons (plugin->port); |
384 | { | ||
385 | /* skip link local addresses */ | ||
386 | return GNUNET_OK; | ||
387 | } | ||
388 | memcpy (&t6.ipv6_addr, | ||
389 | &((struct sockaddr_in6 *) addr)->sin6_addr, | ||
390 | sizeof (struct in6_addr)); | ||
391 | t6.u6_port = htons (plugin->adv_port); | ||
392 | arg = &t6; | ||
393 | args = sizeof (t6); | ||
394 | } | 742 | } |
395 | else | 743 | else |
396 | { | 744 | { |
397 | GNUNET_break (0); | 745 | GNUNET_assert (af == AF_INET6); |
398 | return GNUNET_OK; | 746 | v6 = (struct sockaddr_in6 *) addr; |
399 | } | 747 | if (plugin->behind_nat == GNUNET_YES) |
400 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO | | 748 | v6->sin6_port = htons (0); |
401 | GNUNET_ERROR_TYPE_BULK, | 749 | else |
402 | "udp", | 750 | v6->sin6_port = htons (plugin->port); |
403 | _("Found address `%s' (%s)\n"), | 751 | } |
404 | GNUNET_a2s (addr, addrlen), | 752 | |
405 | name); | 753 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO | |
406 | plugin->env->notify_address (plugin->env->cls, | 754 | GNUNET_ERROR_TYPE_BULK, |
407 | "udp", | 755 | "udp", _("Found address `%s' (%s)\n"), |
408 | arg, args, GNUNET_TIME_UNIT_FOREVER_REL); | 756 | GNUNET_a2s (addr, addrlen), name); |
757 | plugin->env->notify_address (plugin->env->cls, | ||
758 | "udp", | ||
759 | addr, addrlen, GNUNET_TIME_UNIT_FOREVER_REL); | ||
760 | |||
409 | return GNUNET_OK; | 761 | return GNUNET_OK; |
410 | } | 762 | } |
411 | 763 | ||
@@ -434,15 +786,363 @@ process_hostname_ips (void *cls, | |||
434 | } | 786 | } |
435 | 787 | ||
436 | 788 | ||
789 | /** | ||
790 | * Send UDP probe messages or UDP keepalive messages, depending on the | ||
791 | * state of the connection. | ||
792 | * | ||
793 | * @param cls closure for this call (should be the main Plugin) | ||
794 | * @param tc task context for running this | ||
795 | */ | ||
796 | static void | ||
797 | send_udp_probe_message (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
798 | { | ||
799 | struct UDP_NAT_Probes *probe = cls; | ||
800 | struct UDP_NAT_ProbeMessage *message; | ||
801 | struct Plugin *plugin = probe->plugin; | ||
802 | |||
803 | message = GNUNET_malloc(sizeof(struct UDP_NAT_ProbeMessage)); | ||
804 | message->header.size = htons(sizeof(struct UDP_NAT_ProbeMessage)); | ||
805 | message->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE); | ||
806 | /* If they gave us a port, use that. If not, try our port. */ | ||
807 | if (probe->port != 0) | ||
808 | probe->sock_addr.sin_port = htons(probe->port); | ||
809 | else | ||
810 | probe->sock_addr.sin_port = htons(plugin->port); | ||
811 | |||
812 | #if DEBUG_UDP_NAT | ||
813 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
814 | _("Sending a probe to port %d\n"), ntohs(probe->sock_addr.sin_port)); | ||
815 | #endif | ||
816 | |||
817 | probe->count++; | ||
818 | |||
819 | udp_real_send(plugin, udp_sock.desc, NULL, | ||
820 | (char *)message, ntohs(message->header.size), 0, | ||
821 | GNUNET_TIME_relative_get_unit(), | ||
822 | &probe->sock_addr, sizeof(probe->sock_addr), | ||
823 | &udp_probe_continuation, probe); | ||
824 | |||
825 | GNUNET_free(message); | ||
826 | } | ||
827 | |||
828 | |||
829 | /** | ||
830 | * Continuation for probe sends. If the last probe was sent | ||
831 | * "successfully", schedule sending of another one. If not, | ||
832 | * | ||
833 | */ | ||
834 | void | ||
835 | udp_probe_continuation (void *cls, const struct GNUNET_PeerIdentity *target, int result) | ||
836 | { | ||
837 | struct UDP_NAT_Probes *probe = cls; | ||
838 | struct Plugin *plugin = probe->plugin; | ||
839 | |||
840 | if ((result == GNUNET_OK) && (probe->count < MAX_PROBES)) | ||
841 | { | ||
842 | #if DEBUG_UDP_NAT | ||
843 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
844 | _("Scheduling next probe for 10000 milliseconds\n")); | ||
845 | #endif | ||
846 | probe->task = GNUNET_SCHEDULER_add_delayed(plugin->env->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 10000), &send_udp_probe_message, probe); | ||
847 | } | ||
848 | else /* Destroy the probe context. */ | ||
849 | { | ||
850 | #if DEBUG_UDP_NAT | ||
851 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
852 | _("Sending probe didn't go well...\n")); | ||
853 | #endif | ||
854 | } | ||
855 | } | ||
856 | |||
857 | /** | ||
858 | * Find probe message by address | ||
859 | * | ||
860 | * @param plugin the plugin for this transport | ||
861 | * @param address_string the ip address as a string | ||
862 | */ | ||
863 | struct UDP_NAT_Probes * | ||
864 | find_probe(struct Plugin *plugin, char * address_string) | ||
865 | { | ||
866 | struct UDP_NAT_Probes *pos; | ||
867 | |||
868 | pos = plugin->probes; | ||
869 | while (pos != NULL) | ||
870 | if (strcmp(pos->address_string, address_string) == 0) | ||
871 | return pos; | ||
872 | |||
873 | return pos; | ||
874 | } | ||
875 | |||
876 | |||
437 | /* | 877 | /* |
438 | * @param cls the plugin handle | 878 | * @param cls the plugin handle |
439 | * @param tc the scheduling context (for rescheduling this function again) | 879 | * @param tc the scheduling context (for rescheduling this function again) |
440 | * | 880 | * |
441 | * We have been notified that our writeset has something to read. Presumably | 881 | * We have been notified that gnunet-nat-server has written something to stdout. |
442 | * select has been called already, so we can go ahead and start reading from | 882 | * Handle the output, then reschedule this function to be called again once |
443 | * the socket immediately. Then we check if there is more to be read by | 883 | * more is available. |
444 | * calling select ourselves while there is stuff on the wire. Then reschedule | 884 | * |
445 | * this function to be called again once more is available. | 885 | */ |
886 | static void | ||
887 | udp_plugin_server_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
888 | { | ||
889 | struct Plugin *plugin = cls; | ||
890 | char mybuf[40]; | ||
891 | ssize_t bytes; | ||
892 | memset(&mybuf, 0, sizeof(mybuf)); | ||
893 | int i; | ||
894 | struct UDP_NAT_Probes *temp_probe; | ||
895 | int port; | ||
896 | char *port_start; | ||
897 | bytes = GNUNET_DISK_file_read(plugin->server_stdout_handle, &mybuf, sizeof(mybuf)); | ||
898 | |||
899 | if (bytes < 1) | ||
900 | { | ||
901 | #if DEBUG_UDP_NAT | ||
902 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
903 | _("Finished reading from server stdout with code: %d\n"), bytes); | ||
904 | #endif | ||
905 | return; | ||
906 | } | ||
907 | |||
908 | port = 0; | ||
909 | port_start = NULL; | ||
910 | for (i = 0; i < sizeof(mybuf); i++) | ||
911 | { | ||
912 | if (mybuf[i] == '\n') | ||
913 | mybuf[i] = '\0'; | ||
914 | |||
915 | if ((mybuf[i] == ':') && (i + 1 < sizeof(mybuf))) | ||
916 | { | ||
917 | mybuf[i] = '\0'; | ||
918 | port_start = &mybuf[i + 1]; | ||
919 | } | ||
920 | } | ||
921 | |||
922 | if (port_start != NULL) | ||
923 | port = atoi(port_start); | ||
924 | |||
925 | #if DEBUG_UDP_NAT | ||
926 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
927 | _("nat-server-read read: %s port %d\n"), &mybuf, port); | ||
928 | #endif | ||
929 | |||
930 | /** We have received an ICMP response, ostensibly from a non-NAT'd peer | ||
931 | * that wants to connect to us! Send a message to establish a connection. | ||
932 | */ | ||
933 | temp_probe = find_probe(plugin, &mybuf[0]); | ||
934 | |||
935 | if (temp_probe == NULL) | ||
936 | { | ||
937 | temp_probe = GNUNET_malloc(sizeof(struct UDP_NAT_Probes)); | ||
938 | temp_probe->address_string = strdup(&mybuf[0]); | ||
939 | temp_probe->sock_addr.sin_family = AF_INET; | ||
940 | GNUNET_assert(inet_pton(AF_INET, &mybuf[0], &temp_probe->sock_addr.sin_addr) == 1); | ||
941 | temp_probe->port = port; | ||
942 | temp_probe->next = plugin->probes; | ||
943 | temp_probe->plugin = plugin; | ||
944 | temp_probe->task = GNUNET_SCHEDULER_add_delayed(plugin->env->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 500), &send_udp_probe_message, temp_probe); | ||
945 | plugin->probes = temp_probe; | ||
946 | } | ||
947 | |||
948 | plugin->server_read_task = | ||
949 | GNUNET_SCHEDULER_add_read_file (plugin->env->sched, | ||
950 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
951 | plugin->server_stdout_handle, &udp_plugin_server_read, plugin); | ||
952 | |||
953 | } | ||
954 | |||
955 | |||
956 | /** | ||
957 | * Demultiplexer for UDP NAT messages | ||
958 | * | ||
959 | * @param plugin the main plugin for this transport | ||
960 | * @param sender from which peer the message was received | ||
961 | * @param currhdr pointer to the header of the message | ||
962 | * @param sender_addr the address from which the message was received | ||
963 | * @param fromlen the length of the address | ||
964 | * @param sockinfo which socket did we receive the message on | ||
965 | */ | ||
966 | static void | ||
967 | udp_demultiplexer(struct Plugin *plugin, struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *currhdr, struct sockaddr_storage *sender_addr, socklen_t fromlen, struct UDP_Sock_Info *sockinfo) | ||
968 | { | ||
969 | struct UDP_NAT_ProbeMessageReply *outgoing_probe_reply; | ||
970 | struct UDP_NAT_ProbeMessageConfirmation *outgoing_probe_confirmation; | ||
971 | |||
972 | char addr_buf[INET_ADDRSTRLEN]; | ||
973 | struct UDP_NAT_Probes *outgoing_probe; | ||
974 | struct PeerSession *peer_session; | ||
975 | struct MessageQueue *pending_message; | ||
976 | struct MessageQueue *pending_message_temp; | ||
977 | |||
978 | if (memcmp(sender, plugin->env->my_identity, sizeof(struct GNUNET_PeerIdentity)) == 0) | ||
979 | { | ||
980 | #if DEBUG_UDP_NAT | ||
981 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
982 | _("Received a message from myself, dropping!!!\n")); | ||
983 | #endif | ||
984 | return; | ||
985 | } | ||
986 | |||
987 | switch (ntohs(currhdr->type)) | ||
988 | { | ||
989 | case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE: | ||
990 | /* Send probe reply */ | ||
991 | outgoing_probe_reply = GNUNET_malloc(sizeof(struct UDP_NAT_ProbeMessageReply)); | ||
992 | outgoing_probe_reply->header.size = htons(sizeof(struct UDP_NAT_ProbeMessageReply)); | ||
993 | outgoing_probe_reply->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_REPLY); | ||
994 | |||
995 | #if DEBUG_UDP_NAT | ||
996 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
997 | _("Received a probe on listen port %d, sent_from port %d\n"), sockinfo->port, ntohs(((struct sockaddr_in *)sender_addr)->sin_port)); | ||
998 | #endif | ||
999 | |||
1000 | udp_real_send(plugin, sockinfo->desc, NULL, | ||
1001 | (char *)outgoing_probe_reply, | ||
1002 | ntohs(outgoing_probe_reply->header.size), 0, | ||
1003 | GNUNET_TIME_relative_get_unit(), | ||
1004 | sender_addr, fromlen, | ||
1005 | NULL, NULL); | ||
1006 | |||
1007 | #if DEBUG_UDP_NAT | ||
1008 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
1009 | _("Sent PROBE REPLY to port %d on outgoing port %d\n"), ntohs(((struct sockaddr_in *)sender_addr)->sin_port), sockinfo->port); | ||
1010 | #endif | ||
1011 | GNUNET_free(outgoing_probe_reply); | ||
1012 | break; | ||
1013 | case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_REPLY: | ||
1014 | /* Check for existing probe, check ports returned, send confirmation if all is well */ | ||
1015 | #if DEBUG_UDP_NAT | ||
1016 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
1017 | _("Received PROBE REPLY from port %d on incoming port %d\n"), ntohs(((struct sockaddr_in *)sender_addr)->sin_port), sockinfo->port); | ||
1018 | #endif | ||
1019 | /* FIXME: use nonce, then IPv6 replies could work I think... */ | ||
1020 | if (sender_addr->ss_family == AF_INET) | ||
1021 | { | ||
1022 | memset(&addr_buf, 0, sizeof(addr_buf)); | ||
1023 | inet_ntop(AF_INET, &((struct sockaddr_in *) sender_addr)->sin_addr, addr_buf, INET_ADDRSTRLEN); | ||
1024 | outgoing_probe = find_probe(plugin, &addr_buf[0]); | ||
1025 | if (outgoing_probe != NULL) | ||
1026 | { | ||
1027 | #if DEBUG_UDP_NAT | ||
1028 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
1029 | _("Sending confirmation that we were reached!\n")); | ||
1030 | #endif | ||
1031 | outgoing_probe_confirmation = GNUNET_malloc(sizeof(struct UDP_NAT_ProbeMessageConfirmation)); | ||
1032 | outgoing_probe_confirmation->header.size = htons(sizeof(struct UDP_NAT_ProbeMessageConfirmation)); | ||
1033 | outgoing_probe_confirmation->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_CONFIRM); | ||
1034 | |||
1035 | udp_real_send(plugin, sockinfo->desc, NULL, (char *)outgoing_probe_confirmation, ntohs(outgoing_probe_confirmation->header.size), 0, GNUNET_TIME_relative_get_unit(), sender_addr, fromlen, NULL, NULL); | ||
1036 | |||
1037 | if (outgoing_probe->task != GNUNET_SCHEDULER_NO_TASK) | ||
1038 | { | ||
1039 | GNUNET_SCHEDULER_cancel(plugin->env->sched, outgoing_probe->task); | ||
1040 | outgoing_probe->task = GNUNET_SCHEDULER_NO_TASK; | ||
1041 | /* Schedule task to timeout and remove probe if confirmation not received */ | ||
1042 | } | ||
1043 | GNUNET_free(outgoing_probe_confirmation); | ||
1044 | } | ||
1045 | else | ||
1046 | { | ||
1047 | #if DEBUG_UDP_NAT | ||
1048 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", | ||
1049 | _("Received a probe reply, but have no record of a sent probe!\n")); | ||
1050 | #endif | ||
1051 | } | ||
1052 | } | ||
1053 | break; | ||
1054 | case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_CONFIRM: | ||
1055 | peer_session = find_session(plugin, sender); | ||
1056 | #if DEBUG_UDP_NAT | ||
1057 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
1058 | _("Looking up peer session for peer %s\n"), GNUNET_i2s(sender)); | ||
1059 | #endif | ||
1060 | if (peer_session == NULL) /* Shouldn't this NOT happen? */ | ||
1061 | { | ||
1062 | #if DEBUG_UDP_NAT | ||
1063 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", | ||
1064 | _("Peer not in list, adding (THIS MAY BE A MISTAKE) %s\n"), GNUNET_i2s(sender)); | ||
1065 | #endif | ||
1066 | peer_session = GNUNET_malloc(sizeof(struct PeerSession)); | ||
1067 | peer_session->connect_addr = GNUNET_malloc(fromlen); | ||
1068 | memcpy(peer_session->connect_addr, sender_addr, fromlen); | ||
1069 | peer_session->connect_alen = fromlen; | ||
1070 | peer_session->plugin = plugin; | ||
1071 | peer_session->sock = sockinfo->desc; | ||
1072 | memcpy(&peer_session->target, sender, sizeof(struct GNUNET_PeerIdentity)); | ||
1073 | peer_session->expecting_welcome = GNUNET_NO; | ||
1074 | |||
1075 | peer_session->next = plugin->sessions; | ||
1076 | plugin->sessions = peer_session; | ||
1077 | |||
1078 | peer_session->messages = NULL; | ||
1079 | } | ||
1080 | else if (peer_session->expecting_welcome == GNUNET_YES) | ||
1081 | { | ||
1082 | peer_session->expecting_welcome = GNUNET_NO; | ||
1083 | /* FIXME: There is no way to find this based on receiving port at the moment! */ | ||
1084 | peer_session->sock = sockinfo->desc; /* This may matter, not sure right now... */ | ||
1085 | ((struct sockaddr_in *)peer_session->connect_addr)->sin_port = ((struct sockaddr_in *) sender_addr)->sin_port; | ||
1086 | #if DEBUG_UDP_NAT | ||
1087 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", | ||
1088 | _("Received a probe confirmation, will send to peer on port %d\n"), ntohs(((struct sockaddr_in *)peer_session->connect_addr)->sin_port)); | ||
1089 | #endif | ||
1090 | if (peer_session->messages != NULL) | ||
1091 | { | ||
1092 | #if DEBUG_UDP_NAT | ||
1093 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", | ||
1094 | _("Received a probe confirmation, sending queued messages.\n")); | ||
1095 | #endif | ||
1096 | pending_message = peer_session->messages; | ||
1097 | int count = 0; | ||
1098 | while (pending_message != NULL) | ||
1099 | { | ||
1100 | #if DEBUG_UDP_NAT | ||
1101 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", | ||
1102 | _("sending queued message %d\n"), count); | ||
1103 | #endif | ||
1104 | udp_real_send(plugin, peer_session->sock, &peer_session->target, pending_message->msgbuf, pending_message->msgbuf_size, 0, GNUNET_TIME_relative_get_unit(), peer_session->connect_addr, peer_session->connect_alen, pending_message->cont, pending_message->cont_cls); | ||
1105 | pending_message_temp = pending_message; | ||
1106 | pending_message = pending_message->next; | ||
1107 | GNUNET_free(pending_message_temp->msgbuf); | ||
1108 | GNUNET_free(pending_message_temp); | ||
1109 | #if DEBUG_UDP_NAT | ||
1110 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", | ||
1111 | _("finished sending queued message %d\n"), count); | ||
1112 | #endif | ||
1113 | count++; | ||
1114 | } | ||
1115 | } | ||
1116 | |||
1117 | } | ||
1118 | else | ||
1119 | { | ||
1120 | #if DEBUG_UDP_NAT | ||
1121 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", | ||
1122 | _("Received probe confirmation for already confirmed peer!\n")); | ||
1123 | #endif | ||
1124 | } | ||
1125 | /* Received confirmation, add peer with address/port specified */ | ||
1126 | break; | ||
1127 | case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_KEEPALIVE: | ||
1128 | /* Once we've sent NAT_PROBE_CONFIRM change to sending keepalives */ | ||
1129 | /* If we receive these just ignore! */ | ||
1130 | break; | ||
1131 | default: | ||
1132 | plugin->env->receive (plugin->env->cls, sender, currhdr, UDP_DIRECT_DISTANCE, | ||
1133 | NULL, (char *)sender_addr, fromlen); | ||
1134 | } | ||
1135 | |||
1136 | } | ||
1137 | |||
1138 | |||
1139 | /* | ||
1140 | * @param cls the plugin handle | ||
1141 | * @param tc the scheduling context (for rescheduling this function again) | ||
1142 | * | ||
1143 | * We have been notified that our writeset has something to read. We don't | ||
1144 | * know which socket needs to be read, so we have to check each one | ||
1145 | * Then reschedule this function to be called again once more is available. | ||
446 | * | 1146 | * |
447 | */ | 1147 | */ |
448 | static void | 1148 | static void |
@@ -459,126 +1159,77 @@ udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
459 | int offset; | 1159 | int offset; |
460 | int count; | 1160 | int count; |
461 | int tsize; | 1161 | int tsize; |
1162 | |||
462 | char *msgbuf; | 1163 | char *msgbuf; |
463 | const struct GNUNET_MessageHeader *currhdr; | 1164 | const struct GNUNET_MessageHeader *currhdr; |
464 | struct IPv4UdpAddress t4; | ||
465 | struct IPv6UdpAddress t6; | ||
466 | const struct sockaddr_in *s4; | ||
467 | const struct sockaddr_in6 *s6; | ||
468 | const void *ca; | ||
469 | size_t calen; | ||
470 | |||
471 | #if DEBUG_UDP | ||
472 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | ||
473 | ("entered select...\n")); | ||
474 | #endif | ||
475 | 1165 | ||
476 | buflen = GNUNET_NETWORK_socket_recvfrom_amount (udp_sock); | 1166 | buf = NULL; |
1167 | sender = NULL; | ||
477 | 1168 | ||
478 | #if DEBUG_UDP | 1169 | buflen = GNUNET_NETWORK_socket_recvfrom_amount (udp_sock.desc); |
479 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | ||
480 | ("we expect to read %u bytes\n"), buflen); | ||
481 | #endif | ||
482 | 1170 | ||
483 | if (buflen == GNUNET_NO) | 1171 | if (buflen == GNUNET_NO) |
484 | return; | 1172 | return; |
1173 | |||
1174 | buf = GNUNET_malloc (buflen); | ||
1175 | fromlen = sizeof (addr); | ||
1176 | memset (&addr, 0, fromlen); | ||
1177 | ret = | ||
1178 | GNUNET_NETWORK_socket_recvfrom (udp_sock.desc, buf, buflen, | ||
1179 | (struct sockaddr *) &addr, &fromlen); | ||
485 | 1180 | ||
486 | buf = GNUNET_malloc (buflen); | 1181 | #if DEBUG_UDP_NAT |
487 | fromlen = sizeof (addr); | 1182 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ |
1183 | ("socket_recv returned %u, src_addr_len is %u\n"), ret, | ||
1184 | fromlen); | ||
1185 | #endif | ||
488 | 1186 | ||
489 | memset (&addr, 0, fromlen); | 1187 | if (ret <= 0) |
490 | ret = | 1188 | { |
491 | GNUNET_NETWORK_socket_recvfrom (udp_sock, buf, buflen, | 1189 | GNUNET_free (buf); |
492 | (struct sockaddr *) &addr, &fromlen); | 1190 | return; |
1191 | } | ||
1192 | msg = (struct UDPMessage *) buf; | ||
493 | 1193 | ||
494 | #if DEBUG_UDP | 1194 | #if DEBUG_UDP_NAT |
495 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | 1195 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ |
496 | ("socket_recv returned %u, src_addr_len is %u\n"), ret, | 1196 | ("header reports message size of %d, type %d\n"), |
497 | fromlen); | 1197 | ntohs (msg->header.size), ntohs (msg->header.type)); |
498 | #endif | 1198 | #endif |
1199 | if (ntohs (msg->header.size) < sizeof (struct UDPMessage)) | ||
1200 | { | ||
1201 | GNUNET_free (buf); | ||
1202 | return; | ||
1203 | } | ||
499 | 1204 | ||
500 | if (ret <= 0) | 1205 | msgbuf = (char *)&msg[1]; |
501 | { | 1206 | sender = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity)); |
502 | GNUNET_free (buf); | 1207 | memcpy (sender, &msg->sender, sizeof (struct GNUNET_PeerIdentity)); |
503 | return; | ||
504 | } | ||
505 | msg = (struct UDPMessage *) buf; | ||
506 | 1208 | ||
507 | #if DEBUG_UDP | 1209 | offset = 0; |
508 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | 1210 | count = 0; |
509 | ("header reports message size of %d\n"), | 1211 | tsize = ntohs (msg->header.size) - sizeof(struct UDPMessage); |
510 | ntohs (msg->header.size)); | ||
511 | 1212 | ||
512 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | 1213 | while (offset < tsize) |
513 | ("header reports message type of %d\n"), | 1214 | { |
514 | ntohs (msg->header.type)); | 1215 | currhdr = (struct GNUNET_MessageHeader *)&msgbuf[offset]; |
1216 | #if DEBUG_UDP_NAT | ||
1217 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | ||
1218 | ("processing msg %d: type %d, size %d at offset %d\n"), | ||
1219 | count, ntohs(currhdr->type), ntohs(currhdr->size), offset); | ||
515 | #endif | 1220 | #endif |
516 | if (ntohs (msg->header.size) < sizeof (struct UDPMessage)) | 1221 | udp_demultiplexer(plugin, sender, currhdr, &addr, fromlen, &udp_sock); |
517 | { | 1222 | #if DEBUG_UDP_NAT |
518 | GNUNET_free (buf); | 1223 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ |
519 | GNUNET_NETWORK_fdset_zero (plugin->rs); | 1224 | ("processing done msg %d: type %d, size %d at offset %d\n"), |
520 | GNUNET_NETWORK_fdset_set (plugin->rs, udp_sock); | 1225 | count, ntohs(currhdr->type), ntohs(currhdr->size), offset); |
521 | return; | ||
522 | } | ||
523 | msgbuf = (char *)&msg[1]; | ||
524 | sender = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity)); | ||
525 | memcpy (sender, &msg->sender, sizeof (struct GNUNET_PeerIdentity)); | ||
526 | |||
527 | offset = 0; | ||
528 | count = 0; | ||
529 | tsize = ntohs (msg->header.size) - sizeof(struct UDPMessage); | ||
530 | #if DEBUG_UDP | ||
531 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "UDP", _ | ||
532 | ("offset is %d, tsize is %d (UDPMessage size is %d)\n"), | ||
533 | offset, tsize, sizeof(struct UDPMessage)); | ||
534 | #endif | 1226 | #endif |
1227 | offset += ntohs(currhdr->size); | ||
1228 | count++; | ||
1229 | } | ||
1230 | GNUNET_free_non_null (buf); | ||
1231 | GNUNET_free_non_null (sender); | ||
535 | 1232 | ||
536 | if (fromlen == sizeof (struct sockaddr_in)) | ||
537 | { | ||
538 | s4 = (const struct sockaddr_in*) &addr; | ||
539 | t4.u_port = s4->sin_port; | ||
540 | t4.ipv4_addr = s4->sin_addr.s_addr; | ||
541 | ca = &t4; | ||
542 | calen = sizeof (struct IPv4UdpAddress); | ||
543 | } | ||
544 | else if (fromlen == sizeof (struct sockaddr_in6)) | ||
545 | { | ||
546 | s6 = (const struct sockaddr_in6*) &addr; | ||
547 | t6.u6_port = s6->sin6_port; | ||
548 | memcpy (&t6.ipv6_addr, | ||
549 | &s6->sin6_addr, | ||
550 | sizeof (struct in6_addr)); | ||
551 | ca = &t6; | ||
552 | calen = sizeof (struct IPv6UdpAddress); | ||
553 | } | ||
554 | else | ||
555 | { | ||
556 | GNUNET_break (0); | ||
557 | ca = NULL; | ||
558 | calen = 0; | ||
559 | } | ||
560 | while (offset < tsize) | ||
561 | { | ||
562 | currhdr = (struct GNUNET_MessageHeader *)&msgbuf[offset]; | ||
563 | #if DEBUG_UDP | ||
564 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | ||
565 | ("processing msg %d: type %d, size %d at offset %d\n"), | ||
566 | count, ntohs(currhdr->type), ntohs(currhdr->size), offset); | ||
567 | #endif | ||
568 | plugin->env->receive (plugin->env->cls, | ||
569 | sender, currhdr, UDP_DIRECT_DISTANCE, | ||
570 | NULL, ca, calen); | ||
571 | offset += ntohs(currhdr->size); | ||
572 | #if DEBUG_UDP | ||
573 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | ||
574 | ("offset now %d, tsize %d\n"), | ||
575 | offset, tsize); | ||
576 | #endif | ||
577 | count++; | ||
578 | } | ||
579 | |||
580 | GNUNET_free (sender); | ||
581 | GNUNET_free (buf); | ||
582 | 1233 | ||
583 | plugin->select_task = | 1234 | plugin->select_task = |
584 | GNUNET_SCHEDULER_add_select (plugin->env->sched, | 1235 | GNUNET_SCHEDULER_add_select (plugin->env->sched, |
@@ -590,27 +1241,104 @@ udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
590 | } | 1241 | } |
591 | 1242 | ||
592 | /** | 1243 | /** |
593 | * Create a UDP socket. If possible, use IPv6, otherwise | 1244 | * Create a slew of UDP sockets. If possible, use IPv6, otherwise |
594 | * try IPv4. | 1245 | * try IPv4. |
595 | * @param cls closure, the 'struct Plugin*' | 1246 | * |
1247 | * @param cls closure for server start, should be a struct Plugin * | ||
1248 | * | ||
1249 | * @return number of sockets created or GNUNET_SYSERR on error | ||
596 | */ | 1250 | */ |
597 | static struct GNUNET_NETWORK_Handle * | 1251 | static int |
598 | udp_transport_server_start (void *cls) | 1252 | udp_transport_server_start (void *cls) |
599 | { | 1253 | { |
600 | struct Plugin *plugin = cls; | 1254 | struct Plugin *plugin = cls; |
601 | struct GNUNET_NETWORK_Handle *desc; | ||
602 | struct sockaddr_in serverAddrv4; | 1255 | struct sockaddr_in serverAddrv4; |
603 | struct sockaddr_in6 serverAddrv6; | 1256 | struct sockaddr_in6 serverAddrv6; |
604 | struct sockaddr *serverAddr; | 1257 | struct sockaddr *serverAddr; |
605 | socklen_t addrlen; | 1258 | socklen_t addrlen; |
1259 | int sockets_created; | ||
1260 | |||
1261 | /* Pipe to read from started processes stdout (on read end) */ | ||
1262 | plugin->server_stdout = GNUNET_DISK_pipe(GNUNET_YES); | ||
1263 | |||
1264 | sockets_created = 0; | ||
1265 | if (plugin->server_stdout == NULL) | ||
1266 | return sockets_created; | ||
1267 | |||
1268 | if (plugin->behind_nat == GNUNET_YES) | ||
1269 | { | ||
1270 | #if DEBUG_UDP_NAT | ||
1271 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | ||
1272 | "udp", | ||
1273 | "Starting gnunet-nat-server process\n"); | ||
1274 | #endif | ||
1275 | /* Start the server process */ | ||
1276 | plugin->server_pid = GNUNET_OS_start_process(NULL, plugin->server_stdout, "gnunet-nat-server", "gnunet-nat-server", plugin->internal_address, NULL); | ||
1277 | if (plugin->server_pid == GNUNET_SYSERR) | ||
1278 | { | ||
1279 | #if DEBUG_UDP_NAT | ||
1280 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | ||
1281 | "udp", | ||
1282 | "Failed to start gnunet-nat-server process\n"); | ||
1283 | #endif | ||
1284 | return GNUNET_SYSERR; | ||
1285 | } | ||
1286 | /* Close the write end of the read pipe */ | ||
1287 | GNUNET_DISK_pipe_close_end(plugin->server_stdout, GNUNET_DISK_PIPE_END_WRITE); | ||
1288 | |||
1289 | plugin->server_stdout_handle = GNUNET_DISK_pipe_handle(plugin->server_stdout, GNUNET_DISK_PIPE_END_READ); | ||
1290 | plugin->server_read_task = | ||
1291 | GNUNET_SCHEDULER_add_read_file (plugin->env->sched, | ||
1292 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
1293 | plugin->server_stdout_handle, &udp_plugin_server_read, plugin); | ||
1294 | } | ||
1295 | |||
1296 | udp_sock.desc = NULL; | ||
606 | 1297 | ||
607 | desc = NULL; | 1298 | |
608 | if (GNUNET_YES != | 1299 | udp_sock.desc = GNUNET_NETWORK_socket_create (PF_INET, SOCK_DGRAM, 17); |
1300 | if (NULL == udp_sock.desc) | ||
1301 | { | ||
1302 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", "socket"); | ||
1303 | return sockets_created; | ||
1304 | } | ||
1305 | else | ||
1306 | { | ||
1307 | memset (&serverAddrv4, 0, sizeof (serverAddrv4)); | ||
1308 | #if HAVE_SOCKADDR_IN_SIN_LEN | ||
1309 | serverAddrv4.sin_len = sizeof (serverAddrv4); | ||
1310 | #endif | ||
1311 | serverAddrv4.sin_family = AF_INET; | ||
1312 | serverAddrv4.sin_addr.s_addr = INADDR_ANY; | ||
1313 | serverAddrv4.sin_port = htons (plugin->port); | ||
1314 | addrlen = sizeof (serverAddrv4); | ||
1315 | serverAddr = (struct sockaddr *) &serverAddrv4; | ||
1316 | #if DEBUG_UDP_NAT | ||
1317 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | ||
1318 | "udp", | ||
1319 | "Binding to port %d\n", ntohs(serverAddrv4.sin_port)); | ||
1320 | #endif | ||
1321 | while (GNUNET_NETWORK_socket_bind (udp_sock.desc, serverAddr, addrlen) != | ||
1322 | GNUNET_OK) | ||
1323 | { | ||
1324 | serverAddrv4.sin_port = htons (GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); /* Find a good, non-root port */ | ||
1325 | #if DEBUG_UDP_NAT | ||
1326 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | ||
1327 | "udp", | ||
1328 | "Binding failed, trying new port %d\n", ntohs(serverAddrv4.sin_port)); | ||
1329 | #endif | ||
1330 | } | ||
1331 | udp_sock.port = ntohs(serverAddrv4.sin_port); | ||
1332 | sockets_created++; | ||
1333 | } | ||
1334 | |||
1335 | |||
1336 | if ((udp_sock.desc == NULL) && (GNUNET_YES != | ||
609 | GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg, "GNUNETD", | 1337 | GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg, "GNUNETD", |
610 | "DISABLE-IPV6")) | 1338 | "DISABLE-IPV6"))) |
611 | { | 1339 | { |
612 | desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 17); | 1340 | udp_sock.desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 17); |
613 | if (desc != NULL) | 1341 | if (udp_sock.desc != NULL) |
614 | { | 1342 | { |
615 | memset (&serverAddrv6, 0, sizeof (serverAddrv6)); | 1343 | memset (&serverAddrv6, 0, sizeof (serverAddrv6)); |
616 | #if HAVE_SOCKADDR_IN_SIN_LEN | 1344 | #if HAVE_SOCKADDR_IN_SIN_LEN |
@@ -618,43 +1346,19 @@ udp_transport_server_start (void *cls) | |||
618 | #endif | 1346 | #endif |
619 | serverAddrv6.sin6_family = AF_INET6; | 1347 | serverAddrv6.sin6_family = AF_INET6; |
620 | serverAddrv6.sin6_addr = in6addr_any; | 1348 | serverAddrv6.sin6_addr = in6addr_any; |
621 | serverAddrv6.sin6_port = htons (plugin->open_port); | 1349 | serverAddrv6.sin6_port = htons (plugin->port); |
622 | addrlen = sizeof (serverAddrv6); | 1350 | addrlen = sizeof (serverAddrv6); |
623 | serverAddr = (struct sockaddr *) &serverAddrv6; | 1351 | serverAddr = (struct sockaddr *) &serverAddrv6; |
1352 | sockets_created++; | ||
624 | } | 1353 | } |
625 | } | 1354 | } |
626 | if (NULL == desc) | ||
627 | { | ||
628 | desc = GNUNET_NETWORK_socket_create (PF_INET, SOCK_DGRAM, 17); | ||
629 | if (NULL == desc) | ||
630 | { | ||
631 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", "socket"); | ||
632 | return NULL; | ||
633 | } | ||
634 | else | ||
635 | { | ||
636 | memset (&serverAddrv4, 0, sizeof (serverAddrv4)); | ||
637 | #if HAVE_SOCKADDR_IN_SIN_LEN | ||
638 | serverAddrv4.sin_len = sizeof (serverAddrv4); | ||
639 | #endif | ||
640 | serverAddrv4.sin_family = AF_INET; | ||
641 | serverAddrv4.sin_addr.s_addr = INADDR_ANY; | ||
642 | serverAddrv4.sin_port = htons (plugin->open_port); | ||
643 | addrlen = sizeof (serverAddrv4); | ||
644 | serverAddr = (struct sockaddr *) &serverAddrv4; | ||
645 | } | ||
646 | } | ||
647 | |||
648 | if (desc != NULL) | ||
649 | { | ||
650 | GNUNET_assert (GNUNET_NETWORK_socket_bind (desc, serverAddr, addrlen) == | ||
651 | GNUNET_OK); | ||
652 | } | ||
653 | 1355 | ||
654 | plugin->rs = GNUNET_NETWORK_fdset_create (); | 1356 | plugin->rs = GNUNET_NETWORK_fdset_create (); |
655 | 1357 | ||
656 | GNUNET_NETWORK_fdset_zero (plugin->rs); | 1358 | GNUNET_NETWORK_fdset_zero (plugin->rs); |
657 | GNUNET_NETWORK_fdset_set (plugin->rs, desc); | 1359 | |
1360 | |||
1361 | GNUNET_NETWORK_fdset_set (plugin->rs, udp_sock.desc); | ||
658 | 1362 | ||
659 | plugin->select_task = | 1363 | plugin->select_task = |
660 | GNUNET_SCHEDULER_add_select (plugin->env->sched, | 1364 | GNUNET_SCHEDULER_add_select (plugin->env->sched, |
@@ -663,7 +1367,7 @@ udp_transport_server_start (void *cls) | |||
663 | GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs, | 1367 | GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs, |
664 | NULL, &udp_plugin_select, plugin); | 1368 | NULL, &udp_plugin_select, plugin); |
665 | 1369 | ||
666 | return desc; | 1370 | return sockets_created; |
667 | } | 1371 | } |
668 | 1372 | ||
669 | 1373 | ||
@@ -677,11 +1381,19 @@ udp_transport_server_start (void *cls) | |||
677 | static uint16_t | 1381 | static uint16_t |
678 | check_port (struct Plugin *plugin, uint16_t in_port) | 1382 | check_port (struct Plugin *plugin, uint16_t in_port) |
679 | { | 1383 | { |
680 | if ((in_port == plugin->adv_port) || (in_port == plugin->open_port)) | 1384 | |
681 | return in_port; | 1385 | /* FIXME: remember what ports we are using to better respond to this */ |
682 | return (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, | 1386 | return in_port; |
683 | 2) == 0) | 1387 | /* |
684 | ? plugin->open_port : plugin->adv_port; | 1388 | for (i = plugin->starting_port; i < plugin->num_ports + plugin->starting_port; i++) |
1389 | { | ||
1390 | if (in_port == i) | ||
1391 | return in_port; | ||
1392 | } | ||
1393 | |||
1394 | return GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, | ||
1395 | plugin->num_ports) + plugin->starting_port; | ||
1396 | */ | ||
685 | } | 1397 | } |
686 | 1398 | ||
687 | 1399 | ||
@@ -692,40 +1404,46 @@ check_port (struct Plugin *plugin, uint16_t in_port) | |||
692 | * connect to it but simply to see if the binary format is technically | 1404 | * connect to it but simply to see if the binary format is technically |
693 | * legal for establishing a connection. | 1405 | * legal for establishing a connection. |
694 | * | 1406 | * |
695 | * @param cls handle to Plugin | 1407 | * @param cls closure, should be our handle to the Plugin |
696 | * @param addr address to check | 1408 | * @param addr pointer to the address, may be modified (slightly) |
697 | * @param addrlen length of addr | 1409 | * @param addrlen length of addr |
698 | * @return GNUNET_OK if this is a plausible address for this peer | 1410 | * @return GNUNET_OK if this is a plausible address for this peer |
699 | * and transport, GNUNET_SYSERR if not | 1411 | * and transport, GNUNET_SYSERR if not |
1412 | * | ||
700 | */ | 1413 | */ |
701 | static int | 1414 | static int |
702 | udp_check_address (void *cls, void *addr, size_t addrlen) | 1415 | udp_check_address (void *cls, void *addr, size_t addrlen) |
703 | { | 1416 | { |
704 | struct Plugin *plugin = cls; | 1417 | struct Plugin *plugin = cls; |
705 | struct IPv4UdpAddress *v4; | 1418 | char buf[sizeof (struct sockaddr_in6)]; |
706 | struct IPv6UdpAddress *v6; | ||
707 | 1419 | ||
708 | if ((addrlen != sizeof (struct IPv4UdpAddress)) && | 1420 | struct sockaddr_in *v4; |
709 | (addrlen != sizeof (struct IPv6UdpAddress))) | 1421 | struct sockaddr_in6 *v6; |
1422 | |||
1423 | if ((addrlen != sizeof (struct sockaddr_in)) && | ||
1424 | (addrlen != sizeof (struct sockaddr_in6))) | ||
710 | { | 1425 | { |
711 | GNUNET_break_op (0); | 1426 | GNUNET_break_op (0); |
712 | return GNUNET_SYSERR; | 1427 | return GNUNET_SYSERR; |
713 | } | 1428 | } |
714 | if (addrlen == sizeof (struct IPv4UdpAddress)) | 1429 | memcpy (buf, addr, sizeof (struct sockaddr_in6)); |
1430 | if (addrlen == sizeof (struct sockaddr_in)) | ||
715 | { | 1431 | { |
716 | v4 = (struct IPv4UdpAddress *) addr; | 1432 | v4 = (struct sockaddr_in *) buf; |
717 | v4->u_port = htons (check_port (plugin, ntohs (v4->u_port))); | 1433 | v4->sin_port = htons (check_port (plugin, ntohs (v4->sin_port))); |
718 | } | 1434 | } |
719 | else | 1435 | else |
720 | { | 1436 | { |
721 | v6 = (struct IPv6UdpAddress *) addr; | 1437 | v6 = (struct sockaddr_in6 *) buf; |
722 | if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr)) | 1438 | v6->sin6_port = htons (check_port (plugin, ntohs (v6->sin6_port))); |
723 | { | ||
724 | GNUNET_break_op (0); | ||
725 | return GNUNET_SYSERR; | ||
726 | } | ||
727 | v6->u6_port = htons (check_port (plugin, ntohs (v6->u6_port))); | ||
728 | } | 1439 | } |
1440 | |||
1441 | #if DEBUG_UDP_NAT | ||
1442 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | ||
1443 | "udp", | ||
1444 | "Informing transport service about my address `%s'.\n", | ||
1445 | GNUNET_a2s (addr, addrlen)); | ||
1446 | #endif | ||
729 | return GNUNET_OK; | 1447 | return GNUNET_OK; |
730 | } | 1448 | } |
731 | 1449 | ||
@@ -776,40 +1494,12 @@ udp_plugin_address_pretty_printer (void *cls, | |||
776 | void *asc_cls) | 1494 | void *asc_cls) |
777 | { | 1495 | { |
778 | struct Plugin *plugin = cls; | 1496 | struct Plugin *plugin = cls; |
1497 | const struct sockaddr_in *v4; | ||
1498 | const struct sockaddr_in6 *v6; | ||
779 | struct PrettyPrinterContext *ppc; | 1499 | struct PrettyPrinterContext *ppc; |
780 | const void *sb; | ||
781 | struct sockaddr_in a4; | ||
782 | struct sockaddr_in6 a6; | ||
783 | const struct IPv4UdpAddress *t4; | ||
784 | const struct IPv6UdpAddress *t6; | ||
785 | size_t sbs; | ||
786 | uint16_t port; | ||
787 | 1500 | ||
788 | if (addrlen == sizeof (struct IPv6UdpAddress)) | 1501 | if ((addrlen != sizeof (struct sockaddr_in)) && |
789 | { | 1502 | (addrlen != sizeof (struct sockaddr_in6))) |
790 | t6 = addr; | ||
791 | memset (&a6, 0, sizeof (a6)); | ||
792 | a6.sin6_family = AF_INET6; | ||
793 | a6.sin6_port = t6->u6_port; | ||
794 | port = ntohs (t6->u6_port); | ||
795 | memcpy (&a6.sin6_addr, | ||
796 | &t6->ipv6_addr, | ||
797 | sizeof (struct in6_addr)); | ||
798 | sb = &a6; | ||
799 | sbs = sizeof (a6); | ||
800 | } | ||
801 | else if (addrlen == sizeof (struct IPv4UdpAddress)) | ||
802 | { | ||
803 | t4 = addr; | ||
804 | memset (&a4, 0, sizeof (a4)); | ||
805 | a4.sin_family = AF_INET; | ||
806 | a4.sin_port = t4->u_port; | ||
807 | a4.sin_addr.s_addr = t4->ipv4_addr; | ||
808 | port = ntohs (t4->u_port); | ||
809 | sb = &a4; | ||
810 | sbs = sizeof (a4); | ||
811 | } | ||
812 | else | ||
813 | { | 1503 | { |
814 | /* invalid address */ | 1504 | /* invalid address */ |
815 | GNUNET_break_op (0); | 1505 | GNUNET_break_op (0); |
@@ -819,87 +1509,42 @@ udp_plugin_address_pretty_printer (void *cls, | |||
819 | ppc = GNUNET_malloc (sizeof (struct PrettyPrinterContext)); | 1509 | ppc = GNUNET_malloc (sizeof (struct PrettyPrinterContext)); |
820 | ppc->asc = asc; | 1510 | ppc->asc = asc; |
821 | ppc->asc_cls = asc_cls; | 1511 | ppc->asc_cls = asc_cls; |
822 | ppc->port = port; | 1512 | if (addrlen == sizeof (struct sockaddr_in)) |
823 | GNUNET_RESOLVER_hostname_get (plugin->env->sched, | ||
824 | plugin->env->cfg, | ||
825 | sb, | ||
826 | sbs, | ||
827 | !numeric, timeout, &append_port, ppc); | ||
828 | } | ||
829 | |||
830 | |||
831 | |||
832 | /** | ||
833 | * Function called for a quick conversion of the binary address to | ||
834 | * a numeric address. Note that the caller must not free the | ||
835 | * address and that the next call to this function is allowed | ||
836 | * to override the address again. | ||
837 | * | ||
838 | * @param cls closure | ||
839 | * @param addr binary address | ||
840 | * @param addrlen length of the address | ||
841 | * @return string representing the same address | ||
842 | */ | ||
843 | static const char* | ||
844 | udp_address_to_string (void *cls, | ||
845 | const void *addr, | ||
846 | size_t addrlen) | ||
847 | { | ||
848 | static char rbuf[INET6_ADDRSTRLEN + 10]; | ||
849 | char buf[INET6_ADDRSTRLEN]; | ||
850 | const void *sb; | ||
851 | struct in_addr a4; | ||
852 | struct in6_addr a6; | ||
853 | const struct IPv4UdpAddress *t4; | ||
854 | const struct IPv6UdpAddress *t6; | ||
855 | int af; | ||
856 | uint16_t port; | ||
857 | |||
858 | if (addrlen == sizeof (struct IPv6UdpAddress)) | ||
859 | { | 1513 | { |
860 | t6 = addr; | 1514 | v4 = (const struct sockaddr_in *) addr; |
861 | af = AF_INET6; | 1515 | ppc->port = ntohs (v4->sin_port); |
862 | port = ntohs (t6->u6_port); | ||
863 | memcpy (&a6, &t6->ipv6_addr, sizeof (a6)); | ||
864 | sb = &a6; | ||
865 | } | 1516 | } |
866 | else if (addrlen == sizeof (struct IPv4UdpAddress)) | 1517 | else |
867 | { | 1518 | { |
868 | t4 = addr; | 1519 | v6 = (const struct sockaddr_in6 *) addr; |
869 | af = AF_INET; | 1520 | ppc->port = ntohs (v6->sin6_port); |
870 | port = ntohs (t4->u_port); | 1521 | |
871 | memcpy (&a4, &t4->ipv4_addr, sizeof (a4)); | ||
872 | sb = &a4; | ||
873 | } | 1522 | } |
874 | else | 1523 | GNUNET_RESOLVER_hostname_get (plugin->env->sched, |
875 | return NULL; | 1524 | plugin->env->cfg, |
876 | inet_ntop (af, sb, buf, INET6_ADDRSTRLEN); | 1525 | addr, |
877 | GNUNET_snprintf (rbuf, | 1526 | addrlen, |
878 | sizeof (rbuf), | 1527 | !numeric, timeout, &append_port, ppc); |
879 | "%s:%u", | ||
880 | buf, | ||
881 | port); | ||
882 | return rbuf; | ||
883 | } | 1528 | } |
884 | 1529 | ||
885 | 1530 | ||
886 | /** | 1531 | /** |
887 | * The exported method. Makes the core api available via a global and | 1532 | * The exported method. Makes the core api available via a global and |
888 | * returns the udp transport API. | 1533 | * returns the udp transport API. |
889 | * | ||
890 | * @param cls closure, the 'struct GNUNET_TRANSPORT_PluginEnvironment*' | ||
891 | * @return the 'struct GNUNET_TRANSPORT_PluginFunctions*' or NULL on error | ||
892 | */ | 1534 | */ |
893 | void * | 1535 | void * |
894 | libgnunet_plugin_transport_udp_init (void *cls) | 1536 | libgnunet_plugin_transport_udp_init (void *cls) |
895 | { | 1537 | { |
896 | struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; | 1538 | struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; |
1539 | unsigned long long mtu; | ||
1540 | unsigned long long port; | ||
897 | struct GNUNET_TRANSPORT_PluginFunctions *api; | 1541 | struct GNUNET_TRANSPORT_PluginFunctions *api; |
898 | struct Plugin *plugin; | 1542 | struct Plugin *plugin; |
899 | struct GNUNET_SERVICE_Context *service; | 1543 | struct GNUNET_SERVICE_Context *service; |
900 | unsigned long long aport; | 1544 | int sockets_created; |
901 | unsigned long long bport; | 1545 | int behind_nat; |
902 | unsigned long long mtu; | 1546 | char *internal_address; |
1547 | char *external_address; | ||
903 | 1548 | ||
904 | service = GNUNET_SERVICE_start ("transport-udp", env->sched, env->cfg); | 1549 | service = GNUNET_SERVICE_start ("transport-udp", env->sched, env->cfg); |
905 | if (service == NULL) | 1550 | if (service == NULL) |
@@ -909,29 +1554,66 @@ libgnunet_plugin_transport_udp_init (void *cls) | |||
909 | "udp"); | 1554 | "udp"); |
910 | return NULL; | 1555 | return NULL; |
911 | } | 1556 | } |
912 | aport = 0; | 1557 | |
913 | if ((GNUNET_OK != | 1558 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (env->cfg, |
914 | GNUNET_CONFIGURATION_get_value_number (env->cfg, | 1559 | "transport-udp", |
915 | "transport-udp", | 1560 | "BEHIND_NAT")) |
916 | "PORT", | 1561 | behind_nat = GNUNET_YES; /* We are behind nat (according to the user) */ |
917 | &bport)) || | 1562 | else |
918 | (bport > 65535) || | 1563 | behind_nat = GNUNET_NO; /* We are not behind nat! */ |
919 | ((GNUNET_OK == | 1564 | |
920 | GNUNET_CONFIGURATION_get_value_number (env->cfg, | 1565 | external_address = NULL; |
921 | "transport-udp", | 1566 | if ((GNUNET_YES == behind_nat) && (GNUNET_OK != |
922 | "ADVERTISED-PORT", | 1567 | GNUNET_CONFIGURATION_get_value_string (env->cfg, |
923 | &aport)) && (aport > 65535))) | 1568 | "transport-udp", |
1569 | "EXTERNAL_ADDRESS", | ||
1570 | &external_address))) | ||
924 | { | 1571 | { |
925 | GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, | 1572 | GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, |
926 | "udp", | 1573 | "udp", |
927 | _ | 1574 | _ |
928 | ("Require valid port number for service `%s' in configuration!\n"), | 1575 | ("Require EXTERNAL_ADDRESS for service `%s' in configuration!\n"), |
929 | "transport-udp"); | 1576 | "transport-udp"); |
930 | GNUNET_SERVICE_stop (service); | 1577 | GNUNET_SERVICE_stop (service); |
931 | return NULL; | 1578 | return NULL; |
932 | } | 1579 | } |
933 | if (aport == 0) | 1580 | |
934 | aport = bport; | 1581 | internal_address = NULL; |
1582 | if ((GNUNET_YES == behind_nat) && (GNUNET_OK != | ||
1583 | GNUNET_CONFIGURATION_get_value_string (env->cfg, | ||
1584 | "transport-udp", | ||
1585 | "INTERNAL_ADDRESS", | ||
1586 | &internal_address))) | ||
1587 | { | ||
1588 | GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, | ||
1589 | "udp", | ||
1590 | _ | ||
1591 | ("Require INTERNAL_ADDRESS for service `%s' in configuration!\n"), | ||
1592 | "transport-udp"); | ||
1593 | GNUNET_SERVICE_stop (service); | ||
1594 | GNUNET_free_non_null(external_address); | ||
1595 | return NULL; | ||
1596 | } | ||
1597 | |||
1598 | if (GNUNET_OK != | ||
1599 | GNUNET_CONFIGURATION_get_value_number (env->cfg, | ||
1600 | "transport-udp", | ||
1601 | "PORT", | ||
1602 | &port)) | ||
1603 | port = UDP_NAT_DEFAULT_PORT; | ||
1604 | else if (port > 65535) | ||
1605 | { | ||
1606 | GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, | ||
1607 | "udp", | ||
1608 | _("Given `%s' option is out of range: %llu > %u\n"), | ||
1609 | "PORT", | ||
1610 | port, | ||
1611 | 65535); | ||
1612 | GNUNET_SERVICE_stop (service); | ||
1613 | GNUNET_free_non_null(external_address); | ||
1614 | GNUNET_free_non_null(internal_address); | ||
1615 | return NULL; | ||
1616 | } | ||
935 | 1617 | ||
936 | mtu = 1240; | 1618 | mtu = 1240; |
937 | if (mtu < 1200) | 1619 | if (mtu < 1200) |
@@ -941,9 +1623,12 @@ libgnunet_plugin_transport_udp_init (void *cls) | |||
941 | "UDP"); | 1623 | "UDP"); |
942 | 1624 | ||
943 | plugin = GNUNET_malloc (sizeof (struct Plugin)); | 1625 | plugin = GNUNET_malloc (sizeof (struct Plugin)); |
944 | plugin->open_port = bport; | 1626 | plugin->external_address = external_address; |
945 | plugin->adv_port = aport; | 1627 | plugin->internal_address = internal_address; |
1628 | plugin->port = port; | ||
1629 | plugin->behind_nat = behind_nat; | ||
946 | plugin->env = env; | 1630 | plugin->env = env; |
1631 | |||
947 | api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); | 1632 | api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); |
948 | api->cls = plugin; | 1633 | api->cls = plugin; |
949 | 1634 | ||
@@ -951,11 +1636,9 @@ libgnunet_plugin_transport_udp_init (void *cls) | |||
951 | api->disconnect = &udp_disconnect; | 1636 | api->disconnect = &udp_disconnect; |
952 | api->address_pretty_printer = &udp_plugin_address_pretty_printer; | 1637 | api->address_pretty_printer = &udp_plugin_address_pretty_printer; |
953 | api->check_address = &udp_check_address; | 1638 | api->check_address = &udp_check_address; |
954 | api->address_to_string = &udp_address_to_string; | 1639 | |
955 | plugin->service = service; | 1640 | plugin->service = service; |
956 | 1641 | ||
957 | /* FIXME: do the two calls below periodically again and | ||
958 | not just once (since the info we get might change...) */ | ||
959 | GNUNET_OS_network_interfaces_list (&process_interfaces, plugin); | 1642 | GNUNET_OS_network_interfaces_list (&process_interfaces, plugin); |
960 | plugin->hostname_dns = GNUNET_RESOLVER_hostname_resolve (env->sched, | 1643 | plugin->hostname_dns = GNUNET_RESOLVER_hostname_resolve (env->sched, |
961 | env->cfg, | 1644 | env->cfg, |
@@ -964,13 +1647,14 @@ libgnunet_plugin_transport_udp_init (void *cls) | |||
964 | &process_hostname_ips, | 1647 | &process_hostname_ips, |
965 | plugin); | 1648 | plugin); |
966 | 1649 | ||
967 | udp_sock = udp_transport_server_start (plugin); | 1650 | sockets_created = udp_transport_server_start (plugin); |
968 | 1651 | ||
969 | GNUNET_assert (udp_sock != NULL); | 1652 | GNUNET_assert (sockets_created == 1); |
970 | 1653 | ||
971 | return api; | 1654 | return api; |
972 | } | 1655 | } |
973 | 1656 | ||
1657 | |||
974 | void * | 1658 | void * |
975 | libgnunet_plugin_transport_udp_done (void *cls) | 1659 | libgnunet_plugin_transport_udp_done (void *cls) |
976 | { | 1660 | { |
@@ -978,10 +1662,10 @@ libgnunet_plugin_transport_udp_done (void *cls) | |||
978 | struct Plugin *plugin = api->cls; | 1662 | struct Plugin *plugin = api->cls; |
979 | 1663 | ||
980 | udp_transport_server_stop (plugin); | 1664 | udp_transport_server_stop (plugin); |
981 | if (NULL != plugin->hostname_dns) | 1665 | if (NULL != hostname_dns) |
982 | { | 1666 | { |
983 | GNUNET_RESOLVER_request_cancel (plugin->hostname_dns); | 1667 | GNUNET_RESOLVER_request_cancel (hostname_dns); |
984 | plugin->hostname_dns = NULL; | 1668 | hostname_dns = NULL; |
985 | } | 1669 | } |
986 | GNUNET_SERVICE_stop (plugin->service); | 1670 | GNUNET_SERVICE_stop (plugin->service); |
987 | 1671 | ||
diff --git a/src/transport/plugin_transport_udp_nat.c b/src/transport/plugin_transport_udp_nat.c deleted file mode 100644 index 5f225a91c..000000000 --- a/src/transport/plugin_transport_udp_nat.c +++ /dev/null | |||
@@ -1,1676 +0,0 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet | ||
3 | (C) 2010 Christian Grothoff (and other contributing authors) | ||
4 | |||
5 | GNUnet is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published | ||
7 | by the Free Software Foundation; either version 2, or (at your | ||
8 | option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with GNUnet; see the file COPYING. If not, write to the | ||
17 | Free Software Foundation, Inc., 59 Temple Place - Suite 330, | ||
18 | Boston, MA 02111-1307, USA. | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @file transport/plugin_transport_udp.c | ||
23 | * @brief Implementation of the UDP NAT punching | ||
24 | * transport service | ||
25 | * @author Christian Grothoff | ||
26 | * @author Nathan Evans | ||
27 | * | ||
28 | * The idea with this transport is to connect gnunet peers to each other | ||
29 | * when ONE is behind a NAT. This is based on pwnat (http://samy.pl/pwnat) | ||
30 | * created by Samy Kamkar. When configured with the PWNAT options, this | ||
31 | * transport will start a server daemon which sends dummy ICMP and UDP | ||
32 | * messages out to a predefined address (typically 1.2.3.4). | ||
33 | * | ||
34 | * When a non-NAT'd peer (the client) learns of the NAT'd peer (the server) | ||
35 | * address, it will send ICMP RESPONSES to the NAT'd peers external address. | ||
36 | * The NAT box should forward these faked responses to the server, which | ||
37 | * can then connect directly to the non-NAT'd peer. | ||
38 | */ | ||
39 | |||
40 | #include "platform.h" | ||
41 | #include "gnunet_hello_lib.h" | ||
42 | #include "gnunet_connection_lib.h" | ||
43 | #include "gnunet_os_lib.h" | ||
44 | #include "gnunet_peerinfo_service.h" | ||
45 | #include "gnunet_protocols.h" | ||
46 | #include "gnunet_resolver_service.h" | ||
47 | #include "gnunet_server_lib.h" | ||
48 | #include "gnunet_service_lib.h" | ||
49 | #include "gnunet_signatures.h" | ||
50 | #include "gnunet_statistics_service.h" | ||
51 | #include "gnunet_transport_service.h" | ||
52 | #include "plugin_transport.h" | ||
53 | #include "transport.h" | ||
54 | |||
55 | #define DEBUG_UDP_NAT GNUNET_YES | ||
56 | |||
57 | #define MAX_PROBES 20 | ||
58 | |||
59 | /* | ||
60 | * Transport cost to peer, always 1 for UDP (direct connection) | ||
61 | */ | ||
62 | #define UDP_DIRECT_DISTANCE 1 | ||
63 | |||
64 | /** | ||
65 | * Handle for request of hostname resolution, non-NULL if pending. | ||
66 | */ | ||
67 | static struct GNUNET_RESOLVER_RequestHandle *hostname_dns; | ||
68 | |||
69 | /** | ||
70 | * How long until we give up on transmitting the welcome message? | ||
71 | */ | ||
72 | #define HOSTNAME_RESOLVE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) | ||
73 | |||
74 | /** | ||
75 | * Starting port for listening and sending, eventually a config value | ||
76 | */ | ||
77 | #define UDP_NAT_DEFAULT_PORT 22086 | ||
78 | |||
79 | /** | ||
80 | * UDP Message-Packet header. | ||
81 | */ | ||
82 | struct UDPMessage | ||
83 | { | ||
84 | /** | ||
85 | * Message header. | ||
86 | */ | ||
87 | struct GNUNET_MessageHeader header; | ||
88 | |||
89 | /** | ||
90 | * What is the identity of the sender (GNUNET_hash of public key) | ||
91 | */ | ||
92 | struct GNUNET_PeerIdentity sender; | ||
93 | |||
94 | }; | ||
95 | |||
96 | |||
97 | /* Forward definition */ | ||
98 | struct Plugin; | ||
99 | |||
100 | struct PrettyPrinterContext | ||
101 | { | ||
102 | GNUNET_TRANSPORT_AddressStringCallback asc; | ||
103 | void *asc_cls; | ||
104 | uint16_t port; | ||
105 | }; | ||
106 | |||
107 | struct MessageQueue | ||
108 | { | ||
109 | /** | ||
110 | * Linked List | ||
111 | */ | ||
112 | struct MessageQueue *next; | ||
113 | |||
114 | /** | ||
115 | * Session this message belongs to | ||
116 | */ | ||
117 | struct PeerSession *session; | ||
118 | |||
119 | /** | ||
120 | * Actual message to be sent | ||
121 | */ | ||
122 | char *msgbuf; | ||
123 | |||
124 | /** | ||
125 | * Size of message buffer to be sent | ||
126 | */ | ||
127 | size_t msgbuf_size; | ||
128 | |||
129 | /** | ||
130 | * When to discard this message | ||
131 | */ | ||
132 | struct GNUNET_TIME_Absolute timeout; | ||
133 | |||
134 | /** | ||
135 | * Continuation to call when this message goes out | ||
136 | */ | ||
137 | GNUNET_TRANSPORT_TransmitContinuation cont; | ||
138 | |||
139 | /** | ||
140 | * closure for continuation | ||
141 | */ | ||
142 | void *cont_cls; | ||
143 | |||
144 | }; | ||
145 | |||
146 | /** | ||
147 | * UDP NAT Probe message definition | ||
148 | */ | ||
149 | struct UDP_NAT_ProbeMessage | ||
150 | { | ||
151 | /** | ||
152 | * Message header | ||
153 | */ | ||
154 | struct GNUNET_MessageHeader header; | ||
155 | |||
156 | }; | ||
157 | |||
158 | /** | ||
159 | * UDP NAT Probe message reply definition | ||
160 | */ | ||
161 | struct UDP_NAT_ProbeMessageReply | ||
162 | { | ||
163 | /** | ||
164 | * Message header | ||
165 | */ | ||
166 | struct GNUNET_MessageHeader header; | ||
167 | |||
168 | }; | ||
169 | |||
170 | |||
171 | /** | ||
172 | * UDP NAT Probe message confirm definition | ||
173 | */ | ||
174 | struct UDP_NAT_ProbeMessageConfirmation | ||
175 | { | ||
176 | /** | ||
177 | * Message header | ||
178 | */ | ||
179 | struct GNUNET_MessageHeader header; | ||
180 | |||
181 | }; | ||
182 | |||
183 | |||
184 | |||
185 | /** | ||
186 | * UDP NAT "Session" | ||
187 | */ | ||
188 | struct PeerSession | ||
189 | { | ||
190 | |||
191 | /** | ||
192 | * Stored in a linked list. | ||
193 | */ | ||
194 | struct PeerSession *next; | ||
195 | |||
196 | /** | ||
197 | * Pointer to the global plugin struct. | ||
198 | */ | ||
199 | struct Plugin *plugin; | ||
200 | |||
201 | /** | ||
202 | * To whom are we talking to (set to our identity | ||
203 | * if we are still waiting for the welcome message) | ||
204 | */ | ||
205 | struct GNUNET_PeerIdentity target; | ||
206 | |||
207 | /** | ||
208 | * Address of the other peer (either based on our 'connect' | ||
209 | * call or on our 'accept' call). | ||
210 | */ | ||
211 | void *connect_addr; | ||
212 | |||
213 | /** | ||
214 | * Length of connect_addr. | ||
215 | */ | ||
216 | size_t connect_alen; | ||
217 | |||
218 | /** | ||
219 | * Are we still expecting the welcome message? (GNUNET_YES/GNUNET_NO) | ||
220 | */ | ||
221 | int expecting_welcome; | ||
222 | |||
223 | /** | ||
224 | * From which socket do we need to send to this peer? | ||
225 | */ | ||
226 | struct GNUNET_NETWORK_Handle *sock; | ||
227 | |||
228 | /* | ||
229 | * Queue of messages for this peer, in the case that | ||
230 | * we have to await a connection... | ||
231 | */ | ||
232 | struct MessageQueue *messages; | ||
233 | |||
234 | }; | ||
235 | |||
236 | struct UDP_NAT_Probes | ||
237 | { | ||
238 | |||
239 | /** | ||
240 | * Linked list | ||
241 | */ | ||
242 | struct UDP_NAT_Probes *next; | ||
243 | |||
244 | /** | ||
245 | * Address string that the server process returned to us | ||
246 | */ | ||
247 | char *address_string; | ||
248 | |||
249 | /** | ||
250 | * Timeout for this set of probes | ||
251 | */ | ||
252 | struct GNUNET_TIME_Absolute timeout; | ||
253 | |||
254 | /** | ||
255 | * Count of how many probes we've attempted | ||
256 | */ | ||
257 | int count; | ||
258 | |||
259 | /** | ||
260 | * The plugin this probe belongs to | ||
261 | */ | ||
262 | struct Plugin *plugin; | ||
263 | |||
264 | /** | ||
265 | * The task used to send these probes | ||
266 | */ | ||
267 | GNUNET_SCHEDULER_TaskIdentifier task; | ||
268 | |||
269 | /** | ||
270 | * Network address (always ipv4) | ||
271 | */ | ||
272 | struct sockaddr_in sock_addr; | ||
273 | |||
274 | /** | ||
275 | * The port to send this probe to, 0 to choose randomly | ||
276 | */ | ||
277 | int port; | ||
278 | |||
279 | }; | ||
280 | |||
281 | |||
282 | /** | ||
283 | * Encapsulation of all of the state of the plugin. | ||
284 | */ | ||
285 | struct Plugin | ||
286 | { | ||
287 | /** | ||
288 | * Our environment. | ||
289 | */ | ||
290 | struct GNUNET_TRANSPORT_PluginEnvironment *env; | ||
291 | |||
292 | /** | ||
293 | * Handle to the network service. | ||
294 | */ | ||
295 | struct GNUNET_SERVICE_Context *service; | ||
296 | |||
297 | /* | ||
298 | * Session of peers with whom we are currently connected | ||
299 | */ | ||
300 | struct PeerSession *sessions; | ||
301 | |||
302 | /** | ||
303 | * Handle for request of hostname resolution, non-NULL if pending. | ||
304 | */ | ||
305 | struct GNUNET_RESOLVER_RequestHandle *hostname_dns; | ||
306 | |||
307 | /** | ||
308 | * ID of task used to update our addresses when one expires. | ||
309 | */ | ||
310 | GNUNET_SCHEDULER_TaskIdentifier address_update_task; | ||
311 | |||
312 | /** | ||
313 | * ID of select task | ||
314 | */ | ||
315 | GNUNET_SCHEDULER_TaskIdentifier select_task; | ||
316 | |||
317 | /** | ||
318 | * Port to listen on. | ||
319 | */ | ||
320 | uint16_t port; | ||
321 | |||
322 | /** | ||
323 | * The external address given to us by the user. Must be actual | ||
324 | * outside visible address for NAT punching to work. | ||
325 | */ | ||
326 | char *external_address; | ||
327 | |||
328 | /** | ||
329 | * The internal address given to us by the user (or discovered). | ||
330 | */ | ||
331 | char *internal_address; | ||
332 | |||
333 | /* | ||
334 | * FD Read set | ||
335 | */ | ||
336 | struct GNUNET_NETWORK_FDSet *rs; | ||
337 | |||
338 | /* | ||
339 | * stdout pipe handle for the gnunet-nat-server process | ||
340 | */ | ||
341 | struct GNUNET_DISK_PipeHandle *server_stdout; | ||
342 | |||
343 | /* | ||
344 | * stdout file handle (for reading) for the gnunet-nat-server process | ||
345 | */ | ||
346 | const struct GNUNET_DISK_FileHandle *server_stdout_handle; | ||
347 | |||
348 | /** | ||
349 | * ID of select gnunet-nat-server stdout read task | ||
350 | */ | ||
351 | GNUNET_SCHEDULER_TaskIdentifier server_read_task; | ||
352 | |||
353 | /** | ||
354 | * Is this transport configured to be behind a NAT? | ||
355 | */ | ||
356 | int behind_nat; | ||
357 | |||
358 | /** | ||
359 | * The process id of the server process (if behind NAT) | ||
360 | */ | ||
361 | pid_t server_pid; | ||
362 | |||
363 | /** | ||
364 | * Probes in flight | ||
365 | */ | ||
366 | struct UDP_NAT_Probes *probes; | ||
367 | |||
368 | }; | ||
369 | |||
370 | |||
371 | struct UDP_Sock_Info | ||
372 | { | ||
373 | /* The network handle */ | ||
374 | struct GNUNET_NETWORK_Handle *desc; | ||
375 | |||
376 | /* The port we bound to */ | ||
377 | int port; | ||
378 | }; | ||
379 | |||
380 | /* *********** globals ************* */ | ||
381 | |||
382 | /** | ||
383 | * the socket that we transmit all data with | ||
384 | */ | ||
385 | static struct UDP_Sock_Info udp_nat_sock; | ||
386 | |||
387 | |||
388 | /** | ||
389 | * Forward declaration. | ||
390 | */ | ||
391 | void | ||
392 | udp_probe_continuation (void *cls, const struct GNUNET_PeerIdentity *target, int result); | ||
393 | |||
394 | |||
395 | /** | ||
396 | * Disconnect from a remote node. Clean up session if we have one for this peer | ||
397 | * | ||
398 | * @param cls closure for this call (should be handle to Plugin) | ||
399 | * @param target the peeridentity of the peer to disconnect | ||
400 | * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed | ||
401 | */ | ||
402 | void | ||
403 | udp_nat_disconnect (void *cls, const struct GNUNET_PeerIdentity *target) | ||
404 | { | ||
405 | /** TODO: Implement! */ | ||
406 | return; | ||
407 | } | ||
408 | |||
409 | /** | ||
410 | * Shutdown the server process (stop receiving inbound traffic). Maybe | ||
411 | * restarted later! | ||
412 | * | ||
413 | * @param cls Handle to the plugin for this transport | ||
414 | * | ||
415 | * @return returns the number of sockets successfully closed, | ||
416 | * should equal the number of sockets successfully opened | ||
417 | */ | ||
418 | static int | ||
419 | udp_nat_transport_server_stop (void *cls) | ||
420 | { | ||
421 | struct Plugin *plugin = cls; | ||
422 | int ret; | ||
423 | int ok; | ||
424 | |||
425 | ret = 0; | ||
426 | if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK) | ||
427 | { | ||
428 | GNUNET_SCHEDULER_cancel (plugin->env->sched, plugin->select_task); | ||
429 | plugin->select_task = GNUNET_SCHEDULER_NO_TASK; | ||
430 | } | ||
431 | |||
432 | |||
433 | ok = GNUNET_NETWORK_socket_close (udp_nat_sock.desc); | ||
434 | if (ok == GNUNET_OK) | ||
435 | udp_nat_sock.desc = NULL; | ||
436 | ret += ok; | ||
437 | |||
438 | |||
439 | if (plugin->behind_nat == GNUNET_YES) | ||
440 | { | ||
441 | if (0 != PLIBC_KILL (plugin->server_pid, SIGTERM)) | ||
442 | { | ||
443 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | ||
444 | } | ||
445 | GNUNET_OS_process_wait (plugin->server_pid); | ||
446 | } | ||
447 | |||
448 | if (ret != GNUNET_OK) | ||
449 | return GNUNET_SYSERR; | ||
450 | return ret; | ||
451 | } | ||
452 | |||
453 | |||
454 | struct PeerSession * | ||
455 | find_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *peer) | ||
456 | { | ||
457 | struct PeerSession *pos; | ||
458 | |||
459 | pos = plugin->sessions; | ||
460 | while (pos != NULL) | ||
461 | { | ||
462 | if (memcmp(&pos->target, peer, sizeof(struct GNUNET_PeerIdentity)) == 0) | ||
463 | return pos; | ||
464 | pos = pos->next; | ||
465 | } | ||
466 | |||
467 | return pos; | ||
468 | } | ||
469 | |||
470 | |||
471 | /** | ||
472 | * Actually send out the message, assume we've got the address and | ||
473 | * send_handle squared away! | ||
474 | * | ||
475 | * @param cls closure | ||
476 | * @param send_handle which handle to send message on | ||
477 | * @param target who should receive this message (ignored by UDP) | ||
478 | * @param msgbuf one or more GNUNET_MessageHeader(s) strung together | ||
479 | * @param msgbuf_size the size of the msgbuf to send | ||
480 | * @param priority how important is the message (ignored by UDP) | ||
481 | * @param timeout when should we time out (give up) if we can not transmit? | ||
482 | * @param addr the addr to send the message to, needs to be a sockaddr for us | ||
483 | * @param addrlen the len of addr | ||
484 | * @param cont continuation to call once the message has | ||
485 | * been transmitted (or if the transport is ready | ||
486 | * for the next transmission call; or if the | ||
487 | * peer disconnected...) | ||
488 | * @param cont_cls closure for cont | ||
489 | * @return the number of bytes written | ||
490 | */ | ||
491 | static ssize_t | ||
492 | udp_nat_real_send (void *cls, | ||
493 | struct GNUNET_NETWORK_Handle *send_handle, | ||
494 | const struct GNUNET_PeerIdentity *target, | ||
495 | const char *msgbuf, | ||
496 | size_t msgbuf_size, | ||
497 | unsigned int priority, | ||
498 | struct GNUNET_TIME_Relative timeout, | ||
499 | const void *addr, | ||
500 | size_t addrlen, | ||
501 | GNUNET_TRANSPORT_TransmitContinuation cont, | ||
502 | void *cont_cls) | ||
503 | { | ||
504 | struct Plugin *plugin = cls; | ||
505 | struct UDPMessage *message; | ||
506 | int ssize; | ||
507 | ssize_t sent; | ||
508 | |||
509 | if ((addr == NULL) || (addrlen == 0)) | ||
510 | { | ||
511 | #if DEBUG_UDP_NAT | ||
512 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | ||
513 | ("udp_nat_plugin_send called without address, returning!\n")); | ||
514 | #endif | ||
515 | cont (cont_cls, target, GNUNET_SYSERR); | ||
516 | return 0; /* Can never send if we don't have an address!! */ | ||
517 | } | ||
518 | |||
519 | /* Build the message to be sent */ | ||
520 | message = GNUNET_malloc (sizeof (struct UDPMessage) + msgbuf_size); | ||
521 | ssize = sizeof (struct UDPMessage) + msgbuf_size; | ||
522 | |||
523 | message->header.size = htons (ssize); | ||
524 | message->header.type = htons (0); | ||
525 | memcpy (&message->sender, plugin->env->my_identity, | ||
526 | sizeof (struct GNUNET_PeerIdentity)); | ||
527 | memcpy (&message[1], msgbuf, msgbuf_size); | ||
528 | |||
529 | /* Actually send the message */ | ||
530 | sent = | ||
531 | GNUNET_NETWORK_socket_sendto (send_handle, message, ssize, | ||
532 | addr, | ||
533 | addrlen); | ||
534 | |||
535 | if (cont != NULL) | ||
536 | { | ||
537 | if (sent == GNUNET_SYSERR) | ||
538 | cont (cont_cls, target, GNUNET_SYSERR); | ||
539 | else | ||
540 | { | ||
541 | cont (cont_cls, target, GNUNET_OK); | ||
542 | } | ||
543 | } | ||
544 | |||
545 | GNUNET_free (message); | ||
546 | return sent; | ||
547 | } | ||
548 | |||
549 | /** | ||
550 | * We learned about a peer (possibly behind NAT) so run the | ||
551 | * gnunet-nat-client to send dummy ICMP responses | ||
552 | * | ||
553 | * @param plugin the plugin for this transport | ||
554 | * @param addr the address of the peer | ||
555 | * @param addrlen the length of the address | ||
556 | */ | ||
557 | void | ||
558 | run_gnunet_nat_client (struct Plugin *plugin, const char *addr, size_t addrlen) | ||
559 | { | ||
560 | char inet4[INET_ADDRSTRLEN]; | ||
561 | char *address_as_string; | ||
562 | char *port_as_string; | ||
563 | pid_t pid; | ||
564 | const struct sockaddr *sa = (const struct sockaddr *)addr; | ||
565 | |||
566 | if (addrlen < sizeof (struct sockaddr)) | ||
567 | return; | ||
568 | switch (sa->sa_family) | ||
569 | { | ||
570 | case AF_INET: | ||
571 | if (addrlen != sizeof (struct sockaddr_in)) | ||
572 | return; | ||
573 | inet_ntop (AF_INET, | ||
574 | &((struct sockaddr_in *) sa)->sin_addr, | ||
575 | inet4, INET_ADDRSTRLEN); | ||
576 | address_as_string = GNUNET_strdup (inet4); | ||
577 | break; | ||
578 | case AF_INET6: | ||
579 | default: | ||
580 | return; | ||
581 | } | ||
582 | |||
583 | GNUNET_asprintf(&port_as_string, "%d", plugin->port); | ||
584 | #if DEBUG_UDP_NAT | ||
585 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
586 | _("Running gnunet-nat-client with arguments: %s %s %d\n"), plugin->external_address, address_as_string, plugin->port); | ||
587 | #endif | ||
588 | /* Start the server process */ | ||
589 | pid = GNUNET_OS_start_process(NULL, NULL, "gnunet-nat-client", "gnunet-nat-client", plugin->external_address, address_as_string, port_as_string, NULL); | ||
590 | GNUNET_free(address_as_string); | ||
591 | GNUNET_free(port_as_string); | ||
592 | GNUNET_OS_process_wait (pid); | ||
593 | } | ||
594 | |||
595 | /** | ||
596 | * Function that can be used by the transport service to transmit | ||
597 | * a message using the plugin. | ||
598 | * | ||
599 | * @param cls closure | ||
600 | * @param target who should receive this message (ignored by UDP) | ||
601 | * @param msgbuf one or more GNUNET_MessageHeader(s) strung together | ||
602 | * @param msgbuf_size the size of the msgbuf to send | ||
603 | * @param priority how important is the message (ignored by UDP) | ||
604 | * @param timeout when should we time out (give up) if we can not transmit? | ||
605 | * @param session identifier used for this session (can be NULL) | ||
606 | * @param addr the addr to send the message to, needs to be a sockaddr for us | ||
607 | * @param addrlen the len of addr | ||
608 | * @param force_address not used, we had better have an address to send to | ||
609 | * because we are stateless!! | ||
610 | * @param cont continuation to call once the message has | ||
611 | * been transmitted (or if the transport is ready | ||
612 | * for the next transmission call; or if the | ||
613 | * peer disconnected...) | ||
614 | * @param cont_cls closure for cont | ||
615 | * | ||
616 | * @return the number of bytes written (may return 0 and the message can | ||
617 | * still be transmitted later!) | ||
618 | */ | ||
619 | static ssize_t | ||
620 | udp_nat_plugin_send (void *cls, | ||
621 | const struct GNUNET_PeerIdentity *target, | ||
622 | const char *msgbuf, | ||
623 | size_t msgbuf_size, | ||
624 | unsigned int priority, | ||
625 | struct GNUNET_TIME_Relative timeout, | ||
626 | struct Session *session, | ||
627 | const void *addr, | ||
628 | size_t addrlen, | ||
629 | int force_address, | ||
630 | GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls) | ||
631 | { | ||
632 | struct Plugin *plugin = cls; | ||
633 | ssize_t sent; | ||
634 | struct MessageQueue *temp_message; | ||
635 | struct PeerSession *peer_session; | ||
636 | struct sockaddr_in *sockaddr = (struct sockaddr_in *)addr; | ||
637 | int other_peer_natd; | ||
638 | |||
639 | GNUNET_assert (NULL == session); | ||
640 | other_peer_natd = GNUNET_NO; | ||
641 | if ((sockaddr->sin_family == AF_INET) && (ntohs(sockaddr->sin_port) == 0)) | ||
642 | { | ||
643 | other_peer_natd = GNUNET_YES; | ||
644 | } | ||
645 | |||
646 | sent = 0; | ||
647 | |||
648 | if (other_peer_natd == GNUNET_YES) | ||
649 | { | ||
650 | peer_session = find_session(plugin, target); | ||
651 | if (peer_session == NULL) /* We have a new peer to add */ | ||
652 | { | ||
653 | /* | ||
654 | * The first time, we can assume we have no knowledge of a | ||
655 | * working port for this peer, call the ICMP/UDP message sender | ||
656 | * and wait... | ||
657 | */ | ||
658 | peer_session = GNUNET_malloc(sizeof(struct PeerSession)); | ||
659 | peer_session->connect_addr = GNUNET_malloc(addrlen); | ||
660 | memcpy(peer_session->connect_addr, addr, addrlen); | ||
661 | peer_session->connect_alen = addrlen; | ||
662 | peer_session->plugin = plugin; | ||
663 | peer_session->sock = NULL; | ||
664 | memcpy(&peer_session->target, target, sizeof(struct GNUNET_PeerIdentity)); | ||
665 | peer_session->expecting_welcome = GNUNET_YES; | ||
666 | |||
667 | peer_session->next = plugin->sessions; | ||
668 | plugin->sessions = peer_session; | ||
669 | |||
670 | peer_session->messages = GNUNET_malloc(sizeof(struct MessageQueue)); | ||
671 | peer_session->messages->msgbuf = GNUNET_malloc(msgbuf_size); | ||
672 | memcpy(peer_session->messages->msgbuf, msgbuf, msgbuf_size); | ||
673 | peer_session->messages->msgbuf_size = msgbuf_size; | ||
674 | peer_session->messages->next = NULL; | ||
675 | peer_session->messages->timeout = GNUNET_TIME_relative_to_absolute(timeout); | ||
676 | peer_session->messages->cont = cont; | ||
677 | peer_session->messages->cont_cls = cont_cls; | ||
678 | #if DEBUG_UDP_NAT | ||
679 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
680 | _("Other peer is NAT'd, set up peer session for peer %s\n"), GNUNET_i2s(target)); | ||
681 | #endif | ||
682 | run_gnunet_nat_client(plugin, addr, addrlen); | ||
683 | } | ||
684 | else | ||
685 | { | ||
686 | if (peer_session->expecting_welcome == GNUNET_NO) /* We are "connected" */ | ||
687 | { | ||
688 | sent = udp_nat_real_send(cls, peer_session->sock, target, msgbuf, msgbuf_size, priority, timeout, peer_session->connect_addr, peer_session->connect_alen, cont, cont_cls); | ||
689 | } | ||
690 | else /* Haven't gotten a response from this peer, queue message */ | ||
691 | { | ||
692 | temp_message = GNUNET_malloc(sizeof(struct MessageQueue)); | ||
693 | temp_message->msgbuf = GNUNET_malloc(msgbuf_size); | ||
694 | memcpy(temp_message->msgbuf, msgbuf, msgbuf_size); | ||
695 | temp_message->msgbuf_size = msgbuf_size; | ||
696 | temp_message->timeout = GNUNET_TIME_relative_to_absolute(timeout); | ||
697 | temp_message->cont = cont; | ||
698 | temp_message->cont_cls = cont_cls; | ||
699 | temp_message->next = peer_session->messages; | ||
700 | peer_session->messages = temp_message; | ||
701 | } | ||
702 | } | ||
703 | } | ||
704 | else /* Other peer not behind a NAT, so we can just send the message as is */ | ||
705 | { | ||
706 | sent = udp_nat_real_send(cls, udp_nat_sock.desc, target, msgbuf, msgbuf_size, priority, timeout, addr, addrlen, cont, cont_cls); | ||
707 | } | ||
708 | |||
709 | if (sent == GNUNET_SYSERR) | ||
710 | return 0; | ||
711 | |||
712 | return sent; | ||
713 | } | ||
714 | |||
715 | |||
716 | /** | ||
717 | * Add the IP of our network interface to the list of | ||
718 | * our external IP addresses. | ||
719 | */ | ||
720 | static int | ||
721 | process_interfaces (void *cls, | ||
722 | const char *name, | ||
723 | int isDefault, | ||
724 | const struct sockaddr *addr, socklen_t addrlen) | ||
725 | { | ||
726 | struct Plugin *plugin = cls; | ||
727 | int af; | ||
728 | struct sockaddr_in *v4; | ||
729 | struct sockaddr_in6 *v6; | ||
730 | |||
731 | af = addr->sa_family; | ||
732 | if (af == AF_INET) | ||
733 | { | ||
734 | v4 = (struct sockaddr_in *) addr; | ||
735 | if (plugin->behind_nat == GNUNET_YES) | ||
736 | { | ||
737 | GNUNET_assert(inet_pton(AF_INET, plugin->external_address, &v4->sin_addr) == GNUNET_OK); | ||
738 | v4->sin_port = htons (0); /* Indicates to receiver we are behind NAT */ | ||
739 | } | ||
740 | else | ||
741 | v4->sin_port = htons (plugin->port); | ||
742 | } | ||
743 | else | ||
744 | { | ||
745 | GNUNET_assert (af == AF_INET6); | ||
746 | v6 = (struct sockaddr_in6 *) addr; | ||
747 | if (plugin->behind_nat == GNUNET_YES) | ||
748 | v6->sin6_port = htons (0); | ||
749 | else | ||
750 | v6->sin6_port = htons (plugin->port); | ||
751 | } | ||
752 | |||
753 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO | | ||
754 | GNUNET_ERROR_TYPE_BULK, | ||
755 | "udp-nat", _("Found address `%s' (%s)\n"), | ||
756 | GNUNET_a2s (addr, addrlen), name); | ||
757 | plugin->env->notify_address (plugin->env->cls, | ||
758 | "udp_nat", | ||
759 | addr, addrlen, GNUNET_TIME_UNIT_FOREVER_REL); | ||
760 | |||
761 | return GNUNET_OK; | ||
762 | } | ||
763 | |||
764 | |||
765 | /** | ||
766 | * Function called by the resolver for each address obtained from DNS | ||
767 | * for our own hostname. Add the addresses to the list of our | ||
768 | * external IP addresses. | ||
769 | * | ||
770 | * @param cls closure | ||
771 | * @param addr one of the addresses of the host, NULL for the last address | ||
772 | * @param addrlen length of the address | ||
773 | */ | ||
774 | static void | ||
775 | process_hostname_ips (void *cls, | ||
776 | const struct sockaddr *addr, socklen_t addrlen) | ||
777 | { | ||
778 | struct Plugin *plugin = cls; | ||
779 | |||
780 | if (addr == NULL) | ||
781 | { | ||
782 | plugin->hostname_dns = NULL; | ||
783 | return; | ||
784 | } | ||
785 | process_interfaces (plugin, "<hostname>", GNUNET_YES, addr, addrlen); | ||
786 | } | ||
787 | |||
788 | |||
789 | /** | ||
790 | * Send UDP probe messages or UDP keepalive messages, depending on the | ||
791 | * state of the connection. | ||
792 | * | ||
793 | * @param cls closure for this call (should be the main Plugin) | ||
794 | * @param tc task context for running this | ||
795 | */ | ||
796 | static void | ||
797 | send_udp_probe_message (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
798 | { | ||
799 | struct UDP_NAT_Probes *probe = cls; | ||
800 | struct UDP_NAT_ProbeMessage *message; | ||
801 | struct Plugin *plugin = probe->plugin; | ||
802 | |||
803 | message = GNUNET_malloc(sizeof(struct UDP_NAT_ProbeMessage)); | ||
804 | message->header.size = htons(sizeof(struct UDP_NAT_ProbeMessage)); | ||
805 | message->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE); | ||
806 | /* If they gave us a port, use that. If not, try our port. */ | ||
807 | if (probe->port != 0) | ||
808 | probe->sock_addr.sin_port = htons(probe->port); | ||
809 | else | ||
810 | probe->sock_addr.sin_port = htons(plugin->port); | ||
811 | |||
812 | #if DEBUG_UDP_NAT | ||
813 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
814 | _("Sending a probe to port %d\n"), ntohs(probe->sock_addr.sin_port)); | ||
815 | #endif | ||
816 | |||
817 | probe->count++; | ||
818 | |||
819 | udp_nat_real_send(plugin, udp_nat_sock.desc, NULL, | ||
820 | (char *)message, ntohs(message->header.size), 0, | ||
821 | GNUNET_TIME_relative_get_unit(), | ||
822 | &probe->sock_addr, sizeof(probe->sock_addr), | ||
823 | &udp_probe_continuation, probe); | ||
824 | |||
825 | GNUNET_free(message); | ||
826 | } | ||
827 | |||
828 | |||
829 | /** | ||
830 | * Continuation for probe sends. If the last probe was sent | ||
831 | * "successfully", schedule sending of another one. If not, | ||
832 | * | ||
833 | */ | ||
834 | void | ||
835 | udp_probe_continuation (void *cls, const struct GNUNET_PeerIdentity *target, int result) | ||
836 | { | ||
837 | struct UDP_NAT_Probes *probe = cls; | ||
838 | struct Plugin *plugin = probe->plugin; | ||
839 | |||
840 | if ((result == GNUNET_OK) && (probe->count < MAX_PROBES)) | ||
841 | { | ||
842 | #if DEBUG_UDP_NAT | ||
843 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
844 | _("Scheduling next probe for 10000 milliseconds\n")); | ||
845 | #endif | ||
846 | probe->task = GNUNET_SCHEDULER_add_delayed(plugin->env->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 10000), &send_udp_probe_message, probe); | ||
847 | } | ||
848 | else /* Destroy the probe context. */ | ||
849 | { | ||
850 | #if DEBUG_UDP_NAT | ||
851 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
852 | _("Sending probe didn't go well...\n")); | ||
853 | #endif | ||
854 | } | ||
855 | } | ||
856 | |||
857 | /** | ||
858 | * Find probe message by address | ||
859 | * | ||
860 | * @param plugin the plugin for this transport | ||
861 | * @param address_string the ip address as a string | ||
862 | */ | ||
863 | struct UDP_NAT_Probes * | ||
864 | find_probe(struct Plugin *plugin, char * address_string) | ||
865 | { | ||
866 | struct UDP_NAT_Probes *pos; | ||
867 | |||
868 | pos = plugin->probes; | ||
869 | while (pos != NULL) | ||
870 | if (strcmp(pos->address_string, address_string) == 0) | ||
871 | return pos; | ||
872 | |||
873 | return pos; | ||
874 | } | ||
875 | |||
876 | |||
877 | /* | ||
878 | * @param cls the plugin handle | ||
879 | * @param tc the scheduling context (for rescheduling this function again) | ||
880 | * | ||
881 | * We have been notified that gnunet-nat-server has written something to stdout. | ||
882 | * Handle the output, then reschedule this function to be called again once | ||
883 | * more is available. | ||
884 | * | ||
885 | */ | ||
886 | static void | ||
887 | udp_nat_plugin_server_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
888 | { | ||
889 | struct Plugin *plugin = cls; | ||
890 | char mybuf[40]; | ||
891 | ssize_t bytes; | ||
892 | memset(&mybuf, 0, sizeof(mybuf)); | ||
893 | int i; | ||
894 | struct UDP_NAT_Probes *temp_probe; | ||
895 | int port; | ||
896 | char *port_start; | ||
897 | bytes = GNUNET_DISK_file_read(plugin->server_stdout_handle, &mybuf, sizeof(mybuf)); | ||
898 | |||
899 | if (bytes < 1) | ||
900 | { | ||
901 | #if DEBUG_UDP_NAT | ||
902 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
903 | _("Finished reading from server stdout with code: %d\n"), bytes); | ||
904 | #endif | ||
905 | return; | ||
906 | } | ||
907 | |||
908 | port = 0; | ||
909 | port_start = NULL; | ||
910 | for (i = 0; i < sizeof(mybuf); i++) | ||
911 | { | ||
912 | if (mybuf[i] == '\n') | ||
913 | mybuf[i] = '\0'; | ||
914 | |||
915 | if ((mybuf[i] == ':') && (i + 1 < sizeof(mybuf))) | ||
916 | { | ||
917 | mybuf[i] = '\0'; | ||
918 | port_start = &mybuf[i + 1]; | ||
919 | } | ||
920 | } | ||
921 | |||
922 | if (port_start != NULL) | ||
923 | port = atoi(port_start); | ||
924 | |||
925 | #if DEBUG_UDP_NAT | ||
926 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
927 | _("nat-server-read read: %s port %d\n"), &mybuf, port); | ||
928 | #endif | ||
929 | |||
930 | /** We have received an ICMP response, ostensibly from a non-NAT'd peer | ||
931 | * that wants to connect to us! Send a message to establish a connection. | ||
932 | */ | ||
933 | temp_probe = find_probe(plugin, &mybuf[0]); | ||
934 | |||
935 | if (temp_probe == NULL) | ||
936 | { | ||
937 | temp_probe = GNUNET_malloc(sizeof(struct UDP_NAT_Probes)); | ||
938 | temp_probe->address_string = strdup(&mybuf[0]); | ||
939 | temp_probe->sock_addr.sin_family = AF_INET; | ||
940 | GNUNET_assert(inet_pton(AF_INET, &mybuf[0], &temp_probe->sock_addr.sin_addr) == 1); | ||
941 | temp_probe->port = port; | ||
942 | temp_probe->next = plugin->probes; | ||
943 | temp_probe->plugin = plugin; | ||
944 | temp_probe->task = GNUNET_SCHEDULER_add_delayed(plugin->env->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 500), &send_udp_probe_message, temp_probe); | ||
945 | plugin->probes = temp_probe; | ||
946 | } | ||
947 | |||
948 | plugin->server_read_task = | ||
949 | GNUNET_SCHEDULER_add_read_file (plugin->env->sched, | ||
950 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
951 | plugin->server_stdout_handle, &udp_nat_plugin_server_read, plugin); | ||
952 | |||
953 | } | ||
954 | |||
955 | |||
956 | /** | ||
957 | * Demultiplexer for UDP NAT messages | ||
958 | * | ||
959 | * @param plugin the main plugin for this transport | ||
960 | * @param sender from which peer the message was received | ||
961 | * @param currhdr pointer to the header of the message | ||
962 | * @param sender_addr the address from which the message was received | ||
963 | * @param fromlen the length of the address | ||
964 | * @param sockinfo which socket did we receive the message on | ||
965 | */ | ||
966 | static void | ||
967 | udp_nat_demultiplexer(struct Plugin *plugin, struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *currhdr, struct sockaddr_storage *sender_addr, socklen_t fromlen, struct UDP_Sock_Info *sockinfo) | ||
968 | { | ||
969 | struct UDP_NAT_ProbeMessageReply *outgoing_probe_reply; | ||
970 | struct UDP_NAT_ProbeMessageConfirmation *outgoing_probe_confirmation; | ||
971 | |||
972 | char addr_buf[INET_ADDRSTRLEN]; | ||
973 | struct UDP_NAT_Probes *outgoing_probe; | ||
974 | struct PeerSession *peer_session; | ||
975 | struct MessageQueue *pending_message; | ||
976 | struct MessageQueue *pending_message_temp; | ||
977 | |||
978 | if (memcmp(sender, plugin->env->my_identity, sizeof(struct GNUNET_PeerIdentity)) == 0) | ||
979 | { | ||
980 | #if DEBUG_UDP_NAT | ||
981 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
982 | _("Received a message from myself, dropping!!!\n")); | ||
983 | #endif | ||
984 | return; | ||
985 | } | ||
986 | |||
987 | switch (ntohs(currhdr->type)) | ||
988 | { | ||
989 | case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE: | ||
990 | /* Send probe reply */ | ||
991 | outgoing_probe_reply = GNUNET_malloc(sizeof(struct UDP_NAT_ProbeMessageReply)); | ||
992 | outgoing_probe_reply->header.size = htons(sizeof(struct UDP_NAT_ProbeMessageReply)); | ||
993 | outgoing_probe_reply->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_REPLY); | ||
994 | |||
995 | #if DEBUG_UDP_NAT | ||
996 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
997 | _("Received a probe on listen port %d, sent_from port %d\n"), sockinfo->port, ntohs(((struct sockaddr_in *)sender_addr)->sin_port)); | ||
998 | #endif | ||
999 | |||
1000 | udp_nat_real_send(plugin, sockinfo->desc, NULL, | ||
1001 | (char *)outgoing_probe_reply, | ||
1002 | ntohs(outgoing_probe_reply->header.size), 0, | ||
1003 | GNUNET_TIME_relative_get_unit(), | ||
1004 | sender_addr, fromlen, | ||
1005 | NULL, NULL); | ||
1006 | |||
1007 | #if DEBUG_UDP_NAT | ||
1008 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
1009 | _("Sent PROBE REPLY to port %d on outgoing port %d\n"), ntohs(((struct sockaddr_in *)sender_addr)->sin_port), sockinfo->port); | ||
1010 | #endif | ||
1011 | GNUNET_free(outgoing_probe_reply); | ||
1012 | break; | ||
1013 | case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_REPLY: | ||
1014 | /* Check for existing probe, check ports returned, send confirmation if all is well */ | ||
1015 | #if DEBUG_UDP_NAT | ||
1016 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
1017 | _("Received PROBE REPLY from port %d on incoming port %d\n"), ntohs(((struct sockaddr_in *)sender_addr)->sin_port), sockinfo->port); | ||
1018 | #endif | ||
1019 | /* FIXME: use nonce, then IPv6 replies could work I think... */ | ||
1020 | if (sender_addr->ss_family == AF_INET) | ||
1021 | { | ||
1022 | memset(&addr_buf, 0, sizeof(addr_buf)); | ||
1023 | inet_ntop(AF_INET, &((struct sockaddr_in *) sender_addr)->sin_addr, addr_buf, INET_ADDRSTRLEN); | ||
1024 | outgoing_probe = find_probe(plugin, &addr_buf[0]); | ||
1025 | if (outgoing_probe != NULL) | ||
1026 | { | ||
1027 | #if DEBUG_UDP_NAT | ||
1028 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
1029 | _("Sending confirmation that we were reached!\n")); | ||
1030 | #endif | ||
1031 | outgoing_probe_confirmation = GNUNET_malloc(sizeof(struct UDP_NAT_ProbeMessageConfirmation)); | ||
1032 | outgoing_probe_confirmation->header.size = htons(sizeof(struct UDP_NAT_ProbeMessageConfirmation)); | ||
1033 | outgoing_probe_confirmation->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_CONFIRM); | ||
1034 | |||
1035 | udp_nat_real_send(plugin, sockinfo->desc, NULL, (char *)outgoing_probe_confirmation, ntohs(outgoing_probe_confirmation->header.size), 0, GNUNET_TIME_relative_get_unit(), sender_addr, fromlen, NULL, NULL); | ||
1036 | |||
1037 | if (outgoing_probe->task != GNUNET_SCHEDULER_NO_TASK) | ||
1038 | { | ||
1039 | GNUNET_SCHEDULER_cancel(plugin->env->sched, outgoing_probe->task); | ||
1040 | outgoing_probe->task = GNUNET_SCHEDULER_NO_TASK; | ||
1041 | /* Schedule task to timeout and remove probe if confirmation not received */ | ||
1042 | } | ||
1043 | GNUNET_free(outgoing_probe_confirmation); | ||
1044 | } | ||
1045 | else | ||
1046 | { | ||
1047 | #if DEBUG_UDP_NAT | ||
1048 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp-nat", | ||
1049 | _("Received a probe reply, but have no record of a sent probe!\n")); | ||
1050 | #endif | ||
1051 | } | ||
1052 | } | ||
1053 | break; | ||
1054 | case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_CONFIRM: | ||
1055 | peer_session = find_session(plugin, sender); | ||
1056 | #if DEBUG_UDP_NAT | ||
1057 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
1058 | _("Looking up peer session for peer %s\n"), GNUNET_i2s(sender)); | ||
1059 | #endif | ||
1060 | if (peer_session == NULL) /* Shouldn't this NOT happen? */ | ||
1061 | { | ||
1062 | #if DEBUG_UDP_NAT | ||
1063 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", | ||
1064 | _("Peer not in list, adding (THIS MAY BE A MISTAKE) %s\n"), GNUNET_i2s(sender)); | ||
1065 | #endif | ||
1066 | peer_session = GNUNET_malloc(sizeof(struct PeerSession)); | ||
1067 | peer_session->connect_addr = GNUNET_malloc(fromlen); | ||
1068 | memcpy(peer_session->connect_addr, sender_addr, fromlen); | ||
1069 | peer_session->connect_alen = fromlen; | ||
1070 | peer_session->plugin = plugin; | ||
1071 | peer_session->sock = sockinfo->desc; | ||
1072 | memcpy(&peer_session->target, sender, sizeof(struct GNUNET_PeerIdentity)); | ||
1073 | peer_session->expecting_welcome = GNUNET_NO; | ||
1074 | |||
1075 | peer_session->next = plugin->sessions; | ||
1076 | plugin->sessions = peer_session; | ||
1077 | |||
1078 | peer_session->messages = NULL; | ||
1079 | } | ||
1080 | else if (peer_session->expecting_welcome == GNUNET_YES) | ||
1081 | { | ||
1082 | peer_session->expecting_welcome = GNUNET_NO; | ||
1083 | /* FIXME: There is no way to find this based on receiving port at the moment! */ | ||
1084 | peer_session->sock = sockinfo->desc; /* This may matter, not sure right now... */ | ||
1085 | ((struct sockaddr_in *)peer_session->connect_addr)->sin_port = ((struct sockaddr_in *) sender_addr)->sin_port; | ||
1086 | #if DEBUG_UDP_NAT | ||
1087 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp-nat", | ||
1088 | _("Received a probe confirmation, will send to peer on port %d\n"), ntohs(((struct sockaddr_in *)peer_session->connect_addr)->sin_port)); | ||
1089 | #endif | ||
1090 | if (peer_session->messages != NULL) | ||
1091 | { | ||
1092 | #if DEBUG_UDP_NAT | ||
1093 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp-nat", | ||
1094 | _("Received a probe confirmation, sending queued messages.\n")); | ||
1095 | #endif | ||
1096 | pending_message = peer_session->messages; | ||
1097 | int count = 0; | ||
1098 | while (pending_message != NULL) | ||
1099 | { | ||
1100 | #if DEBUG_UDP_NAT | ||
1101 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp-nat", | ||
1102 | _("sending queued message %d\n"), count); | ||
1103 | #endif | ||
1104 | udp_nat_real_send(plugin, peer_session->sock, &peer_session->target, pending_message->msgbuf, pending_message->msgbuf_size, 0, GNUNET_TIME_relative_get_unit(), peer_session->connect_addr, peer_session->connect_alen, pending_message->cont, pending_message->cont_cls); | ||
1105 | pending_message_temp = pending_message; | ||
1106 | pending_message = pending_message->next; | ||
1107 | GNUNET_free(pending_message_temp->msgbuf); | ||
1108 | GNUNET_free(pending_message_temp); | ||
1109 | #if DEBUG_UDP_NAT | ||
1110 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp-nat", | ||
1111 | _("finished sending queued message %d\n"), count); | ||
1112 | #endif | ||
1113 | count++; | ||
1114 | } | ||
1115 | } | ||
1116 | |||
1117 | } | ||
1118 | else | ||
1119 | { | ||
1120 | #if DEBUG_UDP_NAT | ||
1121 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp-nat", | ||
1122 | _("Received probe confirmation for already confirmed peer!\n")); | ||
1123 | #endif | ||
1124 | } | ||
1125 | /* Received confirmation, add peer with address/port specified */ | ||
1126 | break; | ||
1127 | case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_KEEPALIVE: | ||
1128 | /* Once we've sent NAT_PROBE_CONFIRM change to sending keepalives */ | ||
1129 | /* If we receive these just ignore! */ | ||
1130 | break; | ||
1131 | default: | ||
1132 | plugin->env->receive (plugin->env->cls, sender, currhdr, UDP_DIRECT_DISTANCE, | ||
1133 | NULL, (char *)sender_addr, fromlen); | ||
1134 | } | ||
1135 | |||
1136 | } | ||
1137 | |||
1138 | |||
1139 | /* | ||
1140 | * @param cls the plugin handle | ||
1141 | * @param tc the scheduling context (for rescheduling this function again) | ||
1142 | * | ||
1143 | * We have been notified that our writeset has something to read. We don't | ||
1144 | * know which socket needs to be read, so we have to check each one | ||
1145 | * Then reschedule this function to be called again once more is available. | ||
1146 | * | ||
1147 | */ | ||
1148 | static void | ||
1149 | udp_nat_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
1150 | { | ||
1151 | struct Plugin *plugin = cls; | ||
1152 | char *buf; | ||
1153 | struct UDPMessage *msg; | ||
1154 | struct GNUNET_PeerIdentity *sender; | ||
1155 | unsigned int buflen; | ||
1156 | socklen_t fromlen; | ||
1157 | struct sockaddr_storage addr; | ||
1158 | ssize_t ret; | ||
1159 | int offset; | ||
1160 | int count; | ||
1161 | int tsize; | ||
1162 | |||
1163 | char *msgbuf; | ||
1164 | const struct GNUNET_MessageHeader *currhdr; | ||
1165 | |||
1166 | buf = NULL; | ||
1167 | sender = NULL; | ||
1168 | |||
1169 | buflen = GNUNET_NETWORK_socket_recvfrom_amount (udp_nat_sock.desc); | ||
1170 | |||
1171 | if (buflen == GNUNET_NO) | ||
1172 | return; | ||
1173 | |||
1174 | buf = GNUNET_malloc (buflen); | ||
1175 | fromlen = sizeof (addr); | ||
1176 | memset (&addr, 0, fromlen); | ||
1177 | ret = | ||
1178 | GNUNET_NETWORK_socket_recvfrom (udp_nat_sock.desc, buf, buflen, | ||
1179 | (struct sockaddr *) &addr, &fromlen); | ||
1180 | |||
1181 | #if DEBUG_UDP_NAT | ||
1182 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp-nat", _ | ||
1183 | ("socket_recv returned %u, src_addr_len is %u\n"), ret, | ||
1184 | fromlen); | ||
1185 | #endif | ||
1186 | |||
1187 | if (ret <= 0) | ||
1188 | { | ||
1189 | GNUNET_free (buf); | ||
1190 | return; | ||
1191 | } | ||
1192 | msg = (struct UDPMessage *) buf; | ||
1193 | |||
1194 | #if DEBUG_UDP_NAT | ||
1195 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | ||
1196 | ("header reports message size of %d, type %d\n"), | ||
1197 | ntohs (msg->header.size), ntohs (msg->header.type)); | ||
1198 | #endif | ||
1199 | if (ntohs (msg->header.size) < sizeof (struct UDPMessage)) | ||
1200 | { | ||
1201 | GNUNET_free (buf); | ||
1202 | return; | ||
1203 | } | ||
1204 | |||
1205 | msgbuf = (char *)&msg[1]; | ||
1206 | sender = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity)); | ||
1207 | memcpy (sender, &msg->sender, sizeof (struct GNUNET_PeerIdentity)); | ||
1208 | |||
1209 | offset = 0; | ||
1210 | count = 0; | ||
1211 | tsize = ntohs (msg->header.size) - sizeof(struct UDPMessage); | ||
1212 | |||
1213 | while (offset < tsize) | ||
1214 | { | ||
1215 | currhdr = (struct GNUNET_MessageHeader *)&msgbuf[offset]; | ||
1216 | #if DEBUG_UDP_NAT | ||
1217 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | ||
1218 | ("processing msg %d: type %d, size %d at offset %d\n"), | ||
1219 | count, ntohs(currhdr->type), ntohs(currhdr->size), offset); | ||
1220 | #endif | ||
1221 | udp_nat_demultiplexer(plugin, sender, currhdr, &addr, fromlen, &udp_nat_sock); | ||
1222 | #if DEBUG_UDP_NAT | ||
1223 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _ | ||
1224 | ("processing done msg %d: type %d, size %d at offset %d\n"), | ||
1225 | count, ntohs(currhdr->type), ntohs(currhdr->size), offset); | ||
1226 | #endif | ||
1227 | offset += ntohs(currhdr->size); | ||
1228 | count++; | ||
1229 | } | ||
1230 | GNUNET_free_non_null (buf); | ||
1231 | GNUNET_free_non_null (sender); | ||
1232 | |||
1233 | |||
1234 | plugin->select_task = | ||
1235 | GNUNET_SCHEDULER_add_select (plugin->env->sched, | ||
1236 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
1237 | GNUNET_SCHEDULER_NO_TASK, | ||
1238 | GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs, | ||
1239 | NULL, &udp_nat_plugin_select, plugin); | ||
1240 | |||
1241 | } | ||
1242 | |||
1243 | /** | ||
1244 | * Create a slew of UDP sockets. If possible, use IPv6, otherwise | ||
1245 | * try IPv4. | ||
1246 | * | ||
1247 | * @param cls closure for server start, should be a struct Plugin * | ||
1248 | * | ||
1249 | * @return number of sockets created or GNUNET_SYSERR on error | ||
1250 | */ | ||
1251 | static int | ||
1252 | udp_nat_transport_server_start (void *cls) | ||
1253 | { | ||
1254 | struct Plugin *plugin = cls; | ||
1255 | struct sockaddr_in serverAddrv4; | ||
1256 | struct sockaddr_in6 serverAddrv6; | ||
1257 | struct sockaddr *serverAddr; | ||
1258 | socklen_t addrlen; | ||
1259 | int sockets_created; | ||
1260 | |||
1261 | /* Pipe to read from started processes stdout (on read end) */ | ||
1262 | plugin->server_stdout = GNUNET_DISK_pipe(GNUNET_YES); | ||
1263 | |||
1264 | sockets_created = 0; | ||
1265 | if (plugin->server_stdout == NULL) | ||
1266 | return sockets_created; | ||
1267 | |||
1268 | if (plugin->behind_nat == GNUNET_YES) | ||
1269 | { | ||
1270 | #if DEBUG_UDP_NAT | ||
1271 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | ||
1272 | "udp_nat", | ||
1273 | "Starting gnunet-nat-server process\n"); | ||
1274 | #endif | ||
1275 | /* Start the server process */ | ||
1276 | plugin->server_pid = GNUNET_OS_start_process(NULL, plugin->server_stdout, "gnunet-nat-server", "gnunet-nat-server", plugin->internal_address, NULL); | ||
1277 | if (plugin->server_pid == GNUNET_SYSERR) | ||
1278 | { | ||
1279 | #if DEBUG_UDP_NAT | ||
1280 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | ||
1281 | "udp_nat", | ||
1282 | "Failed to start gnunet-nat-server process\n"); | ||
1283 | #endif | ||
1284 | return GNUNET_SYSERR; | ||
1285 | } | ||
1286 | /* Close the write end of the read pipe */ | ||
1287 | GNUNET_DISK_pipe_close_end(plugin->server_stdout, GNUNET_DISK_PIPE_END_WRITE); | ||
1288 | |||
1289 | plugin->server_stdout_handle = GNUNET_DISK_pipe_handle(plugin->server_stdout, GNUNET_DISK_PIPE_END_READ); | ||
1290 | plugin->server_read_task = | ||
1291 | GNUNET_SCHEDULER_add_read_file (plugin->env->sched, | ||
1292 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
1293 | plugin->server_stdout_handle, &udp_nat_plugin_server_read, plugin); | ||
1294 | } | ||
1295 | |||
1296 | udp_nat_sock.desc = NULL; | ||
1297 | |||
1298 | |||
1299 | udp_nat_sock.desc = GNUNET_NETWORK_socket_create (PF_INET, SOCK_DGRAM, 17); | ||
1300 | if (NULL == udp_nat_sock.desc) | ||
1301 | { | ||
1302 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp-nat", "socket"); | ||
1303 | return sockets_created; | ||
1304 | } | ||
1305 | else | ||
1306 | { | ||
1307 | memset (&serverAddrv4, 0, sizeof (serverAddrv4)); | ||
1308 | #if HAVE_SOCKADDR_IN_SIN_LEN | ||
1309 | serverAddrv4.sin_len = sizeof (serverAddrv4); | ||
1310 | #endif | ||
1311 | serverAddrv4.sin_family = AF_INET; | ||
1312 | serverAddrv4.sin_addr.s_addr = INADDR_ANY; | ||
1313 | serverAddrv4.sin_port = htons (plugin->port); | ||
1314 | addrlen = sizeof (serverAddrv4); | ||
1315 | serverAddr = (struct sockaddr *) &serverAddrv4; | ||
1316 | #if DEBUG_UDP_NAT | ||
1317 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | ||
1318 | "udp_nat", | ||
1319 | "Binding to port %d\n", ntohs(serverAddrv4.sin_port)); | ||
1320 | #endif | ||
1321 | while (GNUNET_NETWORK_socket_bind (udp_nat_sock.desc, serverAddr, addrlen) != | ||
1322 | GNUNET_OK) | ||
1323 | { | ||
1324 | serverAddrv4.sin_port = htons (GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); /* Find a good, non-root port */ | ||
1325 | #if DEBUG_UDP_NAT | ||
1326 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | ||
1327 | "udp_nat", | ||
1328 | "Binding failed, trying new port %d\n", ntohs(serverAddrv4.sin_port)); | ||
1329 | #endif | ||
1330 | } | ||
1331 | udp_nat_sock.port = ntohs(serverAddrv4.sin_port); | ||
1332 | sockets_created++; | ||
1333 | } | ||
1334 | |||
1335 | |||
1336 | if ((udp_nat_sock.desc == NULL) && (GNUNET_YES != | ||
1337 | GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg, "GNUNETD", | ||
1338 | "DISABLE-IPV6"))) | ||
1339 | { | ||
1340 | udp_nat_sock.desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 17); | ||
1341 | if (udp_nat_sock.desc != NULL) | ||
1342 | { | ||
1343 | memset (&serverAddrv6, 0, sizeof (serverAddrv6)); | ||
1344 | #if HAVE_SOCKADDR_IN_SIN_LEN | ||
1345 | serverAddrv6.sin6_len = sizeof (serverAddrv6); | ||
1346 | #endif | ||
1347 | serverAddrv6.sin6_family = AF_INET6; | ||
1348 | serverAddrv6.sin6_addr = in6addr_any; | ||
1349 | serverAddrv6.sin6_port = htons (plugin->port); | ||
1350 | addrlen = sizeof (serverAddrv6); | ||
1351 | serverAddr = (struct sockaddr *) &serverAddrv6; | ||
1352 | sockets_created++; | ||
1353 | } | ||
1354 | } | ||
1355 | |||
1356 | plugin->rs = GNUNET_NETWORK_fdset_create (); | ||
1357 | |||
1358 | GNUNET_NETWORK_fdset_zero (plugin->rs); | ||
1359 | |||
1360 | |||
1361 | GNUNET_NETWORK_fdset_set (plugin->rs, udp_nat_sock.desc); | ||
1362 | |||
1363 | plugin->select_task = | ||
1364 | GNUNET_SCHEDULER_add_select (plugin->env->sched, | ||
1365 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
1366 | GNUNET_SCHEDULER_NO_TASK, | ||
1367 | GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs, | ||
1368 | NULL, &udp_nat_plugin_select, plugin); | ||
1369 | |||
1370 | return sockets_created; | ||
1371 | } | ||
1372 | |||
1373 | |||
1374 | /** | ||
1375 | * Check if the given port is plausible (must be either | ||
1376 | * our listen port or our advertised port). If it is | ||
1377 | * neither, we return one of these two ports at random. | ||
1378 | * | ||
1379 | * @return either in_port or a more plausible port | ||
1380 | */ | ||
1381 | static uint16_t | ||
1382 | check_port (struct Plugin *plugin, uint16_t in_port) | ||
1383 | { | ||
1384 | |||
1385 | /* FIXME: remember what ports we are using to better respond to this */ | ||
1386 | return in_port; | ||
1387 | /* | ||
1388 | for (i = plugin->starting_port; i < plugin->num_ports + plugin->starting_port; i++) | ||
1389 | { | ||
1390 | if (in_port == i) | ||
1391 | return in_port; | ||
1392 | } | ||
1393 | |||
1394 | return GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, | ||
1395 | plugin->num_ports) + plugin->starting_port; | ||
1396 | */ | ||
1397 | } | ||
1398 | |||
1399 | |||
1400 | /** | ||
1401 | * Another peer has suggested an address for this peer and transport | ||
1402 | * plugin. Check that this could be a valid address. This function | ||
1403 | * is not expected to 'validate' the address in the sense of trying to | ||
1404 | * connect to it but simply to see if the binary format is technically | ||
1405 | * legal for establishing a connection. | ||
1406 | * | ||
1407 | * @param cls closure, should be our handle to the Plugin | ||
1408 | * @param addr pointer to the address, may be modified (slightly) | ||
1409 | * @param addrlen length of addr | ||
1410 | * @return GNUNET_OK if this is a plausible address for this peer | ||
1411 | * and transport, GNUNET_SYSERR if not | ||
1412 | * | ||
1413 | */ | ||
1414 | static int | ||
1415 | udp_nat_check_address (void *cls, void *addr, size_t addrlen) | ||
1416 | { | ||
1417 | struct Plugin *plugin = cls; | ||
1418 | char buf[sizeof (struct sockaddr_in6)]; | ||
1419 | |||
1420 | struct sockaddr_in *v4; | ||
1421 | struct sockaddr_in6 *v6; | ||
1422 | |||
1423 | if ((addrlen != sizeof (struct sockaddr_in)) && | ||
1424 | (addrlen != sizeof (struct sockaddr_in6))) | ||
1425 | { | ||
1426 | GNUNET_break_op (0); | ||
1427 | return GNUNET_SYSERR; | ||
1428 | } | ||
1429 | memcpy (buf, addr, sizeof (struct sockaddr_in6)); | ||
1430 | if (addrlen == sizeof (struct sockaddr_in)) | ||
1431 | { | ||
1432 | v4 = (struct sockaddr_in *) buf; | ||
1433 | v4->sin_port = htons (check_port (plugin, ntohs (v4->sin_port))); | ||
1434 | } | ||
1435 | else | ||
1436 | { | ||
1437 | v6 = (struct sockaddr_in6 *) buf; | ||
1438 | v6->sin6_port = htons (check_port (plugin, ntohs (v6->sin6_port))); | ||
1439 | } | ||
1440 | |||
1441 | #if DEBUG_UDP_NAT | ||
1442 | GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, | ||
1443 | "udp_nat", | ||
1444 | "Informing transport service about my address `%s'.\n", | ||
1445 | GNUNET_a2s (addr, addrlen)); | ||
1446 | #endif | ||
1447 | return GNUNET_OK; | ||
1448 | } | ||
1449 | |||
1450 | |||
1451 | /** | ||
1452 | * Append our port and forward the result. | ||
1453 | */ | ||
1454 | static void | ||
1455 | append_port (void *cls, const char *hostname) | ||
1456 | { | ||
1457 | struct PrettyPrinterContext *ppc = cls; | ||
1458 | char *ret; | ||
1459 | |||
1460 | if (hostname == NULL) | ||
1461 | { | ||
1462 | ppc->asc (ppc->asc_cls, NULL); | ||
1463 | GNUNET_free (ppc); | ||
1464 | return; | ||
1465 | } | ||
1466 | GNUNET_asprintf (&ret, "%s:%d", hostname, ppc->port); | ||
1467 | ppc->asc (ppc->asc_cls, ret); | ||
1468 | GNUNET_free (ret); | ||
1469 | } | ||
1470 | |||
1471 | |||
1472 | /** | ||
1473 | * Convert the transports address to a nice, human-readable | ||
1474 | * format. | ||
1475 | * | ||
1476 | * @param cls closure | ||
1477 | * @param type name of the transport that generated the address | ||
1478 | * @param addr one of the addresses of the host, NULL for the last address | ||
1479 | * the specific address format depends on the transport | ||
1480 | * @param addrlen length of the address | ||
1481 | * @param numeric should (IP) addresses be displayed in numeric form? | ||
1482 | * @param timeout after how long should we give up? | ||
1483 | * @param asc function to call on each string | ||
1484 | * @param asc_cls closure for asc | ||
1485 | */ | ||
1486 | static void | ||
1487 | udp_nat_plugin_address_pretty_printer (void *cls, | ||
1488 | const char *type, | ||
1489 | const void *addr, | ||
1490 | size_t addrlen, | ||
1491 | int numeric, | ||
1492 | struct GNUNET_TIME_Relative timeout, | ||
1493 | GNUNET_TRANSPORT_AddressStringCallback asc, | ||
1494 | void *asc_cls) | ||
1495 | { | ||
1496 | struct Plugin *plugin = cls; | ||
1497 | const struct sockaddr_in *v4; | ||
1498 | const struct sockaddr_in6 *v6; | ||
1499 | struct PrettyPrinterContext *ppc; | ||
1500 | |||
1501 | if ((addrlen != sizeof (struct sockaddr_in)) && | ||
1502 | (addrlen != sizeof (struct sockaddr_in6))) | ||
1503 | { | ||
1504 | /* invalid address */ | ||
1505 | GNUNET_break_op (0); | ||
1506 | asc (asc_cls, NULL); | ||
1507 | return; | ||
1508 | } | ||
1509 | ppc = GNUNET_malloc (sizeof (struct PrettyPrinterContext)); | ||
1510 | ppc->asc = asc; | ||
1511 | ppc->asc_cls = asc_cls; | ||
1512 | if (addrlen == sizeof (struct sockaddr_in)) | ||
1513 | { | ||
1514 | v4 = (const struct sockaddr_in *) addr; | ||
1515 | ppc->port = ntohs (v4->sin_port); | ||
1516 | } | ||
1517 | else | ||
1518 | { | ||
1519 | v6 = (const struct sockaddr_in6 *) addr; | ||
1520 | ppc->port = ntohs (v6->sin6_port); | ||
1521 | |||
1522 | } | ||
1523 | GNUNET_RESOLVER_hostname_get (plugin->env->sched, | ||
1524 | plugin->env->cfg, | ||
1525 | addr, | ||
1526 | addrlen, | ||
1527 | !numeric, timeout, &append_port, ppc); | ||
1528 | } | ||
1529 | |||
1530 | |||
1531 | /** | ||
1532 | * The exported method. Makes the core api available via a global and | ||
1533 | * returns the udp transport API. | ||
1534 | */ | ||
1535 | void * | ||
1536 | libgnunet_plugin_transport_udp_nat_init (void *cls) | ||
1537 | { | ||
1538 | struct GNUNET_TRANSPORT_PluginEnvironment *env = cls; | ||
1539 | unsigned long long mtu; | ||
1540 | unsigned long long port; | ||
1541 | struct GNUNET_TRANSPORT_PluginFunctions *api; | ||
1542 | struct Plugin *plugin; | ||
1543 | struct GNUNET_SERVICE_Context *service; | ||
1544 | int sockets_created; | ||
1545 | int behind_nat; | ||
1546 | char *internal_address; | ||
1547 | char *external_address; | ||
1548 | |||
1549 | service = GNUNET_SERVICE_start ("transport-udp-nat", env->sched, env->cfg); | ||
1550 | if (service == NULL) | ||
1551 | { | ||
1552 | GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, "udp_nat", _ | ||
1553 | ("Failed to start service for `%s' transport plugin.\n"), | ||
1554 | "udp-nat"); | ||
1555 | return NULL; | ||
1556 | } | ||
1557 | |||
1558 | if (GNUNET_OK != | ||
1559 | GNUNET_CONFIGURATION_get_value_string (env->cfg, | ||
1560 | "transport-udp-nat", | ||
1561 | "EXTERNAL_ADDRESS", | ||
1562 | &external_address)) | ||
1563 | { | ||
1564 | GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, | ||
1565 | "udp_nat", | ||
1566 | _ | ||
1567 | ("Require EXTERNAL_ADDRESS for service `%s' in configuration!\n"), | ||
1568 | "transport-udp"); | ||
1569 | GNUNET_SERVICE_stop (service); | ||
1570 | return NULL; | ||
1571 | } | ||
1572 | |||
1573 | if (GNUNET_OK != | ||
1574 | GNUNET_CONFIGURATION_get_value_string (env->cfg, | ||
1575 | "transport-udp-nat", | ||
1576 | "INTERNAL_ADDRESS", | ||
1577 | &internal_address)) | ||
1578 | { | ||
1579 | GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, | ||
1580 | "udp_nat", | ||
1581 | _ | ||
1582 | ("Require INTERNAL_ADDRESS for service `%s' in configuration!\n"), | ||
1583 | "transport-udp"); | ||
1584 | GNUNET_SERVICE_stop (service); | ||
1585 | GNUNET_free_non_null(external_address); | ||
1586 | return NULL; | ||
1587 | } | ||
1588 | |||
1589 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (env->cfg, | ||
1590 | "transport-udp-nat", | ||
1591 | "BEHIND_NAT")) | ||
1592 | behind_nat = GNUNET_YES; /* We are behind nat (according to the user) */ | ||
1593 | else | ||
1594 | behind_nat = GNUNET_NO; /* We are not behind nat! */ | ||
1595 | |||
1596 | if (GNUNET_OK != | ||
1597 | GNUNET_CONFIGURATION_get_value_number (env->cfg, | ||
1598 | "transport-udp-nat", | ||
1599 | "PORT", | ||
1600 | &port)) | ||
1601 | port = UDP_NAT_DEFAULT_PORT; | ||
1602 | else if (port > 65535) | ||
1603 | { | ||
1604 | GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, | ||
1605 | "udp_nat", | ||
1606 | _("Given `%s' option is out of range: %llu > %u\n"), | ||
1607 | "PORT", | ||
1608 | port, | ||
1609 | 65535); | ||
1610 | GNUNET_SERVICE_stop (service); | ||
1611 | GNUNET_free_non_null(external_address); | ||
1612 | GNUNET_free_non_null(internal_address); | ||
1613 | return NULL; | ||
1614 | } | ||
1615 | |||
1616 | mtu = 1240; | ||
1617 | if (mtu < 1200) | ||
1618 | GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, | ||
1619 | "udp_nat", | ||
1620 | _("MTU %llu for `%s' is probably too low!\n"), mtu, | ||
1621 | "UDP"); | ||
1622 | |||
1623 | plugin = GNUNET_malloc (sizeof (struct Plugin)); | ||
1624 | plugin->external_address = external_address; | ||
1625 | plugin->internal_address = internal_address; | ||
1626 | plugin->port = port; | ||
1627 | plugin->behind_nat = behind_nat; | ||
1628 | plugin->env = env; | ||
1629 | |||
1630 | api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions)); | ||
1631 | api->cls = plugin; | ||
1632 | |||
1633 | api->send = &udp_nat_plugin_send; | ||
1634 | api->disconnect = &udp_nat_disconnect; | ||
1635 | api->address_pretty_printer = &udp_nat_plugin_address_pretty_printer; | ||
1636 | api->check_address = &udp_nat_check_address; | ||
1637 | |||
1638 | plugin->service = service; | ||
1639 | |||
1640 | GNUNET_OS_network_interfaces_list (&process_interfaces, plugin); | ||
1641 | plugin->hostname_dns = GNUNET_RESOLVER_hostname_resolve (env->sched, | ||
1642 | env->cfg, | ||
1643 | AF_UNSPEC, | ||
1644 | HOSTNAME_RESOLVE_TIMEOUT, | ||
1645 | &process_hostname_ips, | ||
1646 | plugin); | ||
1647 | |||
1648 | sockets_created = udp_nat_transport_server_start (plugin); | ||
1649 | |||
1650 | GNUNET_assert (sockets_created == 1); | ||
1651 | |||
1652 | return api; | ||
1653 | } | ||
1654 | |||
1655 | |||
1656 | void * | ||
1657 | libgnunet_plugin_transport_udp_nat_done (void *cls) | ||
1658 | { | ||
1659 | struct GNUNET_TRANSPORT_PluginFunctions *api = cls; | ||
1660 | struct Plugin *plugin = api->cls; | ||
1661 | |||
1662 | udp_nat_transport_server_stop (plugin); | ||
1663 | if (NULL != hostname_dns) | ||
1664 | { | ||
1665 | GNUNET_RESOLVER_request_cancel (hostname_dns); | ||
1666 | hostname_dns = NULL; | ||
1667 | } | ||
1668 | GNUNET_SERVICE_stop (plugin->service); | ||
1669 | |||
1670 | GNUNET_NETWORK_fdset_destroy (plugin->rs); | ||
1671 | GNUNET_free (plugin); | ||
1672 | GNUNET_free (api); | ||
1673 | return NULL; | ||
1674 | } | ||
1675 | |||
1676 | /* end of plugin_transport_udp.c */ | ||
diff --git a/src/transport/test_transport_api_udp_nat_peer1.conf b/src/transport/test_transport_api_udp_nat_peer1.conf index 0956c83eb..7c52dcd78 100644 --- a/src/transport/test_transport_api_udp_nat_peer1.conf +++ b/src/transport/test_transport_api_udp_nat_peer1.conf | |||
@@ -1,6 +1,6 @@ | |||
1 | [transport-udp-nat] | 1 | [transport-udp] |
2 | PORT = 12368 | 2 | PORT = 12368 |
3 | BEHIND_NAT = YES | 3 | BEHIND_NAT = NO |
4 | INTERNAL_ADDRESS = 127.0.0.1 | 4 | INTERNAL_ADDRESS = 127.0.0.1 |
5 | EXTERNAL_ADDRESS = 127.0.0.1 | 5 | EXTERNAL_ADDRESS = 127.0.0.1 |
6 | 6 | ||
@@ -36,11 +36,12 @@ MINIMUM-FRIENDS = 0 | |||
36 | AUTOSTART = NO | 36 | AUTOSTART = NO |
37 | 37 | ||
38 | [transport] | 38 | [transport] |
39 | PLUGINS = udp_nat | 39 | PLUGINS = udp |
40 | DEBUG = NO | 40 | DEBUG = NO |
41 | ACCEPT_FROM6 = ::1; | 41 | ACCEPT_FROM6 = ::1; |
42 | ACCEPT_FROM = 127.0.0.1; | 42 | ACCEPT_FROM = 127.0.0.1; |
43 | NEIGHBOUR_LIMIT = 50 | 43 | NEIGHBOUR_LIMIT = 50 |
44 | #BINARY = /home/mrwiggles/documents/research/gnunet/gnunet-ng/src/transport/.libs/gnunet-service-transport | ||
44 | BINARY = gnunet-service-transport | 45 | BINARY = gnunet-service-transport |
45 | CONFIG = $DEFAULTCONFIG | 46 | CONFIG = $DEFAULTCONFIG |
46 | HOME = $SERVICEHOME | 47 | HOME = $SERVICEHOME |
diff --git a/src/transport/test_transport_api_udp_nat_peer2.conf b/src/transport/test_transport_api_udp_nat_peer2.conf index 3dc4d672b..23cae9e9c 100644 --- a/src/transport/test_transport_api_udp_nat_peer2.conf +++ b/src/transport/test_transport_api_udp_nat_peer2.conf | |||
@@ -1,4 +1,4 @@ | |||
1 | [transport-udp-nat] | 1 | [transport-udp] |
2 | PORT = 22368 | 2 | PORT = 22368 |
3 | BEHIND_NAT = NO | 3 | BEHIND_NAT = NO |
4 | EXTERNAL_ADDRESS = 127.0.0.1 | 4 | EXTERNAL_ADDRESS = 127.0.0.1 |
@@ -33,19 +33,21 @@ MINIMUM-FRIENDS = 0 | |||
33 | AUTOSTART = NO | 33 | AUTOSTART = NO |
34 | 34 | ||
35 | [transport] | 35 | [transport] |
36 | PLUGINS = udp_nat | 36 | PLUGINS = udp |
37 | DEBUG = NO | 37 | DEBUG = NO |
38 | PREFIX = | 38 | PREFIX = |
39 | ACCEPT_FROM6 = ::1; | 39 | ACCEPT_FROM6 = ::1; |
40 | ACCEPT_FROM = 127.0.0.1; | 40 | ACCEPT_FROM = 127.0.0.1; |
41 | NEIGHBOUR_LIMIT = 50 | 41 | NEIGHBOUR_LIMIT = 50 |
42 | BINARY = gnunet-service-transport | 42 | BINARY = gnunet-service-transport |
43 | #BINARY = /home/mrwiggles/documents/research/gnunet/gnunet-ng/src/transport/.libs/gnunet-service-transport | ||
43 | CONFIG = $DEFAULTCONFIG | 44 | CONFIG = $DEFAULTCONFIG |
44 | HOME = $SERVICEHOME | 45 | HOME = $SERVICEHOME |
45 | HOSTNAME = localhost | 46 | HOSTNAME = localhost |
46 | PORT = 22365 | 47 | PORT = 22365 |
47 | UNIXPATH = /tmp/gnunet-p2-service-transport.sock | 48 | UNIXPATH = /tmp/gnunet-p2-service-transport.sock |
48 | #PREFIX = xterm -e xterm -T transport -e gdb --args | 49 | #PREFIX = xterm -e xterm -T transport -e gdb --args |
50 | #PREFIX = valgrind --track-origins=yes --leak-check=full --log-file=valgrind_udp_peer2.log | ||
49 | 51 | ||
50 | [peerinfo] | 52 | [peerinfo] |
51 | TRUST = $SERVICEHOME/data/credit/ | 53 | TRUST = $SERVICEHOME/data/credit/ |
diff --git a/src/transport/test_transport_api_udp_peer2.conf b/src/transport/test_transport_api_udp_peer2.conf index 2259e23f7..284f09b21 100644 --- a/src/transport/test_transport_api_udp_peer2.conf +++ b/src/transport/test_transport_api_udp_peer2.conf | |||
@@ -41,7 +41,7 @@ CONFIG = $DEFAULTCONFIG | |||
41 | HOME = $SERVICEHOME | 41 | HOME = $SERVICEHOME |
42 | HOSTNAME = localhost | 42 | HOSTNAME = localhost |
43 | PORT = 22365 | 43 | PORT = 22365 |
44 | UNIXPATH = /tmp/gnunet-p1-service-transport.sock | 44 | UNIXPATH = /tmp/gnunet-p2-service-transport.sock |
45 | #PREFIX = valgrind --track-origins=yes --leak-check=full --log-file=valgrind_udp_peer2.log | 45 | #PREFIX = valgrind --track-origins=yes --leak-check=full --log-file=valgrind_udp_peer2.log |
46 | 46 | ||
47 | [peerinfo] | 47 | [peerinfo] |
@@ -54,7 +54,7 @@ CONFIG = $DEFAULTCONFIG | |||
54 | HOME = $SERVICEHOME | 54 | HOME = $SERVICEHOME |
55 | HOSTNAME = localhost | 55 | HOSTNAME = localhost |
56 | PORT = 22369 | 56 | PORT = 22369 |
57 | UNIXPATH = /tmp/gnunet-p1-service-peerinfo.sock | 57 | UNIXPATH = /tmp/gnunet-p2-service-peerinfo.sock |
58 | 58 | ||
59 | [resolver] | 59 | [resolver] |
60 | ACCEPT_FROM6 = ::1; | 60 | ACCEPT_FROM6 = ::1; |
@@ -64,7 +64,7 @@ CONFIG = $DEFAULTCONFIG | |||
64 | HOME = $SERVICEHOME | 64 | HOME = $SERVICEHOME |
65 | HOSTNAME = localhost | 65 | HOSTNAME = localhost |
66 | PORT = 22364 | 66 | PORT = 22364 |
67 | UNIXPATH = /tmp/gnunet-p1-service-resolver.sock | 67 | UNIXPATH = /tmp/gnunet-p2-service-resolver.sock |
68 | 68 | ||
69 | [statistics] | 69 | [statistics] |
70 | ACCEPT_FROM6 = ::1; | 70 | ACCEPT_FROM6 = ::1; |
@@ -74,7 +74,7 @@ CONFIG = $DEFAULTCONFIG | |||
74 | HOME = $SERVICEHOME | 74 | HOME = $SERVICEHOME |
75 | HOSTNAME = localhost | 75 | HOSTNAME = localhost |
76 | PORT = 22367 | 76 | PORT = 22367 |
77 | UNIXPATH = /tmp/gnunet-p1-service-statistics.sock | 77 | UNIXPATH = /tmp/gnunet-p2-service-statistics.sock |
78 | 78 | ||
79 | [arm] | 79 | [arm] |
80 | DEFAULTSERVICES = | 80 | DEFAULTSERVICES = |
@@ -85,7 +85,7 @@ CONFIG = $DEFAULTCONFIG | |||
85 | HOME = $SERVICEHOME | 85 | HOME = $SERVICEHOME |
86 | HOSTNAME = localhost | 86 | HOSTNAME = localhost |
87 | PORT = 22366 | 87 | PORT = 22366 |
88 | UNIXPATH = /tmp/gnunet-p1-service-arm.sock | 88 | UNIXPATH = /tmp/gnunet-p2-service-arm.sock |
89 | 89 | ||
90 | [transport-tcp] | 90 | [transport-tcp] |
91 | TIMEOUT = 300000 | 91 | TIMEOUT = 300000 |