src/nat-auto/nat_auto_api_test.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2011, 2016 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20 /**
  21  * @file nat/nat_auto_api_test.c
  22  * @brief functions to test if the NAT configuration is successful at achieving NAT traversal (with the help of a gnunet-nat-server)
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27 #include "gnunet_nat_service.h"
  28 #include "gnunet_nat_auto_service.h"
  29 #include "nat-auto.h"
  30
  31 #define LOG(kind, ...) GNUNET_log_from(kind, "nat-auto", __VA_ARGS__)
  32
  33 #define NAT_SERVER_TIMEOUT \
  34   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30)
  35
  36 /**
  37  * Entry we keep for each incoming connection.
  38  */
  39 struct NatActivity {
  40   /**
  41    * This is a doubly-linked list.
  42    */
  43   struct NatActivity *next;
  44
  45   /**
  46    * This is a doubly-linked list.
  47    */
  48   struct NatActivity *prev;
  49
  50   /**
  51    * Socket of the incoming connection.
  52    */
  53   struct GNUNET_NETWORK_Handle *sock;
  54
  55   /**
  56    * Handle of the master context.
  57    */
  58   struct GNUNET_NAT_AUTO_Test *h;
  59
  60   /**
  61    * Task reading from the incoming connection.
  62    */
  63   struct GNUNET_SCHEDULER_Task *rtask;
  64 };
  65
  66
  67 /**
  68  * Entry we keep for each connection to the gnunet-nat-service.
  69  */
  70 struct ClientActivity {
  71   /**
  72    * This is a doubly-linked list.
  73    */
  74   struct ClientActivity *next;
  75
  76   /**
  77    * This is a doubly-linked list.
  78    */
  79   struct ClientActivity *prev;
  80
  81   /**
  82    * Socket of the incoming connection.
  83    */
  84   struct GNUNET_MQ_Handle *mq;
  85
  86   /**
  87    * Handle to overall NAT test.
  88    */
  89   struct GNUNET_NAT_AUTO_Test *h;
  90 };
  91
  92
  93 /**
  94  * Handle to a NAT test.
  95  */
  96 struct GNUNET_NAT_AUTO_Test {
  97   /**
  98    * Configuration used
  99    */
 100   const struct GNUNET_CONFIGURATION_Handle *cfg;
 101
 102   /**
 103    * Function to call with success report
 104    */
 105   GNUNET_NAT_TestCallback report;
 106
 107   /**
 108    * Closure for @e report.
 109    */
 110   void *report_cls;
 111
 112   /**
 113    * Handle to NAT traversal in use
 114    */
 115   struct GNUNET_NAT_Handle *nat;
 116
 117   /**
 118    * Handle to listen socket, or NULL
 119    */
 120   struct GNUNET_NETWORK_Handle *lsock;
 121
 122   /**
 123    * Head of list of nat activities.
 124    */
 125   struct NatActivity *na_head;
 126
 127   /**
 128    * Tail of list of nat activities.
 129    */
 130   struct NatActivity *na_tail;
 131
 132   /**
 133    * Head of list of client activities.
 134    */
 135   struct ClientActivity *ca_head;
 136
 137   /**
 138    * Tail of list of client activities.
 139    */
 140   struct ClientActivity *ca_tail;
 141
 142   /**
 143    * Identity of task for the listen socket (if any)
 144    */
 145   struct GNUNET_SCHEDULER_Task *ltask;
 146
 147   /**
 148    * Task identifier for the timeout (if any)
 149    */
 150   struct GNUNET_SCHEDULER_Task *ttask;
 151
 152   /**
 153    * Section name of plugin to test.
 154    */
 155   char *section_name;
 156
 157   /**
 158    * IPPROTO_TCP or IPPROTO_UDP.
 159    */
 160   int proto;
 161
 162   /**
 163    * Data that should be transmitted or source-port.
 164    */
 165   uint16_t data;
 166
 167   /**
 168    * Status code to be reported to the timeout/status call
 169    */
 170   enum GNUNET_NAT_StatusCode status;
 171 };
 172
 173
 174 /**
 175  * Function called from #GNUNET_NAT_register whenever someone asks us
 176  * to do connection reversal.
 177  *
 178  * @param cls closure, our `struct GNUNET_NAT_Handle`
 179  * @param addr public IP address of the other peer
 180  * @param addrlen actual lenght of the @a addr
 181  */
 182 static void
 183 reversal_cb(void *cls, const struct sockaddr *addr, socklen_t addrlen)
 184 {
 185   struct GNUNET_NAT_AUTO_Test *h = cls;
 186   const struct sockaddr_in *sa;
 187
 188   if (sizeof(struct sockaddr_in) != addrlen)
 189     return;
 190   sa = (const struct sockaddr_in *)addr;
 191   if (h->data != sa->sin_port)
 192     {
 193       LOG(GNUNET_ERROR_TYPE_DEBUG,
 194           "Received connection reversal request for wrong port\n");
 195       return; /* wrong port */
 196     }
 197   /* report success */
 198   h->report(h->report_cls, GNUNET_NAT_ERROR_SUCCESS);
 199 }
 200
 201
 202 /**
 203  * Activity on our incoming socket.  Read data from the
 204  * incoming connection.
 205  *
 206  * @param cls the `struct GNUNET_NAT_AUTO_Test`
 207  */
 208 static void
 209 do_udp_read(void *cls)
 210 {
 211   struct GNUNET_NAT_AUTO_Test *tst = cls;
 212   uint16_t data;
 213   const struct GNUNET_SCHEDULER_TaskContext *tc;
 214
 215   tc = GNUNET_SCHEDULER_get_task_context();
 216   tst->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
 217                                              tst->lsock,
 218                                              &do_udp_read,
 219                                              tst);
 220   if ((NULL != tc->write_ready) &&
 221       (GNUNET_NETWORK_fdset_isset(tc->read_ready, tst->lsock)) &&
 222       (sizeof(data) ==
 223        GNUNET_NETWORK_socket_recv(tst->lsock, &data, sizeof(data))))
 224     {
 225       if (data == tst->data)
 226         tst->report(tst->report_cls, GNUNET_NAT_ERROR_SUCCESS);
 227       else
 228         LOG(GNUNET_ERROR_TYPE_DEBUG,
 229             "Received data mismatches expected value\n");
 230     }
 231   else
 232     LOG(GNUNET_ERROR_TYPE_DEBUG,
 233         "Failed to receive data from inbound connection\n");
 234 }
 235
 236
 237 /**
 238  * Activity on our incoming socket.  Read data from the
 239  * incoming connection.
 240  *
 241  * @param cls the `struct NatActivity`
 242  */
 243 static void
 244 do_read(void *cls)
 245 {
 246   struct NatActivity *na = cls;
 247   struct GNUNET_NAT_AUTO_Test *tst;
 248   uint16_t data;
 249   const struct GNUNET_SCHEDULER_TaskContext *tc;
 250
 251   tc = GNUNET_SCHEDULER_get_task_context();
 252   na->rtask = NULL;
 253   tst = na->h;
 254   GNUNET_CONTAINER_DLL_remove(tst->na_head, tst->na_tail, na);
 255   if ((NULL != tc->write_ready) &&
 256       (GNUNET_NETWORK_fdset_isset(tc->read_ready, na->sock)) &&
 257       (sizeof(data) ==
 258        GNUNET_NETWORK_socket_recv(na->sock, &data, sizeof(data))))
 259     {
 260       if (data == tst->data)
 261         tst->report(tst->report_cls, GNUNET_NAT_ERROR_SUCCESS);
 262       else
 263         LOG(GNUNET_ERROR_TYPE_DEBUG,
 264             "Received data does not match expected value\n");
 265     }
 266   else
 267     LOG(GNUNET_ERROR_TYPE_DEBUG,
 268         "Failed to receive data from inbound connection\n");
 269   GNUNET_NETWORK_socket_close(na->sock);
 270   GNUNET_free(na);
 271 }
 272
 273
 274 /**
 275  * Activity on our listen socket. Accept the
 276  * incoming connection.
 277  *
 278  * @param cls the `struct GNUNET_NAT_AUTO_Test`
 279  */
 280 static void
 281 do_accept(void *cls)
 282 {
 283   struct GNUNET_NAT_AUTO_Test *tst = cls;
 284   struct GNUNET_NETWORK_Handle *s;
 285   struct NatActivity *wl;
 286
 287   tst->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
 288                                              tst->lsock,
 289                                              &do_accept,
 290                                              tst);
 291   s = GNUNET_NETWORK_socket_accept(tst->lsock, NULL, NULL);
 292   if (NULL == s)
 293     {
 294       GNUNET_log_strerror(GNUNET_ERROR_TYPE_INFO, "accept");
 295       return; /* odd error */
 296     }
 297   LOG(GNUNET_ERROR_TYPE_DEBUG,
 298       "Got an inbound connection, waiting for data\n");
 299   wl = GNUNET_new(struct NatActivity);
 300   wl->sock = s;
 301   wl->h = tst;
 302   wl->rtask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
 303                                             wl->sock,
 304                                             &do_read,
 305                                             wl);
 306   GNUNET_CONTAINER_DLL_insert(tst->na_head, tst->na_tail, wl);
 307 }
 308
 309
 310 /**
 311  * We got disconnected from the NAT server.  Stop
 312  * waiting for a reply.
 313  *
 314  * @param cls the `struct ClientActivity`
 315  * @param error error code
 316  */
 317 static void
 318 mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
 319 {
 320   struct ClientActivity *ca = cls;
 321   struct GNUNET_NAT_AUTO_Test *tst = ca->h;
 322
 323   GNUNET_CONTAINER_DLL_remove(tst->ca_head, tst->ca_tail, ca);
 324   GNUNET_MQ_destroy(ca->mq);
 325   GNUNET_free(ca);
 326 }
 327
 328
 329 /**
 330  * Address-callback, used to send message to gnunet-nat-server.
 331  *
 332  * @param cls closure
 333  * @param app_ctx[in,out] location where the app can store stuff
 334  *                  on add and retrieve it on remove
 335  * @param add_remove #GNUNET_YES to mean the new public IP address, #GNUNET_NO to mean
 336  *     the previous (now invalid) one
 337  * @param ac address class the address belongs to
 338  * @param addr either the previous or the new public IP address
 339  * @param addrlen actual length of the @a addr
 340  */
 341 static void
 342 addr_cb(void *cls,
 343         void **app_ctx,
 344         int add_remove,
 345         enum GNUNET_NAT_AddressClass ac,
 346         const struct sockaddr *addr,
 347         socklen_t addrlen)
 348 {
 349   struct GNUNET_NAT_AUTO_Test *h = cls;
 350   struct ClientActivity *ca;
 351   struct GNUNET_MQ_Envelope *env;
 352   struct GNUNET_NAT_AUTO_TestMessage *msg;
 353   const struct sockaddr_in *sa;
 354
 355   (void)app_ctx;
 356   if (GNUNET_YES != add_remove)
 357     return;
 358   if (addrlen != sizeof(struct sockaddr_in))
 359     {
 360       LOG(GNUNET_ERROR_TYPE_DEBUG,
 361           "NAT test ignores IPv6 address `%s' returned from NAT library\n",
 362           GNUNET_a2s(addr, addrlen));
 363       return; /* ignore IPv6 here */
 364     }
 365   LOG(GNUNET_ERROR_TYPE_INFO,
 366       "Asking gnunet-nat-server to connect to `%s'\n",
 367       GNUNET_a2s(addr, addrlen));
 368
 369   ca = GNUNET_new(struct ClientActivity);
 370   ca->h = h;
 371   ca->mq = GNUNET_CLIENT_connect(h->cfg,
 372                                  "gnunet-nat-server",
 373                                  NULL,
 374                                  &mq_error_handler,
 375                                  ca);
 376   if (NULL == ca->mq)
 377     {
 378       GNUNET_free(ca);
 379       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 380                  _("Failed to connect to `gnunet-nat-server'\n"));
 381       return;
 382     }
 383   GNUNET_CONTAINER_DLL_insert(h->ca_head, h->ca_tail, ca);
 384   sa = (const struct sockaddr_in *)addr;
 385   env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_NAT_TEST);
 386   msg->dst_ipv4 = sa->sin_addr.s_addr;
 387   msg->dport = sa->sin_port;
 388   msg->data = h->data;
 389   msg->is_tcp = htonl((uint32_t)(h->proto == IPPROTO_TCP));
 390   GNUNET_MQ_send(ca->mq, env);
 391 }
 392
 393
 394 /**
 395  * Calls the report-callback reporting failure.
 396  *
 397  * Destroys the nat handle after the callback has been processed.
 398  *
 399  * @param cls handle to the timed out NAT test
 400  */
 401 static void
 402 do_fail(void *cls)
 403 {
 404   struct GNUNET_NAT_AUTO_Test *nh = cls;
 405
 406   nh->ttask = NULL;
 407   nh->report(nh->report_cls, nh->status);
 408 }
 409
 410
 411 /**
 412  * Start testing if NAT traversal works using the given configuration.
 413  *  The transport adapters should be down while using this function.
 414  *
 415  * @param cfg configuration for the NAT traversal
 416  * @param proto protocol to test, i.e. IPPROTO_TCP or IPPROTO_UDP
 417  * @param section_name configuration section to use for configuration
 418  * @param report function to call with the result of the test
 419  * @param report_cls closure for @a report
 420  * @return handle to cancel NAT test
 421  */
 422 struct GNUNET_NAT_AUTO_Test *
 423 GNUNET_NAT_AUTO_test_start(const struct GNUNET_CONFIGURATION_Handle *cfg,
 424                            uint8_t proto,
 425                            const char *section_name,
 426                            GNUNET_NAT_TestCallback report,
 427                            void *report_cls)
 428 {
 429   struct GNUNET_NAT_AUTO_Test *nh;
 430   unsigned long long bnd_port;
 431   struct sockaddr_in sa;
 432   const struct sockaddr *addrs[] = { (const struct sockaddr *)&sa };
 433   const socklen_t addrlens[] = { sizeof(sa) };
 434
 435   if ((GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
 436                                                           section_name,
 437                                                           "PORT",
 438                                                           &bnd_port)) ||
 439       (bnd_port > 65535))
 440     {
 441       GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
 442                  _("Failed to find valid PORT in section `%s'\n"),
 443                  section_name);
 444       return NULL;
 445     }
 446
 447   memset(&sa, 0, sizeof(sa));
 448   sa.sin_family = AF_INET;
 449   sa.sin_port = htons((uint16_t)bnd_port);
 450 #if HAVE_SOCKADDR_IN_SIN_LEN
 451   sa.sin_len = sizeof(sa);
 452 #endif
 453
 454   nh = GNUNET_new(struct GNUNET_NAT_AUTO_Test);
 455   nh->cfg = cfg;
 456   nh->proto = proto;
 457   nh->section_name = GNUNET_strdup(section_name);
 458   nh->report = report;
 459   nh->report_cls = report_cls;
 460   nh->status = GNUNET_NAT_ERROR_SUCCESS;
 461   if (0 == bnd_port)
 462     {
 463       nh->nat = GNUNET_NAT_register(cfg,
 464                                     section_name,
 465                                     proto,
 466                                     0,
 467                                     NULL,
 468                                     NULL,
 469                                     &addr_cb,
 470                                     &reversal_cb,
 471                                     nh);
 472     }
 473   else
 474     {
 475       nh->lsock =
 476         GNUNET_NETWORK_socket_create(AF_INET,
 477                                      (IPPROTO_UDP == proto) ? SOCK_DGRAM
 478                                      : SOCK_STREAM,
 479                                      proto);
 480       if ((NULL == nh->lsock) ||
 481           (GNUNET_OK != GNUNET_NETWORK_socket_bind(nh->lsock,
 482                                                    (const struct sockaddr *)&sa,
 483                                                    sizeof(sa))))
 484         {
 485           LOG(GNUNET_ERROR_TYPE_ERROR,
 486               _("Failed to create socket bound to `%s' for NAT test: %s\n"),
 487               GNUNET_a2s((const struct sockaddr *)&sa, sizeof(sa)),
 488               strerror(errno));
 489           if (NULL != nh->lsock)
 490             {
 491               GNUNET_NETWORK_socket_close(nh->lsock);
 492               nh->lsock = NULL;
 493             }
 494           nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR;
 495           nh->ttask = GNUNET_SCHEDULER_add_now(&do_fail, nh);
 496           return nh;
 497         }
 498       if (IPPROTO_TCP == proto)
 499         {
 500           GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_listen(nh->lsock, 5));
 501           nh->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
 502                                                     nh->lsock,
 503                                                     &do_accept,
 504                                                     nh);
 505         }
 506       else
 507         {
 508           nh->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
 509                                                     nh->lsock,
 510                                                     &do_udp_read,
 511                                                     nh);
 512         }
 513       LOG(GNUNET_ERROR_TYPE_INFO,
 514           "NAT test listens on port %llu (%s)\n",
 515           bnd_port,
 516           (IPPROTO_TCP == proto) ? "tcp" : "udp");
 517       nh->nat = GNUNET_NAT_register(cfg,
 518                                     section_name,
 519                                     proto,
 520                                     1,
 521                                     addrs,
 522                                     addrlens,
 523                                     &addr_cb,
 524                                     NULL,
 525                                     nh);
 526       if (NULL == nh->nat)
 527         {
 528           LOG(GNUNET_ERROR_TYPE_INFO,
 529               _("NAT test failed to start NAT library\n"));
 530           if (NULL != nh->ltask)
 531             {
 532               GNUNET_SCHEDULER_cancel(nh->ltask);
 533               nh->ltask = NULL;
 534             }
 535           if (NULL != nh->lsock)
 536             {
 537               GNUNET_NETWORK_socket_close(nh->lsock);
 538               nh->lsock = NULL;
 539             }
 540           nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED;
 541           nh->ttask = GNUNET_SCHEDULER_add_now(&do_fail, nh);
 542           return nh;
 543         }
 544     }
 545   return nh;
 546 }
 547
 548
 549 /**
 550  * Stop an active NAT test.
 551  *
 552  * @param tst test to stop.
 553  */
 554 void
 555 GNUNET_NAT_AUTO_test_stop(struct GNUNET_NAT_AUTO_Test *tst)
 556 {
 557   struct NatActivity *pos;
 558   struct ClientActivity *cpos;
 559
 560   LOG(GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n");
 561   while (NULL != (cpos = tst->ca_head))
 562     {
 563       GNUNET_CONTAINER_DLL_remove(tst->ca_head, tst->ca_tail, cpos);
 564       GNUNET_MQ_destroy(cpos->mq);
 565       GNUNET_free(cpos);
 566     }
 567   while (NULL != (pos = tst->na_head))
 568     {
 569       GNUNET_CONTAINER_DLL_remove(tst->na_head, tst->na_tail, pos);
 570       GNUNET_SCHEDULER_cancel(pos->rtask);
 571       GNUNET_NETWORK_socket_close(pos->sock);
 572       GNUNET_free(pos);
 573     }
 574   if (NULL != tst->ttask)
 575     {
 576       GNUNET_SCHEDULER_cancel(tst->ttask);
 577       tst->ttask = NULL;
 578     }
 579   if (NULL != tst->ltask)
 580     {
 581       GNUNET_SCHEDULER_cancel(tst->ltask);
 582       tst->ltask = NULL;
 583     }
 584   if (NULL != tst->lsock)
 585     {
 586       GNUNET_NETWORK_socket_close(tst->lsock);
 587       tst->lsock = NULL;
 588     }
 589   if (NULL != tst->nat)
 590     {
 591       GNUNET_NAT_unregister(tst->nat);
 592       tst->nat = NULL;
 593     }
 594   GNUNET_free(tst->section_name);
 595   GNUNET_free(tst);
 596 }
 597
 598 /* end of nat_auto_api_test.c */