src/transport/test_plugin_transport.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009 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., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20 /**
  21  * @file transport/test_plugin_transport.c
  22  * @brief testcase for transport_api.c
  23  * @author Sailor Siraj
  24  * @author Christian Grothoff
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_common.h"
  29 #include "gnunet_constants.h"
  30 #include "gnunet_util_lib.h"
  31 #include "gnunet_hello_lib.h"
  32 #include "gnunet_peerinfo_service.h"
  33 #include "gnunet_statistics_service.h"
  34 #include "gnunet_protocols.h"
  35 #include "gnunet_signatures.h"
  36 #include "gnunet_transport_plugin.h"
  37
  38 #include "transport.h"
  39
  40 /**
  41  * How long until we give up on transmitting the message?
  42  */
  43 #define WAIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
  44 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
  45
  46 /**
  47  * Our public key.
  48  */
  49 static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key;
  50
  51 /**
  52  * Our identity.
  53  */
  54 static struct GNUNET_PeerIdentity my_identity;
  55
  56 /**
  57  * Our private key.
  58  */
  59 static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
  60
  61 /**
  62  * Our configuration.
  63  */
  64 const struct GNUNET_CONFIGURATION_Handle *cfg;
  65
  66 /**
  67  * Our configuration.
  68  */
  69 struct GNUNET_STATISTICS_Handle *stats;
  70
  71 /**
  72  * Our HELLO
  73  */
  74 struct GNUNET_HELLO_Message *hello;
  75
  76 /**
  77  * Number of neighbours we'd like to have.
  78  */
  79 static uint32_t max_connect_per_transport;
  80
  81 /**
  82  * Environment for this plugin.
  83  */
  84 struct GNUNET_TRANSPORT_PluginEnvironment env;
  85
  86 /**
  87  *handle for the api provided by this plugin
  88  */
  89 struct GNUNET_TRANSPORT_PluginFunctions *api;
  90
  91 /**
  92  * Helper handler
  93  */
  94 struct GNUNET_HELPER_Handle *suid_helper;
  95
  96 /**
  97  * Timeout task
  98  */
  99 static GNUNET_SCHEDULER_TaskIdentifier timeout_endbadly;
 100
 101 /**
 102  * Timeout task
 103  */
 104 static GNUNET_SCHEDULER_TaskIdentifier timeout_wait;
 105
 106 /**
 107  * Library name
 108  */
 109 static char *libname;
 110
 111 /**
 112  * Plugin addresses head
 113  */
 114 struct AddressWrapper *head;
 115
 116 /**
 117  * Plugin addresses tail
 118  */
 119 struct AddressWrapper *tail;
 120
 121 unsigned int addresses_reported;
 122
 123 unsigned int pretty_printers_running;
 124
 125 /**
 126  * Did the test pass or fail?
 127  */
 128 static int ok;
 129
 130
 131 struct AddressWrapper
 132 {
 133   struct AddressWrapper *next;
 134
 135   struct AddressWrapper *prev;
 136
 137   void *addr;
 138
 139   size_t addrlen;
 140
 141   char *addrstring;
 142 };
 143
 144
 145 static void
 146 end ()
 147 {
 148   struct AddressWrapper *w;
 149   int c = 0;
 150   ok = 0;
 151
 152   if (GNUNET_SCHEDULER_NO_TASK != timeout_endbadly)
 153   {
 154       GNUNET_SCHEDULER_cancel (timeout_endbadly);
 155       timeout_endbadly = GNUNET_SCHEDULER_NO_TASK;
 156   }
 157   if (NULL != api)
 158       GNUNET_PLUGIN_unload (libname, api);
 159
 160   while (NULL != head)
 161   {
 162       w = head;
 163       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 164                 _("Plugin did not remove address `%s' \n"), w->addrstring);
 165       GNUNET_CONTAINER_DLL_remove (head, tail, w);
 166       c ++;
 167       GNUNET_free (w->addr);
 168       GNUNET_free (w->addrstring);
 169       GNUNET_free (w);
 170   }
 171   if (c > 0)
 172   {
 173     GNUNET_break (0);
 174     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 175               _("Plugin did not remove %u addresses \n"), c);
 176     ok = 1;
 177   }
 178
 179
 180   GNUNET_free (libname);
 181   libname = NULL;
 182   GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
 183   stats = NULL;
 184
 185   if (NULL != suid_helper)
 186   {
 187     GNUNET_HELPER_stop (suid_helper);
 188     suid_helper = NULL;
 189   }
 190 }
 191
 192
 193 static void
 194 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 195 {
 196   struct AddressWrapper *w;
 197   int c = 0;
 198   timeout_endbadly = GNUNET_SCHEDULER_NO_TASK;
 199   if (GNUNET_SCHEDULER_NO_TASK != timeout_wait)
 200   {
 201       GNUNET_SCHEDULER_cancel (timeout_wait);
 202       timeout_wait = GNUNET_SCHEDULER_NO_TASK;
 203   }
 204
 205   if (pretty_printers_running > 0)
 206   {
 207       timeout_endbadly = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &end_badly, NULL);
 208       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 209                 _("Have pending calls to pretty_printer ... deferring shutdown\n"));
 210       return;
 211   }
 212
 213   if (NULL != cls)
 214   {
 215       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 216                 _("Test took too long to execute, timeout .... \n"));
 217   }
 218
 219   if (NULL != libname)
 220   {
 221     if (NULL != api)
 222       GNUNET_PLUGIN_unload (libname, api);
 223     GNUNET_free (libname);
 224     libname = NULL;
 225   }
 226
 227   while (NULL != head)
 228   {
 229       w = head;
 230       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 231                 _("Plugin did not remove address `%s' \n"), w->addrstring);
 232       GNUNET_CONTAINER_DLL_remove (head, tail, w);
 233       c ++;
 234       GNUNET_free (w->addr);
 235       GNUNET_free (w->addrstring);
 236       GNUNET_free (w);
 237   }
 238   if (c > 0)
 239   {
 240     GNUNET_break (0);
 241     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 242               _("Plugin did not remove %u addresses \n"), c);
 243   }
 244
 245   if (NULL != stats)
 246   {
 247     GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
 248     stats = NULL;
 249   }
 250
 251   if (NULL != suid_helper)
 252   {
 253     GNUNET_HELPER_stop (suid_helper);
 254     suid_helper = NULL;
 255   }
 256
 257   ok = 1;
 258 }
 259
 260
 261 static void
 262 wait_end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 263 {
 264   timeout_wait = GNUNET_SCHEDULER_NO_TASK;
 265   if (0 == addresses_reported)
 266     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 267               _("Plugin did not report any addresses, could not check address conversion functions\n"));
 268   end ();
 269 }
 270
 271
 272 static void
 273 end_badly_now ()
 274 {
 275   if (GNUNET_SCHEDULER_NO_TASK != timeout_wait)
 276   {
 277       GNUNET_SCHEDULER_cancel (timeout_wait);
 278       timeout_wait = GNUNET_SCHEDULER_NO_TASK;
 279   }
 280   if (GNUNET_SCHEDULER_NO_TASK != timeout_endbadly)
 281   {
 282       GNUNET_SCHEDULER_cancel (timeout_endbadly);
 283       timeout_endbadly = GNUNET_SCHEDULER_NO_TASK;
 284   }
 285   timeout_endbadly = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
 286 }
 287
 288
 289 static struct GNUNET_TIME_Relative
 290 env_receive (void *cls,
 291             const struct GNUNET_PeerIdentity *peer,
 292             const struct GNUNET_MessageHeader *message,
 293             const struct GNUNET_ATS_Information *ats,
 294             uint32_t ats_count,
 295             struct Session * session,
 296             const char *sender_address,
 297             uint16_t sender_address_len)
 298 {
 299   /* do nothing */
 300   return GNUNET_TIME_relative_get_zero_();
 301 }
 302
 303
 304 static int got_reply;
 305
 306
 307 /**
 308  * Take the given address and append it to the set of results sent back to
 309  * the client.
 310  *
 311  * @param cls the transmission context used ('struct GNUNET_SERVER_TransmitContext*')
 312  * @param buf text to transmit
 313  */
 314 static void
 315 address_pretty_printer_cb (void *cls, const char *buf)
 316 {
 317   if (NULL != buf)
 318   {
 319     got_reply = GNUNET_YES;
 320     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 321                 "Pretty address : `%s'\n", buf);
 322     pretty_printers_running --;
 323   }
 324   else
 325   {
 326       if (GNUNET_NO == got_reply)
 327       {
 328           pretty_printers_running --;
 329           GNUNET_break (0);
 330           end_badly_now ();
 331       }
 332   }
 333 }
 334
 335
 336 static void
 337 env_notify_address (void *cls,
 338                     int add_remove,
 339                     const void *addr,
 340                     size_t addrlen,
 341                     const char *plugin)
 342 {
 343   struct AddressWrapper *w;
 344   char *a2s;
 345   void *s2a;
 346   size_t s2a_len;
 347
 348   if (GNUNET_YES == add_remove)
 349   {
 350       addresses_reported ++;
 351       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 352                   _("Adding address of length %u\n"), addrlen);
 353
 354       w = GNUNET_malloc (sizeof (struct AddressWrapper));
 355       w->addr = GNUNET_malloc (addrlen);
 356       w->addrlen = addrlen;
 357       memcpy (w->addr, addr, addrlen);
 358       GNUNET_CONTAINER_DLL_insert(head, tail, w);
 359       got_reply = GNUNET_NO;
 360       pretty_printers_running ++;
 361       api->address_pretty_printer (api->cls, plugin, addr, addrlen,
 362                                     GNUNET_YES, GNUNET_TIME_UNIT_MINUTES,
 363                                     &address_pretty_printer_cb,
 364                                     w);
 365
 366       a2s = strdup (api->address_to_string (api, w->addr, w->addrlen));
 367       if (NULL == a2s)
 368       {
 369           GNUNET_break (0);
 370           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 371                       _("Plugin cannot convert address to string!\n"));
 372           end_badly_now();
 373           return;
 374       }
 375       w->addrstring = strdup (api->address_to_string (api, w->addr, w->addrlen));
 376       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 377                   _("Plugin added address `%s'\n"), a2s);
 378
 379       if ((GNUNET_OK != api->string_to_address (api, a2s, strlen (a2s)+1, &s2a, &s2a_len)) || (NULL == s2a))
 380       {
 381           GNUNET_break (0);
 382           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 383                       _("Plugin cannot convert string to address!\n"));
 384           end_badly_now();
 385           return;
 386       }
 387
 388       if (s2a_len != w->addrlen)
 389       {
 390           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 391                       _("Plugin creates different address length when converting address->string->address: %u != %u\n"), w->addrlen, s2a_len);
 392       }
 393       else
 394       {
 395           if (0 != memcmp (s2a, w->addr, s2a_len))
 396             GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 397                         _("Plugin creates different address length when connecting back and forth!\n"));
 398       }
 399       GNUNET_free (s2a);
 400       GNUNET_free (a2s);
 401       if (GNUNET_OK != api->check_address (api->cls, w->addr, w->addrlen))
 402       {
 403           GNUNET_break (0);
 404           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 405                       _("Plugin refuses added address!\n"));
 406           end_badly_now();
 407           return;
 408       }
 409       if (GNUNET_SCHEDULER_NO_TASK != timeout_wait)
 410       {
 411           GNUNET_SCHEDULER_cancel (timeout_wait);
 412           timeout_wait = GNUNET_SCHEDULER_NO_TASK;
 413       }
 414
 415       timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL);
 416
 417   }
 418   else if (GNUNET_NO == add_remove)
 419   {
 420       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 421                   _("Removing address of length %u\n"), addrlen);
 422
 423       w = head;
 424       while (NULL != w)
 425       {
 426           if ((addrlen == w->addrlen) && (0 == memcmp (w->addr, addr, addrlen)))
 427           {
 428             break;
 429           }
 430           w = w->next;
 431       }
 432
 433       if (w == NULL)
 434       {
 435           GNUNET_break (0);
 436           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 437                       _("Plugin removes address never added!\n"));
 438           end_badly_now();
 439           return;
 440       }
 441
 442       GNUNET_CONTAINER_DLL_remove (head, tail, w);
 443       GNUNET_free (w->addr);
 444       GNUNET_free (w->addrstring);
 445       GNUNET_free (w);
 446   }
 447   else
 448   {
 449       GNUNET_break (0);
 450       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 451                   _("Invalid operation: %u \n"), add_remove);
 452       end_badly_now ();
 453       return;
 454   }
 455 }
 456
 457
 458 static struct GNUNET_ATS_Information
 459 env_get_address_type (void *cls,
 460                      const struct sockaddr *addr,
 461                      size_t addrlen)
 462 {
 463   struct GNUNET_ATS_Information ats;
 464   ats.type = htonl (GNUNET_ATS_NETWORK_TYPE);
 465   ats.value = htonl (GNUNET_ATS_NET_LOOPBACK);
 466   return ats;
 467 }
 468
 469
 470 static const struct GNUNET_MessageHeader *
 471 env_get_our_hello ()
 472 {
 473   return (const struct GNUNET_MessageHeader *) hello;
 474 }
 475
 476
 477 static void
 478 env_session_end (void *cls,
 479                  const struct GNUNET_PeerIdentity *peer,
 480                  struct Session * session)
 481 {
 482 }
 483
 484
 485 static void
 486 setup_plugin_environment ()
 487 {
 488   env.cfg = cfg;
 489   env.cls = &env;
 490   env.my_identity = &my_identity;
 491   env.max_connections = max_connect_per_transport;
 492   env.stats = stats;
 493
 494   env.receive = &env_receive;
 495   env.notify_address = &env_notify_address;
 496   env.get_address_type = &env_get_address_type;
 497   env.get_our_hello = &env_get_our_hello;
 498   env.session_end = &env_session_end;
 499 }
 500
 501 static int
 502 handle_helper_message (void *cls, void *client,
 503                        const struct GNUNET_MessageHeader *hdr)
 504 {
 505   return GNUNET_OK;
 506 }
 507
 508
 509 /**
 510  * Runs the test.
 511  *
 512  * @param cls closure
 513  * @param c configuration to use
 514  */
 515 static void
 516 run (void *cls, char *const *args, const char *cfgfile,
 517      const struct GNUNET_CONFIGURATION_Handle *c)
 518 {
 519   char *const *argv = cls;
 520   unsigned long long tneigh;
 521   char *keyfile;
 522   char *plugin;
 523   char *sep;
 524
 525   timeout_endbadly = GNUNET_SCHEDULER_add_delayed (TIMEOUT, end_badly, &ok);
 526
 527   cfg = c;
 528   /* parse configuration */
 529   if ( (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (c,
 530                                                             "TRANSPORT",
 531                                                             "NEIGHBOUR_LIMIT",
 532                                                             &tneigh)) ||
 533        (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (c,
 534                                                               "GNUNETD", "HOSTKEY",
 535                                                               &keyfile)))
 536   {
 537     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 538                 _("Transport service is lacking key configuration settings.  Exiting.\n"));
 539     return;
 540   }
 541
 542   if (NULL == (stats = GNUNET_STATISTICS_create ("transport", cfg)))
 543   {
 544     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 545                 _("Could not create statistics.  Exiting.\n"));
 546     end_badly_now ();
 547     return;
 548   }
 549
 550   max_connect_per_transport = (uint32_t) tneigh;
 551   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
 552   GNUNET_free (keyfile);
 553   if (NULL == my_private_key)
 554   {
 555     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 556                 _("Transport service could not access hostkey.  Exiting.\n"));
 557     end_badly_now ();
 558     return;
 559   }
 560   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
 561   GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
 562                       &my_identity.hashPubKey);
 563
 564
 565   hello = GNUNET_HELLO_create(&my_public_key, NULL, NULL);
 566
 567   /* load plugins... */
 568   setup_plugin_environment ();
 569
 570   GNUNET_assert (strlen (argv[0]) > strlen ("test_plugin_"));
 571   plugin = strstr(argv[0],"test_plugin_");
 572   sep = strrchr(argv[0],'.');
 573   if (NULL == plugin)
 574   {
 575       GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Not a valid test name\n"));
 576       end_badly_now ();
 577       return;
 578   }
 579   plugin += strlen ("test_plugin_");
 580   if (NULL != sep)
 581       sep[0] = '\0';
 582
 583   /* Hack for WLAN: start a second helper */
 584   if (0 == strcmp (plugin, "wlan"))
 585   {
 586     char * helper_argv[3];
 587     helper_argv[0] = (char *) "gnunet-helper-transport-wlan-dummy";
 588     helper_argv[1] = (char *) "2";
 589     helper_argv[2] = NULL;
 590     suid_helper = GNUNET_HELPER_start (GNUNET_NO,
 591                                        "gnunet-helper-transport-wlan-dummy",
 592                                        helper_argv,
 593                                        &handle_helper_message,
 594                                        NULL,
 595                                        NULL);
 596   }
 597
 598   /* Loading plugin */
 599   GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Loading transport plugin %s\n"), plugin);
 600   GNUNET_asprintf (&libname, "libgnunet_plugin_transport_%s", plugin);
 601   api = GNUNET_PLUGIN_load (libname, &env);
 602   if (api == NULL)
 603   {
 604     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 605                 _("Failed to load transport plugin for %s\n"), plugin);
 606     end_badly_now ();
 607     return;
 608   }
 609
 610   timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL);
 611
 612   /* Check if all functions are implemented */
 613   if (NULL == api->address_pretty_printer)
 614   {
 615       GNUNET_break (0);
 616       end_badly_now ();
 617       return;
 618   }
 619   if (NULL == api->address_to_string)
 620   {
 621       GNUNET_break (0);
 622       end_badly_now ();
 623       return;
 624   }
 625   GNUNET_assert (NULL != api->check_address);
 626   if (NULL == api->check_address)
 627   {
 628       GNUNET_break (0);
 629       end_badly_now ();
 630       return;
 631   }
 632   GNUNET_assert (NULL != api->disconnect);
 633   if (NULL == api->disconnect)
 634   {
 635       GNUNET_break (0);
 636       end_badly_now ();
 637       return;
 638   }
 639   GNUNET_assert (NULL != api->get_session);
 640   if (NULL == api->get_session)
 641   {
 642       GNUNET_break (0);
 643       end_badly_now ();
 644       return;
 645   }
 646   if (NULL == api->address_pretty_printer)
 647   {
 648       GNUNET_break (0);
 649       end_badly_now ();
 650       return;
 651   }
 652   if (NULL == api->string_to_address)
 653   {
 654       GNUNET_break (0);
 655       end_badly_now ();
 656       return;
 657   }
 658
 659 }
 660
 661
 662 /**
 663  * The main function for the test
 664  *
 665  * @param argc number of arguments from the command line
 666  * @param argv command line arguments
 667  * @return 0 ok, 1 on error
 668  */
 669 int
 670 main (int argc, char *const *argv)
 671 {
 672   static struct GNUNET_GETOPT_CommandLineOption options[] = {
 673     GNUNET_GETOPT_OPTION_END
 674   };
 675   int ret;
 676
 677   char *const argv_prog[] = {
 678     "test_plugin_transport",
 679     "-c",
 680     "test_plugin_transport_data.conf",
 681     NULL
 682   };
 683   GNUNET_log_setup ("test-plugin-transport",
 684                     "WARNING",
 685                     NULL);
 686   ok = 1;                       /* set to fail */
 687   ret = (GNUNET_OK == GNUNET_PROGRAM_run (3,
 688                                           argv_prog,
 689                                           "test-plugin-transport",
 690                                           "testcase",
 691                                           options,
 692                                           &run,
 693                                           (void *) argv)) ? ok : 1;
 694   GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-plugin-transport");
 695   return ret;
 696 }
 697
 698 /* end of test_plugin_transport.c */