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