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 #include "transport-testing.h"
  39
  40 #define VERBOSE GNUNET_NO
  41
  42 #define VERBOSE_ARM GNUNET_NO
  43
  44 #define START_ARM GNUNET_YES
  45
  46 /**
  47  * How long until we give up on transmitting the message?
  48  */
  49 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
  50
  51 /**
  52  * How long until we give up on transmitting the message?
  53  */
  54 #define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
  55
  56 #define MTYPE 12345
  57
  58 static int ok;
  59
  60 static GNUNET_SCHEDULER_TaskIdentifier die_task;
  61
  62 static GNUNET_SCHEDULER_TaskIdentifier send_task;
  63
  64 struct PeerContext *p1;
  65
  66 struct PeerContext *p2;
  67
  68 static GNUNET_TRANSPORT_TESTING_ConnectRequest cc;
  69
  70 struct GNUNET_TRANSPORT_TransmitHandle *th;
  71
  72 char *cfg_file_p1;
  73
  74 char *cfg_file_p2;
  75
  76 #if VERBOSE
  77 #define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
  78 #else
  79 #define OKPP do { ok++; } while (0)
  80 #endif
  81
  82
  83 static void
  84 end ()
  85 {
  86   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
  87
  88   if (send_task != GNUNET_SCHEDULER_NO_TASK)
  89     GNUNET_SCHEDULER_cancel (send_task);
  90
  91   if (die_task != GNUNET_SCHEDULER_NO_TASK)
  92     GNUNET_SCHEDULER_cancel (die_task);
  93
  94   if (th != NULL)
  95     GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
  96   th = NULL;
  97
  98   GNUNET_TRANSPORT_TESTING_stop_peer (p1);
  99   GNUNET_TRANSPORT_TESTING_stop_peer (p2);
 100 }
 101
 102 static void
 103 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 104 {
 105   die_task = GNUNET_SCHEDULER_NO_TASK;
 106
 107   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
 108
 109   if (send_task != GNUNET_SCHEDULER_NO_TASK)
 110     GNUNET_SCHEDULER_cancel (send_task);
 111
 112   if (cc != NULL)
 113     GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc);
 114
 115   if (th != NULL)
 116     GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
 117   th = NULL;
 118
 119   if (p1 != NULL)
 120     GNUNET_TRANSPORT_TESTING_stop_peer (p1);
 121   if (p2 != NULL)
 122     GNUNET_TRANSPORT_TESTING_stop_peer (p2);
 123
 124   ok = GNUNET_SYSERR;
 125 }
 126
 127
 128 static void
 129 notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
 130                 const struct GNUNET_MessageHeader *message,
 131                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
 132                 uint32_t ats_count)
 133 {
 134   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 135               "Received message of type %d from peer %s!\n",
 136               ntohs (message->type), GNUNET_i2s (peer));
 137
 138   if ((MTYPE == ntohs (message->type)) &&
 139       (sizeof (struct GNUNET_MessageHeader) == ntohs (message->size)))
 140   {
 141     ok = 0;
 142     end ();
 143   }
 144   else
 145   {
 146     GNUNET_break (0);
 147     ok = 1;
 148     end ();
 149   }
 150 }
 151
 152
 153 static size_t
 154 notify_ready (void *cls, size_t size, void *buf)
 155 {
 156   struct PeerContext *p = cls;
 157   struct GNUNET_MessageHeader *hdr;
 158
 159   th = NULL;
 160
 161   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 162               "Transmitting message with %u bytes to peer %s\n",
 163               sizeof (struct GNUNET_MessageHeader), GNUNET_i2s (&p->id));
 164   GNUNET_assert (size >= 256);
 165
 166   if (buf != NULL)
 167   {
 168     hdr = buf;
 169     hdr->size = htons (sizeof (struct GNUNET_MessageHeader));
 170     hdr->type = htons (MTYPE);
 171   }
 172   return sizeof (struct GNUNET_MessageHeader);
 173 }
 174
 175
 176 static void
 177 notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
 178                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
 179                 uint32_t ats_count)
 180 {
 181   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer `%4s' connected to us (%p)!\n",
 182               GNUNET_i2s (peer), cls);
 183 }
 184
 185
 186 static void
 187 notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 188 {
 189   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer `%4s' disconnected (%p)!\n",
 190               GNUNET_i2s (peer), cls);
 191 }
 192
 193 static void
 194 sendtask (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 195 {
 196   send_task = GNUNET_SCHEDULER_NO_TASK;
 197
 198   if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
 199     return;
 200
 201   th = GNUNET_TRANSPORT_notify_transmit_ready (p1->th, &p2->id, 256, 0, TIMEOUT,
 202                                                &notify_ready, &p1);
 203 }
 204
 205 static void
 206 testing_connect_cb (struct PeerContext *p1, struct PeerContext *p2, void *cls)
 207 {
 208   cc = NULL;
 209   char *p1_c = strdup (GNUNET_i2s (&p1->id));
 210
 211   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected: %s <-> %s\n", p1_c,
 212               GNUNET_i2s (&p2->id));
 213   GNUNET_free (p1_c);
 214
 215   // FIXME: THIS IS REQUIRED! SEEMS TO BE A BUG!
 216   send_task =
 217       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &sendtask, NULL);
 218 }
 219
 220 static void
 221 run (void *cls, char *const *args, const char *cfgfile,
 222      const struct GNUNET_CONFIGURATION_Handle *cfg)
 223 {
 224   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
 225
 226   p1 = GNUNET_TRANSPORT_TESTING_start_peer (cfg_file_p1, &notify_receive,
 227                                             &notify_connect, &notify_disconnect,
 228                                             NULL);
 229   p2 = GNUNET_TRANSPORT_TESTING_start_peer (cfg_file_p2, &notify_receive,
 230                                             &notify_connect, &notify_disconnect,
 231                                             NULL);
 232   cc = GNUNET_TRANSPORT_TESTING_connect_peers (p1, p2, &testing_connect_cb,
 233                                                NULL);
 234 }
 235
 236 static int
 237 check ()
 238 {
 239   static char *const argv[] = { "test-transport-api",
 240     "-c",
 241     "test_transport_api_data.conf",
 242 #if VERBOSE
 243     "-L", "DEBUG",
 244 #endif
 245     NULL
 246   };
 247   static struct GNUNET_GETOPT_CommandLineOption options[] = {
 248     GNUNET_GETOPT_OPTION_END
 249   };
 250
 251 #if WRITECONFIG
 252   setTransportOptions ("test_transport_api_data.conf");
 253 #endif
 254   send_task = GNUNET_SCHEDULER_NO_TASK;
 255
 256   ok = 1;
 257   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
 258                       "test-transport-api", "nohelp", options, &run, &ok);
 259
 260   return ok;
 261 }
 262
 263 /**
 264  * Return the actual path to a file found in the current
 265  * PATH environment variable.
 266  *
 267  * @param binary the name of the file to find
 268  */
 269 static char *
 270 get_path_from_PATH (char *binary)
 271 {
 272   char *path;
 273   char *pos;
 274   char *end;
 275   char *buf;
 276   const char *p;
 277
 278   p = getenv ("PATH");
 279   if (p == NULL)
 280   {
 281     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 282                 _("PATH environment variable is unset.\n"));
 283     return NULL;
 284   }
 285   path = GNUNET_strdup (p);     /* because we write on it */
 286   buf = GNUNET_malloc (strlen (path) + 20);
 287   pos = path;
 288
 289   while (NULL != (end = strchr (pos, PATH_SEPARATOR)))
 290   {
 291     *end = '\0';
 292     sprintf (buf, "%s/%s", pos, binary);
 293     if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
 294     {
 295       GNUNET_free (path);
 296       return buf;
 297     }
 298     pos = end + 1;
 299   }
 300   sprintf (buf, "%s/%s", pos, binary);
 301   if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
 302   {
 303     GNUNET_free (path);
 304     return buf;
 305   }
 306   GNUNET_free (buf);
 307   GNUNET_free (path);
 308   return NULL;
 309 }
 310
 311 /**
 312  * Check whether the suid bit is set on a file.
 313  * Attempts to find the file using the current
 314  * PATH environment variable as a search path.
 315  *
 316  * @param binary the name of the file to check
 317  *
 318  * @return GNUNET_YES if the binary is found and
 319  *         can be run properly, GNUNET_NO otherwise
 320  */
 321 static int
 322 check_gnunet_nat_binary (char *binary)
 323 {
 324   struct stat statbuf;
 325   char *p;
 326
 327 #ifdef MINGW
 328   SOCKET rawsock;
 329 #endif
 330
 331 #ifdef MINGW
 332   char *binaryexe;
 333
 334   GNUNET_asprintf (&binaryexe, "%s.exe", binary);
 335   p = get_path_from_PATH (binaryexe);
 336   free (binaryexe);
 337 #else
 338   p = get_path_from_PATH (binary);
 339 #endif
 340   if (p == NULL)
 341   {
 342     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 343                 _("Could not find binary `%s' in PATH!\n"), binary);
 344     return GNUNET_NO;
 345   }
 346   if (0 != STAT (p, &statbuf))
 347   {
 348     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("stat (%s) failed: %s\n"), p,
 349                 STRERROR (errno));
 350     GNUNET_free (p);
 351     return GNUNET_SYSERR;
 352   }
 353   GNUNET_free (p);
 354 #ifndef MINGW
 355   if ((0 != (statbuf.st_mode & S_ISUID)) && (statbuf.st_uid == 0))
 356     return GNUNET_YES;
 357   return GNUNET_NO;
 358 #else
 359   rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
 360   if (INVALID_SOCKET == rawsock)
 361   {
 362     DWORD err = GetLastError ();
 363
 364     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 365                 "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n",
 366                 err);
 367     return GNUNET_NO;           /* not running as administrator */
 368   }
 369   closesocket (rawsock);
 370   return GNUNET_YES;
 371 #endif
 372 }
 373
 374 int
 375 main (int argc, char *argv[])
 376 {
 377   int ret;
 378
 379   GNUNET_log_setup ("test-transport-api",
 380 #if VERBOSE
 381                     "DEBUG",
 382 #else
 383                     "WARNING",
 384 #endif
 385                     NULL);
 386
 387   char *pch = strdup (argv[0]);
 388   char *backup = pch;
 389   char *filename = NULL;
 390   char *dotexe;
 391
 392   /* get executable filename */
 393   pch = strtok (pch, "/");
 394   while (pch != NULL)
 395   {
 396     pch = strtok (NULL, "/");
 397     if (pch != NULL)
 398       filename = pch;
 399   }
 400   /* remove "lt-" */
 401   filename = strstr (filename, "tes");
 402   if (NULL != (dotexe = strstr (filename, ".exe")))
 403     dotexe[0] = '\0';
 404
 405   /* create cfg filename */
 406   GNUNET_asprintf (&cfg_file_p1, "%s_peer1.conf", filename);
 407   GNUNET_asprintf (&cfg_file_p2, "%s_peer2.conf", filename);
 408   GNUNET_free (backup);
 409
 410   if (strstr (argv[0], "tcp_nat") != NULL)
 411   {
 412     if (GNUNET_YES != check_gnunet_nat_binary ("gnunet-nat-server"))
 413     {
 414       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 415                   "`%s' not properly installed, cannot run NAT test!\n",
 416                   "gnunet-nat-server");
 417       return 0;
 418     }
 419   }
 420   else if (strstr (argv[0], "udp_nat") != NULL)
 421   {
 422     if (GNUNET_YES != check_gnunet_nat_binary ("gnunet-nat-server"))
 423     {
 424       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 425                   "`%s' not properly installed, cannot run NAT test!\n",
 426                   "gnunet-nat-server");
 427       return 0;
 428     }
 429   }
 430
 431   ret = check ();
 432
 433   GNUNET_free (cfg_file_p1);
 434   GNUNET_free (cfg_file_p2);
 435
 436   return ret;
 437 }
 438
 439 /* end of test_transport_api.c */