small API change: do no longer pass rarely needed GNUNET_SCHEDULER_TaskContext to...
[oweals/gnunet.git] / src / nat / nat_auto.c
1 /*
2      This file is part of GNUnet.
3      Copyright (C) 2015 GNUnet e.V.
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 3, 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., 51 Franklin Street, Fifth Floor,
18      Boston, MA 02110-1301, USA.
19 */
20
21 /**
22  * @file nat/nat_auto.c
23  * @brief functions for auto-configuration of the network
24  * @author Christian Grothoff
25  * @author Bruno Cabral
26  */
27 #include "platform.h"
28 #include "gnunet_util_lib.h"
29 #include "gnunet_resolver_service.h"
30 #include "gnunet_nat_lib.h"
31 #include "nat.h"
32
33 #define LOG(kind,...) GNUNET_log_from (kind, "nat", __VA_ARGS__)
34
35
36 /**
37  * How long do we wait for the NAT test to report success?
38  */
39 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
40
41 #define NAT_SERVER_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
42
43 /**
44  * Phases of the auto configuration.
45  */
46 enum AutoPhase
47 {
48   /**
49    * Initial start value.
50    */
51   AUTO_INIT = 0,
52
53   /**
54    * Test our external IP.
55    */
56   AUTO_EXTERNAL_IP,
57
58   /**
59    * Test our external IP.
60    */
61    AUTO_STUN,
62
63   /**
64    * Test our internal IP.
65    */
66   AUTO_LOCAL_IP,
67
68   /**
69    * Test if NAT was punched.
70    */
71   AUTO_NAT_PUNCHED,
72
73   /**
74    * Test if UPnP is working.
75    */
76   AUTO_UPNPC,
77
78   /**
79    * Test if ICMP server works.
80    */
81   AUTO_ICMP_SERVER,
82
83   /**
84    * Test if ICMP client works.
85    */
86   AUTO_ICMP_CLIENT,
87
88   /**
89    * Last phase, we're done.
90    */
91   AUTO_DONE
92
93 };
94
95
96 /**
97  * Handle to auto-configuration in progress.
98  */
99 struct GNUNET_NAT_AutoHandle
100 {
101
102   /**
103    * Handle to the active NAT test.
104    */
105   struct GNUNET_NAT_Test *tst;
106
107   /**
108    * Function to call when done.
109    */
110   GNUNET_NAT_AutoResultCallback fin_cb;
111
112   /**
113    * Closure for @e fin_cb.
114    */
115   void *fin_cb_cls;
116
117   /**
118    * Handle for active 'GNUNET_NAT_mini_get_external_ipv4'-operation.
119    */
120   struct GNUNET_NAT_ExternalHandle *eh;
121
122   /**
123    * Current configuration (with updates from previous phases)
124    */
125   struct GNUNET_CONFIGURATION_Handle *cfg;
126
127   /**
128    * Original configuration (used to calculate differences)
129    */
130   struct GNUNET_CONFIGURATION_Handle *initial_cfg;
131
132   /**
133    * Task identifier for the timeout.
134    */
135   struct GNUNET_SCHEDULER_Task * task;
136
137   /**
138    * Where are we in the test?
139    */
140   enum AutoPhase phase;
141
142
143   /**
144    * Situation of the NAT
145    */
146   enum GNUNET_NAT_Type type;
147
148   /**
149    * Do we have IPv6?
150    */
151   int have_v6;
152
153   /**
154    * UPnP already set the external ip address ?
155    */
156   int upnp_set_external_address;
157
158   /**
159    * Did the external server connected back ?
160    */
161   int connected_back;
162
163   /**
164     * Address detected by STUN
165    */
166   char* stun_ip;
167   int stun_port;
168
169   /**
170    * Internal IP is the same as the public one ?
171    */
172   int internal_ip_is_public;
173
174   /**
175    * Error code for better debugging and user feedback
176    */
177   enum GNUNET_NAT_StatusCode ret;
178 };
179
180
181
182
183
184
185 /**
186  * The listen socket of the service for IPv4
187  */
188 static struct GNUNET_NETWORK_Handle *lsock4;
189
190
191 /**
192  * The listen task ID for IPv4
193  */
194 static struct GNUNET_SCHEDULER_Task * ltask4;
195
196
197
198
199 /**
200  * The port the test service is running on (default 7895)
201  */
202 static unsigned long long port = 7895;
203
204 static char *stun_server = "stun.ekiga.net";
205 static int stun_port = 3478;
206
207
208
209 /**
210  * Run the next phase of the auto test.
211  *
212  * @param ah auto test handle
213  */
214 static void
215         next_phase (struct GNUNET_NAT_AutoHandle *ah);
216
217
218
219
220 static void
221 process_stun_reply(struct sockaddr_in* answer, struct GNUNET_NAT_AutoHandle *ah)
222 {
223
224   ah->stun_ip = inet_ntoa(answer->sin_addr);
225   ah->stun_port = ntohs(answer->sin_port);
226   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "External IP is: %s , with port %d\n", ah->stun_ip, ah->stun_port);
227
228
229   next_phase (ah);
230
231 }
232
233 /**
234  * Function that terminates the test.
235  */
236 static void
237 stop_stun ()
238 {
239   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping STUN and quitting...\n");
240
241   /* Clean task */
242   if(NULL != ltask4)
243   {
244     GNUNET_SCHEDULER_cancel (ltask4);
245     ltask4 = NULL;
246   }
247
248   /* Clean socket */
249   if(NULL != lsock4)
250   {
251     GNUNET_NETWORK_socket_close (lsock4);
252     lsock4 = NULL;
253   }
254 }
255
256 /**
257  * Activity on our incoming socket.  Read data from the
258  * incoming connection.
259  *
260  * @param cls
261  */
262 static void
263 do_udp_read (void *cls)
264 {
265   struct GNUNET_NAT_AutoHandle *ah = cls;
266   unsigned char reply_buf[1024];
267   ssize_t rlen;
268   struct sockaddr_in answer;
269   const struct GNUNET_SCHEDULER_TaskContext *tc;
270
271   tc = GNUNET_SCHEDULER_get_task_context ();
272   if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
273       (GNUNET_NETWORK_fdset_isset (tc->read_ready,
274                                    lsock4)))
275   {
276     rlen = GNUNET_NETWORK_socket_recv (lsock4, reply_buf, sizeof (reply_buf));
277
278     //Lets handle the packet
279     memset(&answer, 0, sizeof(struct sockaddr_in));
280     if(ah->phase == AUTO_NAT_PUNCHED)
281     {
282       //Destroy the connection
283       GNUNET_NETWORK_socket_close (lsock4);
284       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
285                   "The external server was able to connect back");
286       ah->connected_back = GNUNET_YES;
287       next_phase (ah);
288     }
289     else
290     {
291       if (GNUNET_OK == GNUNET_NAT_stun_handle_packet (reply_buf, rlen, &answer))
292       {
293         //Process the answer
294         process_stun_reply (&answer, ah);
295       }
296       else
297       {
298         next_phase (ah);
299       }
300     }
301   }
302   else
303   {
304     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
305                 "TIMEOUT while waiting for an answer\n");
306     if (ah->phase == AUTO_NAT_PUNCHED)
307     {
308       stop_stun();
309     }
310
311     next_phase (ah);
312   }
313
314
315
316 }
317
318
319 /**
320  * Create an IPv4 listen socket bound to our port.
321  *
322  * @return NULL on error
323  */
324 static struct GNUNET_NETWORK_Handle *
325 bind_v4 ()
326 {
327   struct GNUNET_NETWORK_Handle *ls;
328   struct sockaddr_in sa4;
329   int eno;
330
331   memset (&sa4, 0, sizeof (sa4));
332   sa4.sin_family = AF_INET;
333   sa4.sin_port = htons (port);
334 #if HAVE_SOCKADDR_IN_SIN_LEN
335     sa4.sin_len = sizeof (sa4);
336 #endif
337   ls = GNUNET_NETWORK_socket_create (AF_INET,
338                                      SOCK_DGRAM,
339                                      0);
340   if (NULL == ls)
341     return NULL;
342   if (GNUNET_OK !=
343       GNUNET_NETWORK_socket_bind (ls, (const struct sockaddr *) &sa4,
344                                   sizeof (sa4)))
345   {
346     eno = errno;
347     GNUNET_NETWORK_socket_close (ls);
348     errno = eno;
349     return NULL;
350   }
351   return ls;
352 }
353
354
355
356
357 static void request_callback (void *cls,
358                               enum GNUNET_NAT_StatusCode result)
359 {
360   // struct GNUNET_NAT_AutoHandle *ah = cls;
361
362   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Request callback: stop and quit\n");
363   stop_stun ();
364
365   // next_phase (ah); FIXME this always will be NULL, as called in test_stun()
366 };
367
368
369
370
371
372 /**
373  * Function called by NAT to report the outcome of the nat-test.
374  * Clean up and update GUI.
375  *
376  * @param cls the auto handle
377  * @param success currently always #GNUNET_OK
378  * @param emsg NULL on success, otherwise an error message
379  */
380 static void
381 result_callback (void *cls,
382                  enum GNUNET_NAT_StatusCode ret)
383 {
384   struct GNUNET_NAT_AutoHandle *ah = cls;
385
386   if (GNUNET_NAT_ERROR_SUCCESS == ret)
387     GNUNET_NAT_test_stop (ah->tst);
388   ah->tst = NULL;
389   ah->ret = ret;
390   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
391               GNUNET_NAT_ERROR_SUCCESS == ret
392               ? _("NAT traversal with ICMP Server succeeded.\n")
393               : _("NAT traversal with ICMP Server failed.\n"));
394   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_ICMP_SERVER",
395                                          GNUNET_NAT_ERROR_SUCCESS == ret ? "NO" : "YES");
396   next_phase (ah);
397 }
398
399
400 /**
401  * Main function for the connection reversal test.
402  *
403  * @param cls the `struct GNUNET_NAT_AutoHandle`
404  */
405 static void
406 reversal_test (void *cls)
407 {
408   struct GNUNET_NAT_AutoHandle *ah = cls;
409
410   ah->task = NULL;
411   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
412               _("Testing connection reversal with ICMP server.\n"));
413   GNUNET_RESOLVER_connect (ah->cfg);
414   ah->tst = GNUNET_NAT_test_start (ah->cfg, GNUNET_YES, 0, 0, TIMEOUT,
415                                    &result_callback, ah);
416 }
417
418
419 /**
420  * Set our external IPv4 address based on the UPnP.
421  *
422  *
423  * @param cls closure with our setup context
424  * @param addr the address, NULL on errors
425  * @param emsg NULL on success, otherwise an error message
426  */
427 static void
428 set_external_ipv4 (void *cls,
429                    const struct in_addr *addr,
430                    enum GNUNET_NAT_StatusCode ret)
431 {
432   struct GNUNET_NAT_AutoHandle *ah = cls;
433   char buf[INET_ADDRSTRLEN];
434
435   ah->eh = NULL;
436   ah->ret = ret;
437   if (GNUNET_NAT_ERROR_SUCCESS != ret)
438   {
439     next_phase (ah);
440     return;
441   }
442   /* enable 'behind nat' */
443   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
444               _("Detected external IP `%s'\n"),
445               inet_ntop (AF_INET,
446                          addr,
447                          buf,
448                          sizeof (buf)));
449   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "YES");
450
451   /* set external IP address */
452   if (NULL == inet_ntop (AF_INET, addr, buf, sizeof (buf)))
453   {
454     GNUNET_break (0);
455     /* actually, this should never happen, as the caller already executed just
456      * this check, but for consistency (eg: future changes in the caller)
457      * we still need to report this error...
458      */
459     ah->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID;
460     next_phase (ah);
461     return;
462   }
463   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS",
464                                          buf);
465   ah->upnp_set_external_address = GNUNET_YES;
466   next_phase (ah);
467 }
468
469
470 /**
471  * Determine our external IPv4 address.
472  *
473  * @param ah auto setup context
474  */
475 static void
476 test_external_ip (struct GNUNET_NAT_AutoHandle *ah)
477 {
478   if (GNUNET_NAT_ERROR_SUCCESS != ah->ret)
479     next_phase (ah);
480
481   // FIXME: CPS?
482   /* try to detect external IP */
483   ah->eh = GNUNET_NAT_mini_get_external_ipv4 (TIMEOUT,
484                                               &set_external_ipv4, ah);
485 }
486
487
488 /**
489  * Determine our external IPv4 address and port using an external STUN server
490  *
491  * @param ah auto setup context
492  */
493 static void
494 test_stun (struct GNUNET_NAT_AutoHandle *ah)
495 {
496
497   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running STUN test\n");
498
499   /* Get port from the configuration */
500   if (GNUNET_OK !=
501       GNUNET_CONFIGURATION_get_value_number (ah->cfg,
502                                              "transport-udp",
503                                              "PORT",
504                                              &port))
505   {
506     port = 2086;
507   }
508
509   //Lets create the socket
510   lsock4 = bind_v4 ();
511   if (NULL == lsock4)
512   {
513     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
514     next_phase(ah);
515     return;
516   }
517   else
518   {
519     //Lets call our function now when it accepts
520     ltask4 = GNUNET_SCHEDULER_add_read_net (NAT_SERVER_TIMEOUT,
521                                             lsock4, &do_udp_read, ah);
522
523   }
524
525
526   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
527               "STUN service listens on port %u\n",
528               port);
529   if (GNUNET_NO == GNUNET_NAT_stun_make_request (stun_server, stun_port,
530                                                  lsock4, &request_callback,
531                                                  NULL))
532   {
533     /*An error happened*/
534     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "STUN error, stopping\n");
535     stop_stun ();
536     next_phase (ah);
537   }
538 }
539
540
541
542 /**
543  * Process list of local IP addresses.  Find and set the
544  * one of the default interface.
545  *
546  * @param cls our `struct GNUNET_NAT_AutoHandle`
547  * @param name name of the interface (can be NULL for unknown)
548  * @param isDefault is this presumably the default interface
549  * @param addr address of this interface (can be NULL for unknown or unassigned)
550  * @param broadcast_addr the broadcast address (can be NULL for unknown or unassigned)
551  * @param netmask the network mask (can be NULL for unknown or unassigned))
552  * @param addrlen length of the @a addr and @a broadcast_addr
553  * @return GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort
554  */
555 static int
556 process_if (void *cls,
557       const char *name,
558       int isDefault,
559       const struct sockaddr *addr,
560       const struct sockaddr *broadcast_addr,
561       const struct sockaddr *netmask,
562       socklen_t addrlen)
563 {
564   struct GNUNET_NAT_AutoHandle *ah = cls;
565   const struct sockaddr_in *in;
566   char buf[INET_ADDRSTRLEN];
567
568
569   if ( (sizeof (struct sockaddr_in6) == addrlen) &&
570        (0 != memcmp (&in6addr_loopback, &((const struct sockaddr_in6 *) addr)->sin6_addr,
571                      sizeof (struct in6_addr))) &&
572        (! IN6_IS_ADDR_LINKLOCAL(&((const struct sockaddr_in6 *) addr)->sin6_addr)) )
573   {
574     ah->have_v6 = GNUNET_YES;
575     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
576                 _("This system has a global IPv6 address, setting IPv6 to supported.\n"));
577
578     return GNUNET_OK;
579   }
580   if (addrlen != sizeof (struct sockaddr_in))
581     return GNUNET_OK;
582   in = (const struct sockaddr_in *) addr;
583
584
585   /* set internal IP address */
586   if (NULL == inet_ntop (AF_INET, &in->sin_addr, buf, sizeof (buf)))
587   {
588     GNUNET_break (0);
589     return GNUNET_OK;
590   }
591   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "INTERNAL_ADDRESS",
592                                          buf);
593   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
594               _("Detected internal network address `%s'.\n"),
595               buf);
596
597
598   ah->ret = GNUNET_NAT_ERROR_SUCCESS;
599
600   /* Check if our internal IP is the same as the External detect by STUN*/
601   if(ah->stun_ip && (strcmp(buf, ah->stun_ip) == 0) )
602   {
603     ah->internal_ip_is_public = GNUNET_YES;
604     GNUNET_log (GNUNET_ERROR_TYPE_INFO,"A internal IP is the sameas the external");
605     /* No need to continue*/
606     return GNUNET_SYSERR;
607   }
608
609   /* no need to continue iteration if we found the default */
610   if (!isDefault)
611     return GNUNET_OK;
612   else
613     return GNUNET_SYSERR;
614 }
615
616
617 /**
618  * Determine our local IP addresses; detect internal IP & IPv6-support
619  *
620  * @param ah auto setup context
621  */
622 static void
623 test_local_ip (struct GNUNET_NAT_AutoHandle *ah)
624 {
625   ah->have_v6 = GNUNET_NO;
626   ah->ret = GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO; // reset to success if any of the IFs in below iterator has a valid IP
627   GNUNET_OS_network_interfaces_list (&process_if, ah);
628
629   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "DISABLEV6",
630                                          (GNUNET_YES == ah->have_v6) ? "NO" : "YES");
631   next_phase (ah);
632 }
633
634
635 /**
636  * Test if NAT has been punched
637  *
638  * @param ah auto setup context
639  */
640 static void
641 test_nat_punched (struct GNUNET_NAT_AutoHandle *ah)
642 {
643
644   struct GNUNET_CLIENT_Connection *client;
645   struct GNUNET_NAT_TestMessage msg;
646
647
648   if (ah->stun_ip)
649   {
650     LOG (GNUNET_ERROR_TYPE_INFO,
651          "Asking gnunet-nat-server to connect to `%s'\n",
652          ah->stun_ip);
653
654
655     msg.header.size = htons (sizeof (struct GNUNET_NAT_TestMessage));
656     msg.header.type = htons (GNUNET_MESSAGE_TYPE_NAT_TEST);
657     msg.dst_ipv4 = inet_addr(ah->stun_ip);
658     msg.dport = htons(ah->stun_port);
659     msg.data = port;
660     msg.is_tcp = htonl ((uint32_t) GNUNET_NO);
661
662     client = GNUNET_CLIENT_connect ("gnunet-nat-server", ah->cfg);
663     if (NULL == client)
664     {
665       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
666                   _("Failed to connect to `gnunet-nat-server'\n"));
667       return;
668     }
669
670     GNUNET_break (GNUNET_OK ==
671                   GNUNET_CLIENT_transmit_and_get_response (client, &msg.header,
672                                                            NAT_SERVER_TIMEOUT,
673                                                            GNUNET_YES, NULL,
674                                                            NULL));
675     if (NULL != ltask4)
676     {
677       GNUNET_SCHEDULER_cancel (ltask4);
678       ltask4 = GNUNET_SCHEDULER_add_read_net (NAT_SERVER_TIMEOUT,
679                                               lsock4, &do_udp_read, ah);
680     }
681
682   }
683   else
684   {
685     LOG (GNUNET_ERROR_TYPE_INFO,
686          "We don't have a STUN IP");
687     next_phase(ah);
688   }
689
690
691 }
692
693
694
695
696 /**
697  * Test if UPnPC works.
698  *
699  * @param ah auto setup context
700  */
701 static void
702 test_upnpc (struct GNUNET_NAT_AutoHandle *ah)
703 {
704
705   int have_upnpc;
706
707   if (GNUNET_NAT_ERROR_SUCCESS != ah->ret)
708     next_phase (ah);
709
710   // test if upnpc is available
711   have_upnpc = (GNUNET_SYSERR !=
712                 GNUNET_OS_check_helper_binary ("upnpc", GNUNET_NO, NULL));
713   //FIXME: test if upnpc is actually working, that is, if transports start to work once we use UPnP
714   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
715               (have_upnpc)
716               ? _("upnpc found, enabling its use\n")
717               : _("upnpc not found\n"));
718   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_UPNP",
719                                          (GNUNET_YES == have_upnpc) ? "YES" : "NO");
720   next_phase (ah);
721
722 }
723
724
725 /**
726  * Test if ICMP server is working
727  *
728  * @param ah auto setup context
729  */
730 static void
731 test_icmp_server (struct GNUNET_NAT_AutoHandle *ah)
732 {
733
734   int ext_ip;
735   int nated;
736   int binary;
737   char *tmp;
738   char *helper;
739   ext_ip = GNUNET_NO;
740   nated = GNUNET_NO;
741   binary = GNUNET_NO;
742
743   tmp = NULL;
744   helper = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-server");
745   if ((GNUNET_OK ==
746         GNUNET_CONFIGURATION_get_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS",
747                                                &tmp)) && (0 < strlen (tmp))){
748     ext_ip = GNUNET_OK;
749     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("test_icmp_server not possible, as we have no public IPv4 address\n"));
750   }
751   else
752     goto err;
753
754   if (GNUNET_YES ==
755         GNUNET_CONFIGURATION_get_value_yesno (ah->cfg, "nat", "BEHIND_NAT")){
756     nated = GNUNET_YES;
757     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("test_icmp_server not possible, as we are not behind NAT\n"));
758   }
759   else
760     goto err;
761
762   if (GNUNET_YES ==
763         GNUNET_OS_check_helper_binary (helper, GNUNET_YES, "-d 127.0.0.1" )){
764     binary = GNUNET_OK; // use localhost as source for that one udp-port, ok for testing
765     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("No working gnunet-helper-nat-server found\n"));
766   }
767 err:
768   GNUNET_free_non_null (tmp);
769   GNUNET_free (helper);
770
771   if (GNUNET_OK == ext_ip && GNUNET_YES == nated && GNUNET_OK == binary)
772     ah->task = GNUNET_SCHEDULER_add_now (&reversal_test, ah);
773   else
774     next_phase (ah);
775
776 }
777
778
779 /**
780  * Test if ICMP client is working
781  *
782  * @param ah auto setup context
783  */
784 static void
785 test_icmp_client (struct GNUNET_NAT_AutoHandle *ah)
786 {
787
788
789   char *tmp;
790   char *helper;
791
792   tmp = NULL;
793   helper = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-client");
794   if ((GNUNET_OK ==
795         GNUNET_CONFIGURATION_get_value_string (ah->cfg, "nat", "INTERNAL_ADDRESS",
796                                                &tmp)) && (0 < strlen (tmp)))
797   {
798     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("test_icmp_client not possible, as we have no internal IPv4 address\n"));
799   }
800   else
801     goto err;
802
803   if (GNUNET_YES !=
804       GNUNET_CONFIGURATION_get_value_yesno (ah->cfg, "nat", "BEHIND_NAT")){
805     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("test_icmp_server not possible, as we are not behind NAT\n"));
806   }
807   else
808     goto err;
809
810   if (GNUNET_YES ==
811       GNUNET_OS_check_helper_binary (helper, GNUNET_YES, "-d 127.0.0.1 127.0.0.2 42")){
812           // none of these parameters are actually used in privilege testing mode
813     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("No working gnunet-helper-nat-server found\n"));
814   }
815 err:
816   GNUNET_free_non_null (tmp);
817   GNUNET_free (helper);
818
819   next_phase (ah);
820
821 }
822
823
824 /**
825  * Run the next phase of the auto test.
826  */
827 static void
828 next_phase (struct GNUNET_NAT_AutoHandle *ah)
829 {
830   struct GNUNET_CONFIGURATION_Handle *diff;
831
832   ah->phase++;
833   switch (ah->phase)
834   {
835   case AUTO_INIT:
836     GNUNET_assert (0);
837     break;
838   case AUTO_EXTERNAL_IP:
839     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_EXTERNAL_IP\n");
840     test_external_ip (ah);
841     break;
842   case AUTO_STUN:
843     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_STUN\n");
844     test_stun (ah);
845     break;
846   case AUTO_LOCAL_IP:
847     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_LOCAL_IP\n");
848     test_local_ip (ah);
849     break;
850   case AUTO_NAT_PUNCHED:
851     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_NAT_PUNCHED\n");
852     test_nat_punched (ah);
853     break;
854   case AUTO_UPNPC:
855     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_UPNPC\n");
856     test_upnpc (ah);
857     break;
858   case AUTO_ICMP_SERVER:
859     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_ICMP_SERVER\n");
860     test_icmp_server (ah);
861     break;
862   case AUTO_ICMP_CLIENT:
863     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_ICMP_CLIENT\n");
864     test_icmp_client (ah);
865     break;
866   case AUTO_DONE:
867     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Done with tests\n");
868     if (!ah->internal_ip_is_public)
869     {
870       GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "YES");
871
872       if (ah->connected_back)
873       {
874         GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "PUNCHED_NAT", "YES");
875       }
876       else
877       {
878         GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "PUNCHED_NAT", "NO");
879       }
880
881       if (ah->stun_ip)
882       {
883         GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS",
884                                                ah->stun_ip);
885         if (ah->connected_back)
886         {
887           ah->type = GNUNET_NAT_TYPE_STUN_PUNCHED_NAT;
888           GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "USE_STUN", "YES");
889         }
890         else
891         {
892           ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT;
893           GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "USE_STUN", "NO");
894         }
895
896       }
897       if (ah->stun_port)
898       {
899         GNUNET_CONFIGURATION_set_value_number (ah->cfg, "transport-udp",
900                                                "ADVERTISED_PORT",
901                                                ah->stun_port);
902       }
903
904     }
905     else
906     {
907       //The internal IP is the same as public, but we didn't got a incoming connection
908       if (ah->connected_back)
909       {
910         ah->type = GNUNET_NAT_TYPE_NO_NAT;
911         GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "NO");
912       }
913       else
914       {
915         GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "YES");
916         ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT;
917         if (ah->stun_ip)
918         {
919           GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS",
920                                                  ah->stun_ip);
921         }
922         if (ah->stun_port)
923         {
924           GNUNET_CONFIGURATION_set_value_number (ah->cfg, "transport-udp",
925                                                  "ADVERTISED_PORT",
926                                                  ah->stun_port);
927
928         }
929       }
930     }
931
932     diff = GNUNET_CONFIGURATION_get_diff (ah->initial_cfg,
933                                           ah->cfg);
934
935
936     ah->fin_cb (ah->fin_cb_cls,
937                 diff,
938                 ah->ret,
939                 ah->type);
940     GNUNET_CONFIGURATION_destroy (diff);
941     GNUNET_NAT_autoconfig_cancel (ah);
942     return;
943
944   }
945
946
947
948 }
949
950
951 /**
952  * Start auto-configuration routine.  The resolver service should
953  * be available when this function is called.
954  *
955  * @param cfg initial configuration
956  * @param cb function to call with autoconfiguration result
957  * @param cb_cls closure for @a cb
958  * @return handle to cancel operation
959  */
960 struct GNUNET_NAT_AutoHandle *
961 GNUNET_NAT_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
962                              GNUNET_NAT_AutoResultCallback cb,
963                              void *cb_cls)
964 {
965   struct GNUNET_NAT_AutoHandle *ah;
966
967   ah = GNUNET_new (struct GNUNET_NAT_AutoHandle);
968   ah->fin_cb = cb;
969   ah->fin_cb_cls = cb_cls;
970   ah->ret = GNUNET_NAT_ERROR_SUCCESS;
971   ah->cfg = GNUNET_CONFIGURATION_dup (cfg);
972   ah->initial_cfg = GNUNET_CONFIGURATION_dup (cfg);
973
974   /* never use loopback addresses if user wanted autoconfiguration */
975   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat",
976                                          "USE_LOCALADDR",
977                                          "NO");
978
979   next_phase (ah);
980   return ah;
981 }
982
983
984 /**
985  * Abort autoconfiguration.
986  *
987  * @param ah handle for operation to abort
988  */
989 void
990 GNUNET_NAT_autoconfig_cancel (struct GNUNET_NAT_AutoHandle *ah)
991 {
992   if (NULL != ah->tst)
993   {
994     GNUNET_NAT_test_stop (ah->tst);
995     ah->tst = NULL;
996   }
997   if (NULL != ah->eh)
998   {
999     GNUNET_NAT_mini_get_external_ipv4_cancel (ah->eh);
1000     ah->eh = NULL;
1001   }
1002   if (NULL != ah->task)
1003   {
1004     GNUNET_SCHEDULER_cancel (ah->task);
1005     ah->task = NULL;
1006   }
1007   GNUNET_CONFIGURATION_destroy (ah->cfg);
1008   GNUNET_CONFIGURATION_destroy (ah->initial_cfg);
1009   GNUNET_free (ah);
1010 }
1011
1012
1013 /* end of nat_auto.c */