src/nat/nat_auto.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2015 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 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 NAT and quitting...\n");
 240
 241   //Clean task
 242   if(NULL != ltask4)
 243     GNUNET_SCHEDULER_cancel (ltask4);
 244
 245   //Clean socket
 246   if(NULL != ltask4)
 247     GNUNET_NETWORK_socket_close (lsock4);
 248
 249 }
 250
 251 /**
 252  * Activity on our incoming socket.  Read data from the
 253  * incoming connection.
 254  *
 255  * @param cls
 256  * @param tc scheduler context
 257  */
 258 static void
 259 do_udp_read (void *cls,
 260              const struct GNUNET_SCHEDULER_TaskContext *tc)
 261 {
 262   struct GNUNET_NAT_AutoHandle *ah = cls;
 263   unsigned char reply_buf[1024];
 264   ssize_t rlen;
 265   struct sockaddr_in answer;
 266
 267
 268   if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
 269       (GNUNET_NETWORK_fdset_isset (tc->read_ready,
 270                                    lsock4)))
 271   {
 272     rlen = GNUNET_NETWORK_socket_recv (lsock4, reply_buf, sizeof (reply_buf));
 273
 274
 275     //Lets handle the packet
 276     memset(&answer, 0, sizeof(struct sockaddr_in));
 277
 278
 279
 280
 281
 282     if(ah->phase == AUTO_NAT_PUNCHED)
 283     {
 284       //Destroy the connection
 285       GNUNET_NETWORK_socket_close (lsock4);
 286       GNUNET_log (GNUNET_ERROR_TYPE_INFO, "The external server was able to connect back");
 287       ah->connected_back = GNUNET_YES;
 288       next_phase (ah);
 289     }
 290     else
 291     {
 292       if(GNUNET_OK == GNUNET_NAT_stun_handle_packet(reply_buf,rlen, &answer))
 293       {
 294         //Process the answer
 295         process_stun_reply(&answer, ah);
 296
 297       }
 298       else
 299       {
 300         next_phase (ah);
 301       }
 302     }
 303
 304
 305   }
 306   else
 307   {
 308     GNUNET_log (GNUNET_ERROR_TYPE_INFO, "TIMEOUT while aiting for an answer");
 309     if(ah->phase == AUTO_NAT_PUNCHED)
 310     {
 311       stop_stun();
 312     }
 313
 314     next_phase(ah);
 315   }
 316
 317
 318
 319 }
 320
 321
 322 /**
 323  * Create an IPv4 listen socket bound to our port.
 324  *
 325  * @return NULL on error
 326  */
 327 static struct GNUNET_NETWORK_Handle *
 328 bind_v4 ()
 329 {
 330   struct GNUNET_NETWORK_Handle *ls;
 331   struct sockaddr_in sa4;
 332   int eno;
 333
 334   memset (&sa4, 0, sizeof (sa4));
 335   sa4.sin_family = AF_INET;
 336   sa4.sin_port = htons (port);
 337 #if HAVE_SOCKADDR_IN_SIN_LEN
 338     sa4.sin_len = sizeof (sa4);
 339 #endif
 340   ls = GNUNET_NETWORK_socket_create (AF_INET,
 341                                      SOCK_DGRAM,
 342                                      0);
 343   if (NULL == ls)
 344     return NULL;
 345   if (GNUNET_OK !=
 346       GNUNET_NETWORK_socket_bind (ls, (const struct sockaddr *) &sa4,
 347                                   sizeof (sa4)))
 348   {
 349     eno = errno;
 350     GNUNET_NETWORK_socket_close (ls);
 351     errno = eno;
 352     return NULL;
 353   }
 354   return ls;
 355 }
 356
 357
 358
 359
 360 static void request_callback(void *cls,
 361                              enum GNUNET_NAT_StatusCode result)
 362 {
 363   struct GNUNET_NAT_AutoHandle *ah = cls;
 364   GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping NAT and quitting...\n");
 365   stop_stun();
 366
 367   next_phase(ah);
 368 };
 369
 370
 371
 372
 373
 374 /**
 375  * Function called by NAT to report the outcome of the nat-test.
 376  * Clean up and update GUI.
 377  *
 378  * @param cls the auto handle
 379  * @param success currently always #GNUNET_OK
 380  * @param emsg NULL on success, otherwise an error message
 381  */
 382 static void
 383 result_callback (void *cls,
 384                  enum GNUNET_NAT_StatusCode ret)
 385 {
 386   struct GNUNET_NAT_AutoHandle *ah = cls;
 387
 388   if (GNUNET_NAT_ERROR_SUCCESS == ret)
 389     GNUNET_NAT_test_stop (ah->tst);
 390   ah->tst = NULL;
 391   ah->ret = ret;
 392   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 393               GNUNET_NAT_ERROR_SUCCESS == ret
 394               ? _("NAT traversal with ICMP Server succeeded.\n")
 395               : _("NAT traversal with ICMP Server failed.\n"));
 396   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_ICMP_SERVER",
 397                                          GNUNET_NAT_ERROR_SUCCESS == ret ? "NO" : "YES");
 398   next_phase (ah);
 399 }
 400
 401
 402 /**
 403  * Main function for the connection reversal test.
 404  *
 405  * @param cls the `struct GNUNET_NAT_AutoHandle`
 406  * @param tc scheduler context
 407  */
 408 static void
 409 reversal_test (void *cls,
 410                const struct GNUNET_SCHEDULER_TaskContext *tc)
 411 {
 412   struct GNUNET_NAT_AutoHandle *ah = cls;
 413
 414   ah->task = NULL;
 415   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 416               _("Testing connection reversal with ICMP server.\n"));
 417   GNUNET_RESOLVER_connect (ah->cfg);
 418   ah->tst = GNUNET_NAT_test_start (ah->cfg, GNUNET_YES, 0, 0, TIMEOUT,
 419                                    &result_callback, ah);
 420 }
 421
 422
 423 /**
 424  * Set our external IPv4 address based on the UPnP.
 425  *
 426  *
 427  * @param cls closure with our setup context
 428  * @param addr the address, NULL on errors
 429  * @param emsg NULL on success, otherwise an error message
 430  */
 431 static void
 432 set_external_ipv4 (void *cls,
 433                    const struct in_addr *addr,
 434                    enum GNUNET_NAT_StatusCode ret)
 435 {
 436   struct GNUNET_NAT_AutoHandle *ah = cls;
 437   char buf[INET_ADDRSTRLEN];
 438
 439   ah->eh = NULL;
 440   ah->ret = ret;
 441   if (GNUNET_NAT_ERROR_SUCCESS != ret)
 442   {
 443     next_phase (ah);
 444     return;
 445   }
 446   /* enable 'behind nat' */
 447   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 448               _("Detected external IP `%s'\n"),
 449               inet_ntop (AF_INET,
 450                          addr,
 451                          buf,
 452                          sizeof (buf)));
 453   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "YES");
 454
 455   /* set external IP address */
 456   if (NULL == inet_ntop (AF_INET, addr, buf, sizeof (buf)))
 457   {
 458     GNUNET_break (0);
 459     /* actually, this should never happen, as the caller already executed just
 460      * this check, but for consistency (eg: future changes in the caller)
 461      * we still need to report this error...
 462      */
 463     ah->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID;
 464     next_phase (ah);
 465     return;
 466   }
 467   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS",
 468                                          buf);
 469   ah->upnp_set_external_address = GNUNET_YES;
 470   next_phase (ah);
 471 }
 472
 473
 474 /**
 475  * Determine our external IPv4 address.
 476  *
 477  * @param ah auto setup context
 478  */
 479 static void
 480 test_external_ip (struct GNUNET_NAT_AutoHandle *ah)
 481 {
 482   if (GNUNET_NAT_ERROR_SUCCESS != ah->ret)
 483     next_phase (ah);
 484
 485   // FIXME: CPS?
 486   /* try to detect external IP */
 487   ah->eh = GNUNET_NAT_mini_get_external_ipv4 (TIMEOUT,
 488                                               &set_external_ipv4, ah);
 489 }
 490
 491
 492 /**
 493  * Determine our external IPv4 address and port using an external STUN server
 494  *
 495  * @param ah auto setup context
 496  */
 497 static void
 498 test_stun (struct GNUNET_NAT_AutoHandle *ah)
 499 {
 500
 501   GNUNET_log (GNUNET_ERROR_TYPE_INFO,"Running STUN test");
 502
 503   /* Get port from the configuration */
 504   if (GNUNET_OK !=
 505       GNUNET_CONFIGURATION_get_value_number (ah->cfg,
 506                                              "transport-udp",
 507                                              "PORT",
 508                                              &port))
 509   {
 510     port = 2086;
 511   }
 512
 513   //Lets create the socket
 514   lsock4 = bind_v4 ();
 515   if (NULL == lsock4)
 516   {
 517     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
 518     next_phase(ah);
 519     return;
 520   }
 521   else
 522   {
 523     //Lets call our function now when it accepts
 524     ltask4 = GNUNET_SCHEDULER_add_read_net (NAT_SERVER_TIMEOUT,
 525                                             lsock4, &do_udp_read, ah);
 526
 527   }
 528
 529
 530   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 531               "STUN service listens on port %u\n",
 532               port);
 533   if( GNUNET_NO == GNUNET_NAT_stun_make_request(stun_server, stun_port, lsock4, &request_callback, NULL))
 534   {
 535     /*An error happened*/
 536     stop_stun();
 537     next_phase(ah);
 538   }
 539
 540
 541 }
 542
 543
 544
 545 /**
 546  * Process list of local IP addresses.  Find and set the
 547  * one of the default interface.
 548  *
 549  * @param cls our `struct GNUNET_NAT_AutoHandle`
 550  * @param name name of the interface (can be NULL for unknown)
 551  * @param isDefault is this presumably the default interface
 552  * @param addr address of this interface (can be NULL for unknown or unassigned)
 553  * @param broadcast_addr the broadcast address (can be NULL for unknown or unassigned)
 554  * @param netmask the network mask (can be NULL for unknown or unassigned))
 555  * @param addrlen length of the @a addr and @a broadcast_addr
 556  * @return GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort
 557  */
 558 static int
 559 process_if (void *cls,
 560       const char *name,
 561       int isDefault,
 562       const struct sockaddr *addr,
 563       const struct sockaddr *broadcast_addr,
 564       const struct sockaddr *netmask,
 565       socklen_t addrlen)
 566 {
 567   struct GNUNET_NAT_AutoHandle *ah = cls;
 568   const struct sockaddr_in *in;
 569   char buf[INET_ADDRSTRLEN];
 570
 571
 572   if ( (sizeof (struct sockaddr_in6) == addrlen) &&
 573        (0 != memcmp (&in6addr_loopback, &((const struct sockaddr_in6 *) addr)->sin6_addr,
 574                      sizeof (struct in6_addr))) &&
 575        (! IN6_IS_ADDR_LINKLOCAL(&((const struct sockaddr_in6 *) addr)->sin6_addr)) )
 576   {
 577     ah->have_v6 = GNUNET_YES;
 578     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 579                 _("This system has a global IPv6 address, setting IPv6 to supported.\n"));
 580
 581     return GNUNET_OK;
 582   }
 583   if (addrlen != sizeof (struct sockaddr_in))
 584     return GNUNET_OK;
 585   in = (const struct sockaddr_in *) addr;
 586
 587
 588   /* set internal IP address */
 589   if (NULL == inet_ntop (AF_INET, &in->sin_addr, buf, sizeof (buf)))
 590   {
 591     GNUNET_break (0);
 592     return GNUNET_OK;
 593   }
 594   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "INTERNAL_ADDRESS",
 595                                          buf);
 596   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 597               _("Detected internal network address `%s'.\n"),
 598               buf);
 599
 600
 601   ah->ret = GNUNET_NAT_ERROR_SUCCESS;
 602
 603   /* Check if our internal IP is the same as the External detect by STUN*/
 604   if(ah->stun_ip && (strcmp(buf, ah->stun_ip) == 0) )
 605   {
 606     ah->internal_ip_is_public = GNUNET_YES;
 607     GNUNET_log (GNUNET_ERROR_TYPE_INFO,"A internal IP is the sameas the external");
 608     /* No need to continue*/
 609     return GNUNET_SYSERR;
 610   }
 611
 612   /* no need to continue iteration if we found the default */
 613   if (!isDefault)
 614     return GNUNET_OK;
 615   else
 616     return GNUNET_SYSERR;
 617 }
 618
 619
 620 /**
 621  * Determine our local IP addresses; detect internal IP & IPv6-support
 622  *
 623  * @param ah auto setup context
 624  */
 625 static void
 626 test_local_ip (struct GNUNET_NAT_AutoHandle *ah)
 627 {
 628   ah->have_v6 = GNUNET_NO;
 629   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
 630   GNUNET_OS_network_interfaces_list (&process_if, ah);
 631
 632   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "DISABLEV6",
 633                                          (GNUNET_YES == ah->have_v6) ? "NO" : "YES");
 634   next_phase (ah);
 635 }
 636
 637
 638 /**
 639  * Test if NAT has been punched
 640  *
 641  * @param ah auto setup context
 642  */
 643 static void
 644 test_nat_punched (struct GNUNET_NAT_AutoHandle *ah)
 645 {
 646
 647   struct GNUNET_CLIENT_Connection *client;
 648   struct GNUNET_NAT_TestMessage msg;
 649
 650
 651   if(ah->stun_ip)
 652   {
 653     LOG (GNUNET_ERROR_TYPE_INFO,
 654          "Asking gnunet-nat-server to connect to `%s'\n",
 655          ah->stun_ip);
 656
 657
 658     msg.header.size = htons (sizeof (struct GNUNET_NAT_TestMessage));
 659     msg.header.type = htons (GNUNET_MESSAGE_TYPE_NAT_TEST);
 660     msg.dst_ipv4 = inet_addr(ah->stun_ip);
 661     msg.dport = htons(ah->stun_port);
 662     msg.data = port;
 663     msg.is_tcp = htonl ((uint32_t) GNUNET_NO);
 664
 665     client = GNUNET_CLIENT_connect ("gnunet-nat-server", ah->cfg);
 666     if (NULL == client)
 667     {
 668       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 669                   _("Failed to connect to `gnunet-nat-server'\n"));
 670       return;
 671     }
 672
 673     GNUNET_break (GNUNET_OK ==
 674                   GNUNET_CLIENT_transmit_and_get_response (client, &msg.header,
 675                                                            NAT_SERVER_TIMEOUT,
 676                                                            GNUNET_YES, NULL,
 677                                                            NULL));
 678     ltask4 = GNUNET_SCHEDULER_add_read_net (NAT_SERVER_TIMEOUT,
 679                                             lsock4, &do_udp_read, ah);
 680
 681   }
 682   else
 683   {
 684     LOG (GNUNET_ERROR_TYPE_INFO,
 685          "We don't have a STUN IP");
 686     next_phase(ah);
 687   }
 688
 689
 690 }
 691
 692
 693
 694
 695 /**
 696  * Test if UPnPC works.
 697  *
 698  * @param ah auto setup context
 699  */
 700 static void
 701 test_upnpc (struct GNUNET_NAT_AutoHandle *ah)
 702 {
 703
 704   int have_upnpc;
 705
 706   if (GNUNET_NAT_ERROR_SUCCESS != ah->ret)
 707     next_phase (ah);
 708
 709   // test if upnpc is available
 710   have_upnpc = (GNUNET_SYSERR !=
 711                 GNUNET_OS_check_helper_binary ("upnpc", GNUNET_NO, NULL));
 712   //FIXME: test if upnpc is actually working, that is, if transports start to work once we use UPnP
 713   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 714               (have_upnpc)
 715               ? _("upnpc found, enabling its use\n")
 716               : _("upnpc not found\n"));
 717   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_UPNP",
 718                                          (GNUNET_YES == have_upnpc) ? "YES" : "NO");
 719   next_phase (ah);
 720
 721 }
 722
 723
 724 /**
 725  * Test if ICMP server is working
 726  *
 727  * @param ah auto setup context
 728  */
 729 static void
 730 test_icmp_server (struct GNUNET_NAT_AutoHandle *ah)
 731 {
 732
 733   int ext_ip;
 734   int nated;
 735   int binary;
 736   char *tmp;
 737   char *helper;
 738   ext_ip = GNUNET_NO;
 739   nated = GNUNET_NO;
 740   binary = GNUNET_NO;
 741
 742   tmp = NULL;
 743   helper = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-server");
 744   if ((GNUNET_OK ==
 745         GNUNET_CONFIGURATION_get_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS",
 746                                                &tmp)) && (0 < strlen (tmp))){
 747     ext_ip = GNUNET_OK;
 748     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("test_icmp_server not possible, as we have no public IPv4 address\n"));
 749   }
 750   else
 751     goto err;
 752
 753   if (GNUNET_YES ==
 754         GNUNET_CONFIGURATION_get_value_yesno (ah->cfg, "nat", "BEHIND_NAT")){
 755     nated = GNUNET_YES;
 756     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("test_icmp_server not possible, as we are not behind NAT\n"));
 757   }
 758   else
 759     goto err;
 760
 761   if (GNUNET_YES ==
 762         GNUNET_OS_check_helper_binary (helper, GNUNET_YES, "-d 127.0.0.1" )){
 763     binary = GNUNET_OK; // use localhost as source for that one udp-port, ok for testing
 764     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("No working gnunet-helper-nat-server found\n"));
 765   }
 766 err:
 767   GNUNET_free_non_null (tmp);
 768   GNUNET_free (helper);
 769
 770   if (GNUNET_OK == ext_ip && GNUNET_YES == nated && GNUNET_OK == binary)
 771     ah->task = GNUNET_SCHEDULER_add_now (&reversal_test, ah);
 772   else
 773     next_phase (ah);
 774
 775 }
 776
 777
 778 /**
 779  * Test if ICMP client is working
 780  *
 781  * @param ah auto setup context
 782  */
 783 static void
 784 test_icmp_client (struct GNUNET_NAT_AutoHandle *ah)
 785 {
 786
 787
 788   char *tmp;
 789   char *helper;
 790
 791   tmp = NULL;
 792   helper = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-client");
 793   if ((GNUNET_OK ==
 794         GNUNET_CONFIGURATION_get_value_string (ah->cfg, "nat", "INTERNAL_ADDRESS",
 795                                                &tmp)) && (0 < strlen (tmp)))
 796   {
 797     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("test_icmp_client not possible, as we have no internal IPv4 address\n"));
 798   }
 799   else
 800     goto err;
 801
 802   if (GNUNET_YES !=
 803       GNUNET_CONFIGURATION_get_value_yesno (ah->cfg, "nat", "BEHIND_NAT")){
 804     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("test_icmp_server not possible, as we are not behind NAT\n"));
 805   }
 806   else
 807     goto err;
 808
 809   if (GNUNET_YES ==
 810       GNUNET_OS_check_helper_binary (helper, GNUNET_YES, "-d 127.0.0.1 127.0.0.2 42")){
 811           // none of these parameters are actually used in privilege testing mode
 812     GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("No working gnunet-helper-nat-server found\n"));
 813   }
 814 err:
 815   GNUNET_free_non_null (tmp);
 816   GNUNET_free (helper);
 817
 818   next_phase (ah);
 819
 820 }
 821
 822
 823 /**
 824  * Run the next phase of the auto test.
 825  */
 826 static void
 827 next_phase (struct GNUNET_NAT_AutoHandle *ah)
 828 {
 829   struct GNUNET_CONFIGURATION_Handle *diff;
 830
 831   ah->phase++;
 832   switch (ah->phase)
 833   {
 834   case AUTO_INIT:
 835     GNUNET_assert (0);
 836     break;
 837   case AUTO_EXTERNAL_IP:
 838     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_EXTERNAL_IP\n");
 839     test_external_ip (ah);
 840     break;
 841   case AUTO_STUN:
 842     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_STUN\n");
 843     test_stun (ah);
 844     break;
 845   case AUTO_LOCAL_IP:
 846     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_LOCAL_IP\n");
 847     test_local_ip (ah);
 848     break;
 849   case AUTO_NAT_PUNCHED:
 850     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run GNUNET_ERROR_TYPE_DEBUG\n");
 851     test_nat_punched (ah);
 852     break;
 853   case AUTO_UPNPC:
 854     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_UPNPC\n");
 855     test_upnpc (ah);
 856     break;
 857   case AUTO_ICMP_SERVER:
 858     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_ICMP_SERVER\n");
 859     test_icmp_server (ah);
 860     break;
 861   case AUTO_ICMP_CLIENT:
 862     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Will run AUTO_ICMP_CLIENT\n");
 863     test_icmp_client (ah);
 864     break;
 865   case AUTO_DONE:
 866     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Done with tests\n");
 867     if(!ah->internal_ip_is_public)
 868     {
 869       GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "YES");
 870
 871       if(ah->connected_back)
 872       {
 873         GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "PUNCHED_NAT", "YES");
 874       }
 875       else
 876       {
 877         GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "PUNCHED_NAT", "NO");
 878       }
 879
 880       if (ah->stun_ip)
 881       {
 882         GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS",
 883                                                ah->stun_ip);
 884         if(ah->connected_back)
 885         {
 886           ah->type = GNUNET_NAT_TYPE_STUN_PUNCHED_NAT;
 887           GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "USE_STUN", "YES");
 888         }
 889         else
 890         {
 891           ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT;
 892           GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "USE_STUN", "NO");
 893         }
 894
 895       }
 896       if(ah->stun_port)
 897       {
 898         GNUNET_CONFIGURATION_set_value_number (ah->cfg, "transport-udp",
 899                                                "ADVERTISED_PORT",
 900                                                ah->stun_port);
 901       }
 902
 903     }
 904     else
 905     {
 906       //The internal IP is the same as public, but we didn't got a incoming connection
 907       if(ah->connected_back)
 908       {
 909         ah->type = GNUNET_NAT_TYPE_NO_NAT;
 910         GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "NO");
 911       }
 912       else
 913       {
 914         GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "YES");
 915         ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT;
 916         if (ah->stun_ip)
 917         {
 918           GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS",
 919                                                  ah->stun_ip);
 920         }
 921         if(ah->stun_port)
 922         {
 923           GNUNET_CONFIGURATION_set_value_number (ah->cfg, "transport-udp",
 924                                                  "ADVERTISED_PORT",
 925                                                  ah->stun_port);
 926
 927         }
 928       }
 929     }
 930
 931     diff = GNUNET_CONFIGURATION_get_diff (ah->initial_cfg,
 932                                           ah->cfg);
 933
 934
 935     ah->fin_cb (ah->fin_cb_cls,
 936                 diff,
 937                 ah->ret,
 938                 ah->type);
 939     GNUNET_CONFIGURATION_destroy (diff);
 940     GNUNET_NAT_autoconfig_cancel (ah);
 941     return;
 942
 943   }
 944
 945
 946
 947 }
 948
 949
 950 /**
 951  * Start auto-configuration routine.  The resolver service should
 952  * be available when this function is called.
 953  *
 954  * @param cfg initial configuration
 955  * @param cb function to call with autoconfiguration result
 956  * @param cb_cls closure for @a cb
 957  * @return handle to cancel operation
 958  */
 959 struct GNUNET_NAT_AutoHandle *
 960 GNUNET_NAT_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
 961                              GNUNET_NAT_AutoResultCallback cb,
 962                              void *cb_cls)
 963 {
 964   struct GNUNET_NAT_AutoHandle *ah;
 965
 966   ah = GNUNET_new (struct GNUNET_NAT_AutoHandle);
 967   ah->fin_cb = cb;
 968   ah->fin_cb_cls = cb_cls;
 969   ah->ret = GNUNET_NAT_ERROR_SUCCESS;
 970   ah->cfg = GNUNET_CONFIGURATION_dup (cfg);
 971   ah->initial_cfg = GNUNET_CONFIGURATION_dup (cfg);
 972
 973   /* never use loopback addresses if user wanted autoconfiguration */
 974   GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat",
 975                                          "USE_LOCALADDR",
 976                                          "NO");
 977
 978   next_phase (ah);
 979   return ah;
 980 }
 981
 982
 983 /**
 984  * Abort autoconfiguration.
 985  *
 986  * @param ah handle for operation to abort
 987  */
 988 void
 989 GNUNET_NAT_autoconfig_cancel (struct GNUNET_NAT_AutoHandle *ah)
 990 {
 991   if (NULL != ah->tst)
 992   {
 993     GNUNET_NAT_test_stop (ah->tst);
 994     ah->tst = NULL;
 995   }
 996   if (NULL != ah->eh)
 997   {
 998     GNUNET_NAT_mini_get_external_ipv4_cancel (ah->eh);
 999     ah->eh = NULL;
1000   }
1001   if (NULL != ah->task)
1002   {
1003     GNUNET_SCHEDULER_cancel (ah->task);
1004     ah->task = NULL;
1005   }
1006   GNUNET_CONFIGURATION_destroy (ah->cfg);
1007   GNUNET_CONFIGURATION_destroy (ah->initial_cfg);
1008   GNUNET_free (ah);
1009 }
1010
1011
1012 /* end of nat_auto.c */