src/transport/test_transport_api.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2009, 2010 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_transport_api.c
  22  * @brief base test case for transport implementations
  23  *
  24  * This test case serves as a base for tcp, udp, and udp-nat
  25  * transport test cases.  Based on the executable being run
  26  * the correct test case will be performed.  Conservation of
  27  * C code apparently.
  28  */
  29 #include "platform.h"
  30 #include "gnunet_common.h"
  31 #include "gnunet_hello_lib.h"
  32 #include "gnunet_getopt_lib.h"
  33 #include "gnunet_os_lib.h"
  34 #include "gnunet_program_lib.h"
  35 #include "gnunet_scheduler_lib.h"
  36 #include "gnunet_transport_service.h"
  37 #include "transport.h"
  38
  39 #define VERBOSE GNUNET_NO
  40
  41 #define VERBOSE_ARM GNUNET_NO
  42
  43 #define START_ARM GNUNET_YES
  44
  45 /**
  46  * How long until we give up on transmitting the message?
  47  */
  48 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
  49
  50 /**
  51  * How long until we give up on transmitting the message?
  52  */
  53 #define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
  54
  55 #define MTYPE 12345
  56
  57 struct PeerContext
  58 {
  59   struct GNUNET_CONFIGURATION_Handle *cfg;
  60   struct GNUNET_TRANSPORT_Handle *th;
  61   struct GNUNET_PeerIdentity id;
  62 #if START_ARM
  63   struct GNUNET_OS_Process *arm_proc;
  64 #endif
  65 };
  66
  67 static struct PeerContext p1;
  68
  69 static struct PeerContext p2;
  70
  71 static int ok;
  72
  73 static int is_tcp;
  74
  75 static int is_tcp_nat;
  76
  77 static int is_udp;
  78
  79 static int is_unix;
  80
  81 static int is_udp_nat;
  82
  83 static int is_http;
  84
  85 static int is_https;
  86
  87 static int is_multi_protocol;
  88
  89 static int is_wlan;
  90
  91 static  GNUNET_SCHEDULER_TaskIdentifier die_task;
  92
  93 static  GNUNET_SCHEDULER_TaskIdentifier tct;
  94
  95 static char * key_file_p1;
  96 static char * cert_file_p1;
  97
  98 static char * key_file_p2;
  99 static char * cert_file_p2;
 100
 101 #if VERBOSE
 102 #define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
 103 #else
 104 #define OKPP do { ok++; } while (0)
 105 #endif
 106
 107
 108 static void
 109 end ()
 110 {
 111   GNUNET_assert (ok == 6);
 112   GNUNET_SCHEDULER_cancel (die_task);
 113   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 114               "Disconnecting from transports!\n");
 115   GNUNET_TRANSPORT_disconnect (p1.th);
 116   GNUNET_TRANSPORT_disconnect (p2.th);
 117   die_task = GNUNET_SCHEDULER_NO_TASK;
 118   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 119               "Transports disconnected, returning success!\n");
 120   ok = 0;
 121 }
 122
 123 static void
 124 stop_arm (struct PeerContext *p)
 125 {
 126 #if START_ARM
 127   if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
 128     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
 129   GNUNET_OS_process_wait (p->arm_proc);
 130   GNUNET_OS_process_close (p->arm_proc);
 131   p->arm_proc = NULL;
 132 #endif
 133   GNUNET_CONFIGURATION_destroy (p->cfg);
 134 }
 135
 136
 137 static void
 138 end_badly ()
 139 {
 140   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
 141   GNUNET_break (0);
 142   GNUNET_TRANSPORT_disconnect (p1.th);
 143   GNUNET_TRANSPORT_disconnect (p2.th);
 144   if (GNUNET_SCHEDULER_NO_TASK != tct)
 145     {
 146       GNUNET_SCHEDULER_cancel (tct);
 147       tct = GNUNET_SCHEDULER_NO_TASK;
 148     }
 149   ok = 1;
 150 }
 151
 152
 153 static void
 154 notify_receive (void *cls,
 155                 const struct GNUNET_PeerIdentity *peer,
 156                 const struct GNUNET_MessageHeader *message,
 157                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
 158                 uint32_t ats_count)
 159 {
 160   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 161               "Received message of type %d from peer %s!\n",
 162               ntohs(message->type),
 163               GNUNET_i2s (peer));
 164   GNUNET_assert (ok == 5);
 165   OKPP;
 166   GNUNET_assert (MTYPE == ntohs (message->type));
 167   GNUNET_assert (sizeof (struct GNUNET_MessageHeader) ==
 168                  ntohs (message->size));
 169   end ();
 170 }
 171
 172
 173 static size_t
 174 notify_ready (void *cls, size_t size, void *buf)
 175 {
 176   struct PeerContext *p = cls;
 177   struct GNUNET_MessageHeader *hdr;
 178
 179   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 180               "Transmitting message with %u bytes to peer %s\n",
 181               sizeof (struct GNUNET_MessageHeader),
 182               GNUNET_i2s (&p->id));
 183   GNUNET_assert (size >= 256);
 184   GNUNET_assert (ok == 4);
 185   OKPP;
 186   if (buf != NULL)
 187   {
 188     hdr = buf;
 189     hdr->size = htons (sizeof (struct GNUNET_MessageHeader));
 190     hdr->type = htons (MTYPE);
 191   }
 192   return sizeof (struct GNUNET_MessageHeader);
 193 }
 194
 195
 196 static void
 197 exchange_hello_last (void *cls,
 198                      const struct GNUNET_MessageHeader *message)
 199 {
 200   struct PeerContext *me = cls;
 201
 202   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 203               "Exchanging HELLO of size %d with peer (%s)!\n",
 204               (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
 205               GNUNET_i2s (&me->id));
 206   GNUNET_assert (message != NULL);
 207   GNUNET_assert (GNUNET_OK ==
 208                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
 209                                       message, &me->id));
 210   GNUNET_TRANSPORT_offer_hello (p1.th, message, NULL, NULL);
 211 }
 212
 213
 214
 215 static void
 216 exchange_hello (void *cls,
 217                 const struct GNUNET_MessageHeader *message)
 218 {
 219   struct PeerContext *me = cls;
 220
 221   GNUNET_assert (message != NULL);
 222   GNUNET_assert (GNUNET_OK ==
 223                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
 224                                       message, &me->id));
 225   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 226               "Exchanging HELLO of size %d from peer %s!\n",
 227               (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message),
 228               GNUNET_i2s (&me->id));
 229   GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
 230 }
 231
 232
 233
 234 static void
 235 notify_connect (void *cls,
 236                 const struct GNUNET_PeerIdentity *peer,
 237                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
 238                 uint32_t ats_count)
 239 {
 240   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 241               "Peer `%4s' connected to us (%p)!\n",
 242               GNUNET_i2s (peer),
 243               cls);
 244   if (cls == &p1)
 245     {
 246       GNUNET_assert (ok >= 2);
 247       OKPP;
 248       OKPP;
 249       GNUNET_SCHEDULER_cancel (die_task);
 250       GNUNET_SCHEDULER_cancel (tct);
 251       tct = GNUNET_SCHEDULER_NO_TASK;
 252       GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
 253       GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
 254       die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_TRANSMIT,
 255                                                &end_badly, NULL);
 256       GNUNET_TRANSPORT_notify_transmit_ready (p1.th,
 257                                               &p2.id,
 258                                               256, 0, TIMEOUT, &notify_ready,
 259                                               &p1);
 260     }
 261 }
 262
 263
 264 static void
 265 notify_disconnect (void *cls,
 266                    const struct GNUNET_PeerIdentity *peer)
 267 {
 268   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 269               "Peer `%4s' disconnected (%p)!\n",
 270               GNUNET_i2s (peer), cls);
 271 }
 272
 273
 274 static void
 275 setup_peer (struct PeerContext *p,
 276             const char *cfgname)
 277 {
 278   p->cfg = GNUNET_CONFIGURATION_create ();
 279 #if START_ARM
 280   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
 281                                         "gnunet-service-arm",
 282 #if VERBOSE_ARM
 283                                         "-L", "DEBUG",
 284 #endif
 285                                         "-c", cfgname, NULL);
 286 #endif
 287   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 288
 289   if (is_https)
 290     {
 291       struct stat sbuf;
 292       if (p==&p1)
 293         {
 294           if (GNUNET_CONFIGURATION_have_value (p->cfg,
 295                                                "transport-https", "KEY_FILE"))
 296             GNUNET_CONFIGURATION_get_value_string (p->cfg, "transport-https", "KEY_FILE", &key_file_p1);
 297           if (key_file_p1==NULL)
 298             GNUNET_asprintf(&key_file_p1,"https.key");
 299           if (0 == stat (key_file_p1, &sbuf ))
 300             {
 301               if (0 == remove(key_file_p1))
 302                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 303                             "Successfully removed existing private key file `%s'\n",key_file_p1);
 304               else
 305                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 306                             "Failed to remove private key file `%s'\n",key_file_p1);
 307             }
 308           if (GNUNET_CONFIGURATION_have_value (p->cfg,"transport-https", "CERT_FILE"))
 309             GNUNET_CONFIGURATION_get_value_string (p->cfg, "transport-https", "CERT_FILE", &cert_file_p1);
 310           if (cert_file_p1==NULL)
 311             GNUNET_asprintf(&cert_file_p1,"https.cert");
 312           if (0 == stat (cert_file_p1, &sbuf ))
 313             {
 314               if (0 == remove(cert_file_p1))
 315                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 316                             "Successfully removed existing certificate file `%s'\n",
 317                             cert_file_p1);
 318               else
 319                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 320                             "Failed to remove existing certificate file `%s'\n",
 321                             cert_file_p1);
 322             }
 323         }
 324       else if (p==&p2)
 325         {
 326           if (GNUNET_CONFIGURATION_have_value (p->cfg,
 327                                                "transport-https", "KEY_FILE"))
 328             GNUNET_CONFIGURATION_get_value_string (p->cfg, "transport-https", "KEY_FILE", &key_file_p2);
 329           if (key_file_p2==NULL)
 330             GNUNET_asprintf(&key_file_p2,"https.key");
 331           if (0 == stat (key_file_p2, &sbuf ))
 332             {
 333               if (0 == remove(key_file_p2))
 334                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 335                             "Successfully removed existing private key file `%s'\n",
 336                             key_file_p2);
 337               else
 338                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 339                             "Failed to remove private key file `%s'\n",
 340                             key_file_p2);
 341             }
 342           if (GNUNET_CONFIGURATION_have_value (p->cfg,"transport-https", "CERT_FILE"))
 343             GNUNET_CONFIGURATION_get_value_string (p->cfg, "transport-https", "CERT_FILE", &cert_file_p2);
 344           if (cert_file_p2==NULL)
 345             GNUNET_asprintf(&cert_file_p2,"https.cert");
 346           if (0 == stat (cert_file_p2, &sbuf ))
 347             {
 348               if (0 == remove(cert_file_p2))
 349                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 350                             "Successfully removed existing certificate file `%s'\n",cert_file_p2);
 351               else
 352                 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 353                             "Failed to remove existing certificate file `%s'\n",cert_file_p2);
 354             }
 355         }
 356     }
 357
 358   p->th = GNUNET_TRANSPORT_connect (p->cfg,
 359                                     NULL, p,
 360                                     &notify_receive,
 361                                     &notify_connect, &notify_disconnect);
 362   GNUNET_assert (p->th != NULL);
 363 }
 364
 365
 366 static void
 367 try_connect (void *cls,
 368              const struct GNUNET_SCHEDULER_TaskContext *tc)
 369 {
 370   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 371               "Asking peers to connect...\n");
 372   GNUNET_TRANSPORT_try_connect (p2.th,
 373                                 &p1.id);
 374   GNUNET_TRANSPORT_try_connect (p1.th,
 375                                 &p2.id);
 376   tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
 377                                       &try_connect,
 378                                       NULL);
 379 }
 380
 381
 382 static void
 383 run (void *cls,
 384      char *const *args,
 385      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 386 {
 387   GNUNET_assert (ok == 1);
 388   OKPP;
 389   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
 390                                            &end_badly, NULL);
 391
 392   if (is_udp)
 393     {
 394       setup_peer (&p1, "test_transport_api_udp_peer1.conf");
 395       setup_peer (&p2, "test_transport_api_udp_peer2.conf");
 396     }
 397   if (is_unix)
 398     {
 399       setup_peer (&p1, "test_transport_api_unix_peer1.conf");
 400       setup_peer (&p2, "test_transport_api_unix_peer2.conf");
 401     }
 402   if (is_multi_protocol)
 403     {
 404       setup_peer (&p1, "test_transport_api_multi_peer1.conf");
 405       setup_peer (&p2, "test_transport_api_multi_peer2.conf");
 406     }
 407   else if (is_tcp)
 408     {
 409       setup_peer (&p1, "test_transport_api_tcp_peer1.conf");
 410       setup_peer (&p2, "test_transport_api_tcp_peer2.conf");
 411     }
 412   else if (is_tcp_nat)
 413     {
 414       setup_peer (&p1, "test_transport_api_tcp_nat_peer1.conf");
 415       setup_peer (&p2, "test_transport_api_tcp_nat_peer2.conf");
 416     }
 417   else if (is_udp_nat)
 418     {
 419       setup_peer (&p1, "test_transport_api_udp_nat_peer1.conf");
 420       setup_peer (&p2, "test_transport_api_udp_nat_peer2.conf");
 421     }
 422   else if (is_http)
 423     {
 424       setup_peer (&p1, "test_transport_api_http_peer1.conf");
 425       setup_peer (&p2, "test_transport_api_http_peer2.conf");
 426     }
 427   else if (is_https)
 428     {
 429       setup_peer (&p1, "test_transport_api_https_peer1.conf");
 430       setup_peer (&p2, "test_transport_api_https_peer2.conf");
 431     }
 432   else if (is_wlan)
 433     {
 434       setup_peer (&p1, "test_transport_api_wlan_peer1.conf");
 435       setup_peer (&p2, "test_transport_api_wlan_peer2.conf");
 436     }
 437   GNUNET_assert(p1.th != NULL);
 438   GNUNET_assert(p2.th != NULL);
 439
 440   GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1);
 441   GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
 442   tct = GNUNET_SCHEDULER_add_now (&try_connect, NULL);
 443 }
 444
 445 static int
 446 check ()
 447 {
 448   static char *const argv[] = { "test-transport-api",
 449     "-c",
 450     "test_transport_api_data.conf",
 451 #if VERBOSE
 452     "-L", "DEBUG",
 453 #endif
 454     NULL
 455   };
 456   static struct GNUNET_GETOPT_CommandLineOption options[] = {
 457     GNUNET_GETOPT_OPTION_END
 458   };
 459
 460 #if WRITECONFIG
 461   setTransportOptions("test_transport_api_data.conf");
 462 #endif
 463   ok = 1;
 464   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
 465                       argv, "test-transport-api", "nohelp",
 466                       options, &run, &ok);
 467   stop_arm (&p1);
 468   stop_arm (&p2);
 469
 470   if (is_https)
 471     {
 472       struct stat sbuf;
 473       if (0 == stat (cert_file_p1, &sbuf ))
 474         {
 475           if (0 == remove(cert_file_p1))
 476             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 477                         "Successfully removed existing certificate file `%s'\n",cert_file_p1);
 478           else
 479             GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 480                         "Failed to remove certfile `%s'\n",cert_file_p1);
 481         }
 482
 483       if (0 == stat (key_file_p1, &sbuf ))
 484         {
 485           if (0 == remove(key_file_p1))
 486             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 487                         "Successfully removed private key file `%s'\n",key_file_p1);
 488           else
 489             GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 490                         "Failed to private key file `%s'\n",key_file_p1);
 491         }
 492
 493       if (0 == stat (cert_file_p2, &sbuf ))
 494         {
 495           if (0 == remove(cert_file_p2))
 496             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 497                         "Successfully removed existing certificate file `%s'\n",cert_file_p2);
 498           else
 499             GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 500                         "Failed to remove certfile `%s'\n",cert_file_p2);
 501         }
 502
 503       if (0 == stat (key_file_p2, &sbuf ))
 504         {
 505           if (0 == remove(key_file_p2))
 506             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 507                         "Successfully removed private key file `%s'\n",key_file_p2);
 508           else
 509             GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 510                         "Failed to private key file `%s'\n",key_file_p2);
 511         }
 512       GNUNET_free(key_file_p1);
 513       GNUNET_free(key_file_p2);
 514       GNUNET_free(cert_file_p1);
 515       GNUNET_free(cert_file_p2);
 516     }
 517   return ok;
 518 }
 519
 520 /**
 521  * Return the actual path to a file found in the current
 522  * PATH environment variable.
 523  *
 524  * @param binary the name of the file to find
 525  */
 526 static char *
 527 get_path_from_PATH (char *binary)
 528 {
 529   char *path;
 530   char *pos;
 531   char *end;
 532   char *buf;
 533   const char *p;
 534
 535   p = getenv ("PATH");
 536   if (p == NULL)
 537     {
 538       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 539                   _("PATH environment variable is unset.\n"));
 540       return NULL;
 541     }
 542   path = GNUNET_strdup (p);     /* because we write on it */
 543   buf = GNUNET_malloc (strlen (path) + 20);
 544   pos = path;
 545
 546   while (NULL != (end = strchr (pos, PATH_SEPARATOR)))
 547     {
 548       *end = '\0';
 549       sprintf (buf, "%s/%s", pos, binary);
 550       if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
 551         {
 552           GNUNET_free (path);
 553           return buf;
 554         }
 555       pos = end + 1;
 556     }
 557   sprintf (buf, "%s/%s", pos, binary);
 558   if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
 559     {
 560       GNUNET_free (path);
 561       return buf;
 562     }
 563   GNUNET_free (buf);
 564   GNUNET_free (path);
 565   return NULL;
 566 }
 567
 568 /**
 569  * Check whether the suid bit is set on a file.
 570  * Attempts to find the file using the current
 571  * PATH environment variable as a search path.
 572  *
 573  * @param binary the name of the file to check
 574  *
 575  * @return GNUNET_YES if the binary is found and
 576  *         can be run properly, GNUNET_NO otherwise
 577  */
 578 static int
 579 check_gnunet_nat_binary(char *binary)
 580 {
 581   struct stat statbuf;
 582   char *p;
 583 #ifdef MINGW
 584   SOCKET rawsock;
 585 #endif
 586
 587 #ifdef MINGW
 588   char *binaryexe;
 589   GNUNET_asprintf (&binaryexe, "%s.exe", binary);
 590   p = get_path_from_PATH (binaryexe);
 591   free (binaryexe);
 592 #else
 593   p = get_path_from_PATH (binary);
 594 #endif
 595   if (p == NULL)
 596     {
 597       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 598                   _("Could not find binary `%s' in PATH!\n"),
 599                   binary);
 600       return GNUNET_NO;
 601     }
 602   if (0 != STAT (p, &statbuf))
 603     {
 604       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 605                   _("stat (%s) failed: %s\n"),
 606                   p,
 607                   STRERROR (errno));
 608       GNUNET_free (p);
 609       return GNUNET_SYSERR;
 610     }
 611   GNUNET_free (p);
 612 #ifndef MINGW
 613   if ( (0 != (statbuf.st_mode & S_ISUID)) &&
 614        (statbuf.st_uid == 0) )
 615     return GNUNET_YES;
 616   return GNUNET_NO;
 617 #else
 618   rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
 619   if (INVALID_SOCKET == rawsock)
 620     {
 621       DWORD err = GetLastError ();
 622       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 623                   "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n", err);
 624       return GNUNET_NO; /* not running as administrator */
 625     }
 626   closesocket (rawsock);
 627   return GNUNET_YES;
 628 #endif
 629 }
 630
 631 int
 632 main (int argc, char *argv[])
 633 {
 634   int ret;
 635 #ifdef MINGW
 636   return GNUNET_SYSERR;
 637 #endif
 638
 639   GNUNET_log_setup ("test-transport-api",
 640 #if VERBOSE
 641                     "DEBUG",
 642 #else
 643                     "WARNING",
 644 #endif
 645                     NULL);
 646
 647   if (strstr(argv[0], "tcp_nat") != NULL)
 648     {
 649       is_tcp_nat = GNUNET_YES;
 650       if (GNUNET_YES != check_gnunet_nat_binary("gnunet-nat-server"))
 651         {
 652           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 653                       "`%s' not properly installed, cannot run NAT test!\n",
 654                       "gnunet-nat-server");
 655           return 0;
 656         }
 657     }
 658   else if (strstr(argv[0], "tcp") != NULL)
 659     {
 660       is_tcp = GNUNET_YES;
 661     }
 662   else if (strstr(argv[0], "udp_nat") != NULL)
 663     {
 664       is_udp_nat = GNUNET_YES;
 665       if (GNUNET_YES != check_gnunet_nat_binary("gnunet-nat-server"))
 666         {
 667           GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 668                       "`%s' not properly installed, cannot run NAT test!\n",
 669                       "gnunet-nat-server");
 670           return 0;
 671         }
 672     }
 673   else if (strstr(argv[0], "udp") != NULL)
 674     {
 675       is_udp = GNUNET_YES;
 676     }
 677   else if (strstr(argv[0], "unix") != NULL)
 678     {
 679       is_unix = GNUNET_YES;
 680     }
 681   else if (strstr(argv[0], "https") != NULL)
 682     {
 683       is_https = GNUNET_YES;
 684     }
 685   else if (strstr(argv[0], "http") != NULL)
 686     {
 687       is_http = GNUNET_YES;
 688     }
 689   else if (strstr(argv[0], "wlan") != NULL)
 690     {
 691        is_wlan = GNUNET_YES;
 692     }
 693   else if (strstr(argv[0], "multi") != NULL)
 694     {
 695        is_multi_protocol = GNUNET_YES;
 696     }
 697
 698   ret = check ();
 699   if (is_multi_protocol)
 700   {
 701          GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-transport-multi-peer-1/");
 702          GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-transport-multi-peer-2/");
 703   }
 704   else
 705   {
 706          GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-transport-peer-1");
 707          GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-transport-peer-2");
 708   }
 709
 710   return ret;
 711 }
 712
 713 /* end of test_transport_api.c */