src/pt/test_gnunet_vpn.c

   1 /*
   2      This file is part of GNUnet
   3      Copyright (C) 2007, 2009, 2011, 2012 Christian Grothoff
   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 /**
  22  * @file test_gnunet_vpn.c
  23  * @brief testcase for tunneling HTTP over the GNUnet VPN
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 /* Just included for the right curl.h */
  28 #include "gnunet_curl_lib.h"
  29 #include <microhttpd.h>
  30 #include "gnunet_vpn_service.h"
  31 #include "gnunet_testing_lib.h"
  32
  33 #define PORT 48080
  34
  35 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
  36
  37
  38 /**
  39  * Return value for 'main'.
  40  */
  41 static int global_ret;
  42
  43 static struct GNUNET_VPN_Handle *vpn;
  44
  45 static struct MHD_Daemon *mhd;
  46
  47 static struct GNUNET_SCHEDULER_Task *mhd_task_id;
  48
  49 static struct GNUNET_SCHEDULER_Task *curl_task_id;
  50
  51 static struct GNUNET_SCHEDULER_Task *timeout_task_id;
  52
  53 static struct GNUNET_VPN_RedirectionRequest *rr;
  54
  55 static CURL *curl;
  56
  57 static CURLM *multi;
  58
  59 static char *url;
  60
  61 /**
  62  * IP address of the ultimate destination.
  63  */
  64 static const char *dest_ip;
  65
  66 /**
  67  * Address family of the dest_ip.
  68  */
  69 static int dest_af;
  70
  71 /**
  72  * Address family to use by the curl client.
  73  */
  74 static int src_af;
  75
  76
  77 struct CBC
  78 {
  79   char buf[1024];
  80   size_t pos;
  81 };
  82
  83 static struct CBC cbc;
  84
  85
  86 static size_t
  87 copy_buffer (void *ptr, size_t size, size_t nmemb, void *ctx)
  88 {
  89   struct CBC *cbc = ctx;
  90
  91   if (cbc->pos + size * nmemb > sizeof (cbc->buf))
  92     return 0;                   /* overflow */
  93   GNUNET_memcpy (&cbc->buf[cbc->pos], ptr, size * nmemb);
  94   cbc->pos += size * nmemb;
  95   return size * nmemb;
  96 }
  97
  98
  99 static int
 100 mhd_ahc (void *cls,
 101          struct MHD_Connection *connection,
 102          const char *url,
 103          const char *method,
 104          const char *version,
 105          const char *upload_data,
 106          size_t * upload_data_size,
 107          void **unused)
 108 {
 109   static int ptr;
 110   struct MHD_Response *response;
 111   int ret;
 112
 113   if (0 != strcmp ("GET", method))
 114     return MHD_NO;              /* unexpected method */
 115   if (&ptr != *unused)
 116   {
 117     *unused = &ptr;
 118     return MHD_YES;
 119   }
 120   *unused = NULL;
 121   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 122               "MHD sends respose for request to URL `%s'\n", url);
 123   response =
 124       MHD_create_response_from_buffer (strlen (url), (void *) url,
 125                                        MHD_RESPMEM_MUST_COPY);
 126   ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
 127   MHD_destroy_response (response);
 128   if (ret == MHD_NO)
 129     abort ();
 130   return ret;
 131 }
 132
 133
 134 static void
 135 do_shutdown (void *cls)
 136 {
 137   if (NULL != mhd_task_id)
 138   {
 139     GNUNET_SCHEDULER_cancel (mhd_task_id);
 140     mhd_task_id = NULL;
 141   }
 142   if (NULL != curl_task_id)
 143   {
 144     GNUNET_SCHEDULER_cancel (curl_task_id);
 145     curl_task_id = NULL;
 146   }
 147   if (NULL != timeout_task_id)
 148   {
 149     GNUNET_SCHEDULER_cancel (timeout_task_id);
 150     timeout_task_id = NULL;
 151   }
 152   if (NULL != mhd)
 153   {
 154     MHD_stop_daemon (mhd);
 155     mhd = NULL;
 156   }
 157   if (NULL != rr)
 158   {
 159     GNUNET_VPN_cancel_request (rr);
 160     rr = NULL;
 161   }
 162   if (NULL != vpn)
 163   {
 164     GNUNET_VPN_disconnect (vpn);
 165     vpn = NULL;
 166   }
 167   GNUNET_free_non_null (url);
 168   url = NULL;
 169 }
 170
 171
 172 /**
 173  * Function to run the HTTP client.
 174  */
 175 static void
 176 curl_main (void *cls)
 177 {
 178   fd_set rs;
 179   fd_set ws;
 180   fd_set es;
 181   int max;
 182   struct GNUNET_NETWORK_FDSet nrs;
 183   struct GNUNET_NETWORK_FDSet nws;
 184   struct GNUNET_TIME_Relative delay;
 185   long timeout;
 186   int running;
 187   struct CURLMsg *msg;
 188
 189   curl_task_id = NULL;
 190   max = 0;
 191   FD_ZERO (&rs);
 192   FD_ZERO (&ws);
 193   FD_ZERO (&es);
 194   curl_multi_perform (multi, &running);
 195   if (running == 0)
 196   {
 197     GNUNET_assert (NULL != (msg = curl_multi_info_read (multi, &running)));
 198     if (msg->msg == CURLMSG_DONE)
 199     {
 200       if (msg->data.result != CURLE_OK)
 201       {
 202         fprintf (stderr, "%s failed at %s:%d: `%s'\n", "curl_multi_perform",
 203                  __FILE__, __LINE__, curl_easy_strerror (msg->data.result));
 204         global_ret = 1;
 205       }
 206     }
 207     curl_multi_remove_handle (multi, curl);
 208     curl_multi_cleanup (multi);
 209     curl_easy_cleanup (curl);
 210     curl = NULL;
 211     multi = NULL;
 212     if (cbc.pos != strlen ("/hello_world"))
 213     {
 214       GNUNET_break (0);
 215       global_ret = 2;
 216     }
 217     if (0 != strncmp ("/hello_world", cbc.buf, strlen ("/hello_world")))
 218     {
 219       GNUNET_break (0);
 220       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 221                   "You might want to check if your host-based firewall is blocking the connections.\n");
 222       global_ret = 3;
 223     }
 224     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download complete, shutting down!\n");
 225     GNUNET_SCHEDULER_shutdown ();
 226     return;
 227   }
 228   GNUNET_assert (CURLM_OK == curl_multi_fdset (multi, &rs, &ws, &es, &max));
 229   if ((CURLM_OK != curl_multi_timeout (multi, &timeout)) || (-1 == timeout))
 230     delay = GNUNET_TIME_UNIT_SECONDS;
 231   else
 232     delay =
 233         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
 234                                        (unsigned int) timeout);
 235   GNUNET_NETWORK_fdset_copy_native (&nrs, &rs, max + 1);
 236   GNUNET_NETWORK_fdset_copy_native (&nws, &ws, max + 1);
 237   curl_task_id =
 238       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, delay,
 239                                    &nrs, &nws, &curl_main, NULL);
 240 }
 241
 242
 243 /**
 244  * Callback invoked from the VPN service once a redirection is
 245  * available.  Provides the IP address that can now be used to
 246  * reach the requested destination (in our case, the MHD server)
 247  *
 248  * @param cls closure
 249  * @param af address family, AF_INET or AF_INET6; AF_UNSPEC on error;
 250  *                will match 'result_af' from the request
 251  * @param address IP address (struct in_addr or struct in_addr6, depending on 'af')
 252  *                that the VPN allocated for the redirection;
 253  *                traffic to this IP will now be redirected to the
 254  *                specified target peer; NULL on error
 255  */
 256 static void
 257 allocation_cb (void *cls, int af, const void *address)
 258 {
 259   char ips[INET6_ADDRSTRLEN];
 260
 261   rr = NULL;
 262   if (src_af != af)
 263   {
 264     fprintf (stderr,
 265              "VPN failed to allocate appropriate address\n");
 266     GNUNET_SCHEDULER_shutdown ();
 267     return;
 268   }
 269   if (AF_INET6 == af)
 270     GNUNET_asprintf (&url,
 271                      "http://[%s]:%u/hello_world",
 272                      inet_ntop (af,
 273                                 address,
 274                                 ips,
 275                                 sizeof (ips)),
 276                      (unsigned int) PORT);
 277   else
 278     GNUNET_asprintf (&url,
 279                      "http://%s:%u/hello_world",
 280                      inet_ntop (af,
 281                                 address,
 282                                 ips,
 283                                 sizeof (ips)),
 284                      (unsigned int) PORT);
 285   curl = curl_easy_init ();
 286   curl_easy_setopt (curl, CURLOPT_URL, url);
 287   curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, &copy_buffer);
 288   curl_easy_setopt (curl, CURLOPT_WRITEDATA, &cbc);
 289   curl_easy_setopt (curl, CURLOPT_FAILONERROR, 1);
 290   curl_easy_setopt (curl, CURLOPT_TIMEOUT, 150L);
 291   curl_easy_setopt (curl, CURLOPT_CONNECTTIMEOUT, 15L);
 292   curl_easy_setopt (curl, CURLOPT_NOSIGNAL, 1);
 293   curl_easy_setopt (curl, CURLOPT_VERBOSE, 0);
 294
 295   multi = curl_multi_init ();
 296   GNUNET_assert (multi != NULL);
 297   GNUNET_assert (CURLM_OK == curl_multi_add_handle (multi, curl));
 298   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 299               "Beginning HTTP download from `%s'\n",
 300               url);
 301   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 302                                 &curl_main,
 303                                 NULL);
 304 }
 305
 306
 307 /**
 308  * Function to keep the HTTP server running.
 309  */
 310 static void
 311 mhd_main (void);
 312
 313
 314 static void
 315 mhd_task (void *cls)
 316 {
 317   mhd_task_id = NULL;
 318   MHD_run (mhd);
 319   mhd_main ();
 320 }
 321
 322
 323 static void
 324 do_timeout (void *cls)
 325 {
 326   timeout_task_id = NULL;
 327   GNUNET_SCHEDULER_shutdown ();
 328   GNUNET_break (0);
 329   global_ret = 1;
 330 }
 331
 332
 333 static void
 334 mhd_main ()
 335 {
 336   struct GNUNET_NETWORK_FDSet nrs;
 337   struct GNUNET_NETWORK_FDSet nws;
 338   fd_set rs;
 339   fd_set ws;
 340   fd_set es;
 341   int max_fd;
 342   unsigned MHD_LONG_LONG timeout;
 343   struct GNUNET_TIME_Relative delay;
 344
 345   GNUNET_assert (NULL == mhd_task_id);
 346   FD_ZERO (&rs);
 347   FD_ZERO (&ws);
 348   FD_ZERO (&es);
 349   max_fd = -1;
 350   GNUNET_assert (MHD_YES == MHD_get_fdset (mhd, &rs, &ws, &es, &max_fd));
 351   if (MHD_YES == MHD_get_timeout (mhd, &timeout))
 352     delay =
 353         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
 354                                        (unsigned int) timeout);
 355   else
 356     delay = GNUNET_TIME_UNIT_FOREVER_REL;
 357   GNUNET_NETWORK_fdset_copy_native (&nrs, &rs, max_fd + 1);
 358   GNUNET_NETWORK_fdset_copy_native (&nws, &ws, max_fd + 1);
 359   mhd_task_id =
 360       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, delay,
 361                                    &nrs, &nws, &mhd_task, NULL);
 362 }
 363
 364
 365 static void
 366 run (void *cls,
 367      const struct GNUNET_CONFIGURATION_Handle *cfg,
 368      struct GNUNET_TESTING_Peer *peer)
 369 {
 370   struct in_addr v4;
 371   struct in6_addr v6;
 372   void *addr;
 373   enum MHD_FLAG flags;
 374
 375   vpn = GNUNET_VPN_connect (cfg);
 376   GNUNET_assert (NULL != vpn);
 377   flags = MHD_USE_DEBUG;
 378   if (AF_INET6 == dest_af)
 379     flags |= MHD_USE_IPv6;
 380   mhd =
 381       MHD_start_daemon (flags, PORT, NULL, NULL, &mhd_ahc, NULL,
 382                         MHD_OPTION_END);
 383
 384
 385   GNUNET_assert (NULL != mhd);
 386   mhd_main ();
 387   addr = NULL;
 388   switch (dest_af)
 389   {
 390   case AF_INET:
 391     GNUNET_assert (1 == inet_pton (dest_af, dest_ip, &v4));
 392     addr = &v4;
 393     break;
 394   case AF_INET6:
 395     GNUNET_assert (1 == inet_pton (dest_af, dest_ip, &v6));
 396     addr = &v6;
 397     break;
 398   default:
 399     GNUNET_assert (0);
 400   }
 401   rr = GNUNET_VPN_redirect_to_ip (vpn, src_af, dest_af, addr,
 402                                   GNUNET_TIME_UNIT_FOREVER_ABS, &allocation_cb,
 403                                   NULL);
 404   timeout_task_id =
 405       GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 406                                     &do_timeout,
 407                                     NULL);
 408   GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
 409                                  NULL);
 410 }
 411
 412
 413 int
 414 main (int argc, char *const *argv)
 415 {
 416   const char *type;
 417   const char *bin;
 418   char *vpn_binary;
 419   char *exit_binary;
 420   int ret = 0;
 421
 422 #ifndef MINGW
 423   if (0 != ACCESS ("/dev/net/tun", R_OK))
 424   {
 425     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
 426                               "access",
 427                               "/dev/net/tun");
 428     fprintf (stderr,
 429              "WARNING: System unable to run test, skipping.\n");
 430     return 77;
 431   }
 432 #endif
 433   vpn_binary = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-vpn");
 434   exit_binary = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-exit");
 435   if ((GNUNET_YES != (ret = GNUNET_OS_check_helper_binary (vpn_binary, GNUNET_YES, "-d gnunet-vpn - - 169.1.3.3.7 255.255.255.0"))) || //ipv4 only please!
 436       (GNUNET_YES != (ret = GNUNET_OS_check_helper_binary (exit_binary, GNUNET_YES, "-d gnunet-vpn - - - 169.1.3.3.7 255.255.255.0")))) //no nat, ipv4 only
 437   {
 438     GNUNET_free (vpn_binary);
 439     GNUNET_free (exit_binary);
 440     fprintf (stderr,
 441              "WARNING: gnunet-helper-{exit,vpn} binaries are not SUID, refusing to run test (as it would have to fail). %d\n", ret);
 442     return 77;
 443   }
 444
 445   GNUNET_free (vpn_binary);
 446   GNUNET_free (exit_binary);
 447   bin = argv[0];
 448   if (NULL != strstr (bin, "lt-"))
 449     bin = strstr (bin, "lt-") + 4;
 450   type = strstr (bin, "-");
 451   if (NULL == type)
 452   {
 453     fprintf (stderr,
 454              "invalid binary name\n");
 455     return 1;
 456   }
 457   type++;
 458   /* on Windows, .exe is suffixed to these binaries,
 459    * thus cease comparison after the 6th char.
 460    */
 461   if (0 == strncmp (type, "4_to_6",6))
 462   {
 463     dest_ip = "FC5A:04E1:C2BA::1";
 464     dest_af = AF_INET6;
 465     src_af = AF_INET;
 466   }
 467   else if (0 == strncmp (type, "6_to_4",6))
 468   {
 469     dest_ip = "169.254.86.1";
 470     dest_af = AF_INET;
 471     src_af = AF_INET6;
 472   }
 473   else if (0 == strncmp (type, "4_over",6))
 474   {
 475     dest_ip = "169.254.86.1";
 476     dest_af = AF_INET;
 477     src_af = AF_INET;
 478   }
 479   else if (0 == strncmp (type, "6_over",6))
 480   {
 481     dest_ip = "FC5A:04E1:C2BA::1";
 482     dest_af = AF_INET6;
 483     src_af = AF_INET6;
 484   }
 485   else
 486   {
 487     fprintf (stderr, "invalid binary suffix `%s'\n", type);
 488     return 1;
 489   }
 490   if ((GNUNET_OK != GNUNET_NETWORK_test_pf (src_af)) ||
 491       (GNUNET_OK != GNUNET_NETWORK_test_pf (dest_af)))
 492   {
 493     fprintf (stderr,
 494              "Required address families not supported by this system, skipping test.\n");
 495     return 0;
 496   }
 497   if (0 != curl_global_init (CURL_GLOBAL_WIN32))
 498   {
 499     fprintf (stderr, "failed to initialize curl\n");
 500     return 2;
 501   }
 502   if (0 !=
 503       GNUNET_TESTING_peer_run ("test-gnunet-vpn", "test_gnunet_vpn.conf", &run,
 504                                NULL))
 505     return 1;
 506   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-vpn");
 507   return global_ret;
 508 }
 509
 510 /* end of test_gnunet_vpn.c */