src/transport/gnunet-transport.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2011 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 /**
  22  * @file src/transport/gnunet-transport.c
  23  * @brief Tool to help configure, measure and control the transport subsystem.
  24  * @author Christian Grothoff
  25  * @author Nathan Evans
  26  *
  27  * This utility can be used to test if a transport mechanism for
  28  * GNUnet is properly configured.
  29  */
  30
  31 #include "platform.h"
  32 #include "gnunet_util_lib.h"
  33 #include "gnunet_resolver_service.h"
  34 #include "gnunet_protocols.h"
  35 #include "gnunet_transport_service.h"
  36 #include "gnunet_nat_lib.h"
  37
  38 /**
  39  * How long do we wait for the NAT test to report success?
  40  * Should match NAT_SERVER_TIMEOUT in 'nat_test.c'.
  41  */
  42 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
  43 #define RESOLUTION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
  44 #define OP_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
  45
  46 /**
  47  * Benchmarking block size in KB
  48  */
  49 #define BLOCKSIZE 4
  50
  51
  52 /**
  53  * Which peer should we connect to?
  54  */
  55 static char *cpid;
  56
  57 /**
  58  * Handle to transport service.
  59  */
  60 static struct GNUNET_TRANSPORT_Handle *handle;
  61
  62 /**
  63  * Configuration handle
  64  */
  65 static struct GNUNET_CONFIGURATION_Handle *cfg;
  66
  67 /**
  68  * Try_connect handle
  69  */
  70 struct GNUNET_TRANSPORT_TryConnectHandle * tc_handle;
  71
  72 /**
  73  * Option -s.
  74  */
  75 static int benchmark_send;
  76
  77 /**
  78  * Option -b.
  79  */
  80 static int benchmark_receive;
  81
  82 /**
  83  * Option -l.
  84  */
  85 static int benchmark_receive;
  86
  87 /**
  88  * Option -i.
  89  */
  90 static int iterate_connections;
  91
  92 /**
  93  * Option -t.
  94  */
  95 static int test_configuration;
  96
  97 /**
  98  * Option -c.
  99  */
 100 static int monitor_connects;
 101
 102 /**
 103  * Option -m.
 104  */
 105 static int monitor_connections;
 106
 107 /**
 108  * Option -C.
 109  */
 110 static int try_connect;
 111
 112 /**
 113  * Option -n.
 114  */
 115 static int numeric;
 116
 117 /**
 118  * Global return value (0 success).
 119  */
 120 static int ret;
 121
 122 /**
 123  * Current number of connections in monitor mode
 124  */
 125 static int monitor_connect_counter;
 126
 127 /**
 128  * Number of bytes of traffic we received so far.
 129  */
 130 static unsigned long long traffic_received;
 131
 132 /**
 133  * Number of bytes of traffic we sent so far.
 134  */
 135 static unsigned long long traffic_sent;
 136
 137 /**
 138  * Starting time of transmitting/receiving data.
 139  */
 140 static struct GNUNET_TIME_Absolute start_time;
 141
 142 /**
 143  * Handle for current transmission request.
 144  */
 145 static struct GNUNET_TRANSPORT_TransmitHandle *th;
 146
 147 /**
 148  *
 149  */
 150 struct GNUNET_TRANSPORT_PeerIterateContext *pic;
 151
 152 /**
 153  * Identity of the peer we transmit to / connect to.
 154  * (equivalent to 'cpid' string).
 155  */
 156 static struct GNUNET_PeerIdentity pid;
 157
 158 /**
 159  * Task scheduled for cleanup / termination of the process.
 160  */
 161 static GNUNET_SCHEDULER_TaskIdentifier end;
 162
 163 /**
 164  * Task for operation timeout
 165  */
 166 static GNUNET_SCHEDULER_TaskIdentifier op_timeout;
 167
 168
 169 static struct GNUNET_CONTAINER_MultiHashMap *peers;
 170
 171 /**
 172  * Selected level of verbosity.
 173  */
 174 static int verbosity;
 175
 176 /**
 177  * Resolver process handle.
 178  */
 179 struct GNUNET_OS_Process *resolver;
 180
 181 /**
 182  * Number of tasks running that still need the resolver.
 183  */
 184 static unsigned int resolver_users;
 185
 186 /**
 187  * Number of address resolutions pending
 188  */
 189 static unsigned int address_resolutions;
 190
 191 /**
 192  * Address resolutions pending in progress
 193  */
 194 static unsigned int address_resolution_in_progress;
 195
 196 /**
 197  * Context for a plugin test.
 198  */
 199 struct TestContext
 200 {
 201
 202   /**
 203    * Handle to the active NAT test.
 204    */
 205   struct GNUNET_NAT_Test *tst;
 206
 207   /**
 208    * Task identifier for the timeout.
 209    */
 210   GNUNET_SCHEDULER_TaskIdentifier tsk;
 211
 212   /**
 213    * Name of plugin under test.
 214    */
 215   const char *name;
 216
 217 };
 218
 219
 220 /**
 221  * Task run in monitor mode when the user presses CTRL-C to abort.
 222  * Stops monitoring activity.
 223  *
 224  * @param cls the 'struct GNUNET_TRANSPORT_PeerIterateContext *'
 225  * @param tc scheduler context
 226  */
 227 static void
 228 shutdown_task (void *cls,
 229                const struct GNUNET_SCHEDULER_TaskContext *tc)
 230 {
 231   struct GNUNET_TIME_Relative duration;
 232   end = GNUNET_SCHEDULER_NO_TASK;
 233   if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
 234   {
 235       GNUNET_SCHEDULER_cancel (op_timeout);
 236       op_timeout = GNUNET_SCHEDULER_NO_TASK;
 237   }
 238   if (NULL != tc_handle)
 239   {
 240       GNUNET_TRANSPORT_try_connect_cancel (tc_handle);
 241       tc_handle = NULL;
 242   }
 243   if (NULL != pic)
 244   {
 245       GNUNET_TRANSPORT_peer_get_active_addresses_cancel (pic);
 246       pic = NULL;
 247   }
 248   if (NULL != th)
 249   {
 250     GNUNET_TRANSPORT_notify_transmit_ready_cancel(th);
 251     th = NULL;
 252   }
 253   if (NULL != handle)
 254   {
 255     GNUNET_TRANSPORT_disconnect(handle);
 256     handle = NULL;
 257   }
 258   if (NULL != peers)
 259   {
 260     GNUNET_CONTAINER_multihashmap_destroy (peers);
 261     peers = NULL;
 262   }
 263   if (benchmark_send)
 264   {
 265     duration = GNUNET_TIME_absolute_get_duration (start_time);
 266     FPRINTF (stdout, _("Transmitted %llu bytes/s (%llu bytes in %s)\n"),
 267              1000 * traffic_sent / (1 + duration.rel_value), traffic_sent,
 268              GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
 269   }
 270   if (benchmark_receive)
 271   {
 272     duration = GNUNET_TIME_absolute_get_duration (start_time);
 273     FPRINTF (stdout, _("Received %llu bytes/s (%llu bytes in %s)\n"),
 274              1000 * traffic_received / (1 + duration.rel_value),
 275              traffic_received,
 276              GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
 277   }
 278 }
 279
 280 struct ResolutionContext *rc_head;
 281 struct ResolutionContext *rc_tail;
 282
 283 struct ResolutionContext
 284 {
 285         struct ResolutionContext *next;
 286         struct ResolutionContext *prev;
 287   struct GNUNET_HELLO_Address *addrcp;
 288   struct GNUNET_TRANSPORT_AddressToStringContext *asc;
 289   int printed;
 290 };
 291
 292
 293 static void
 294 operation_timeout (void *cls,
 295                const struct GNUNET_SCHEDULER_TaskContext *tc)
 296 {
 297         struct ResolutionContext *cur;
 298         struct ResolutionContext *next;
 299   op_timeout = GNUNET_SCHEDULER_NO_TASK;
 300   if ((try_connect) || (benchmark_send) ||
 301                 (benchmark_receive))
 302   {
 303       FPRINTF (stdout, _("Failed to connect to `%s'\n"), GNUNET_h2s_full (&pid.hashPubKey));
 304       if (GNUNET_SCHEDULER_NO_TASK != end)
 305         GNUNET_SCHEDULER_cancel (end);
 306       end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
 307       ret = 1;
 308       return;
 309   }
 310   if (iterate_connections)
 311   {
 312                 next = rc_head;
 313                 while (NULL != (cur = next))
 314                 {
 315                                 next = cur->next;
 316                                 FPRINTF (stdout, _("Failed to resolve address for peer `%s'\n"),
 317                                                 GNUNET_i2s (&cur->addrcp->peer));
 318
 319                                 GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, cur);
 320                                 GNUNET_TRANSPORT_address_to_string_cancel (cur->asc);
 321                                 GNUNET_free (cur->addrcp);
 322                                 GNUNET_free (cur);
 323
 324                 }
 325                 FPRINTF (stdout, "%s", _("Failed to list connections, timeout occured\n"));
 326       if (GNUNET_SCHEDULER_NO_TASK != end)
 327         GNUNET_SCHEDULER_cancel (end);
 328       end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
 329       ret = 1;
 330       return;
 331   }
 332
 333 }
 334
 335
 336
 337 /**
 338  * Display the result of the test.
 339  *
 340  * @param tc test context
 341  * @param result GNUNET_YES on success
 342  */
 343 static void
 344 display_test_result (struct TestContext *tc, int result)
 345 {
 346   if (GNUNET_YES != result)
 347   {
 348     FPRINTF (stderr, "Configuration for plugin `%s' did not work!\n", tc->name);
 349   }
 350   else
 351   {
 352     FPRINTF (stderr, "Configuration for plugin `%s' is working!\n", tc->name);
 353   }
 354   if (GNUNET_SCHEDULER_NO_TASK != tc->tsk)
 355   {
 356     GNUNET_SCHEDULER_cancel (tc->tsk);
 357     tc->tsk = GNUNET_SCHEDULER_NO_TASK;
 358   }
 359   if (NULL != tc->tst)
 360   {
 361     GNUNET_NAT_test_stop (tc->tst);
 362     tc->tst = NULL;
 363   }
 364   GNUNET_free (tc);
 365   resolver_users--;
 366   if ((0 == resolver_users) && (NULL != resolver))
 367   {
 368     GNUNET_break (0 == GNUNET_OS_process_kill (resolver, SIGTERM));
 369     GNUNET_OS_process_destroy (resolver);
 370     resolver = NULL;
 371   }
 372 }
 373
 374
 375 /**
 376  * Function called by NAT on success.
 377  * Clean up and update GUI (with success).
 378  *
 379  * @param cls test context
 380  * @param success currently always GNUNET_OK
 381  */
 382 static void
 383 result_callback (void *cls, int success)
 384 {
 385   struct TestContext *tc = cls;
 386
 387   display_test_result (tc, success);
 388 }
 389
 390
 391 /**
 392  * Function called if NAT failed to confirm success.
 393  * Clean up and update GUI (with failure).
 394  *
 395  * @param cls test context
 396  * @param tc scheduler callback
 397  */
 398 static void
 399 fail_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 400 {
 401   struct TestContext *tstc = cls;
 402
 403   tstc->tsk = GNUNET_SCHEDULER_NO_TASK;
 404   display_test_result (tstc, GNUNET_NO);
 405 }
 406
 407
 408 /**
 409  * Test our plugin's configuration (NAT traversal, etc.).
 410  *
 411  * @param cfg configuration to test
 412  */
 413 static void
 414 do_test_configuration (const struct GNUNET_CONFIGURATION_Handle *cfg)
 415 {
 416   char *plugins;
 417   char *tok;
 418   unsigned long long bnd_port;
 419   unsigned long long adv_port;
 420   struct TestContext *tc;
 421
 422   if (GNUNET_OK !=
 423       GNUNET_CONFIGURATION_get_value_string (cfg, "transport", "plugins",
 424                                              &plugins))
 425   {
 426     FPRINTF (stderr,
 427              "%s",
 428              _
 429              ("No transport plugins configured, peer will never communicate\n"));
 430     ret = 4;
 431     return;
 432   }
 433   for (tok = strtok (plugins, " "); tok != NULL; tok = strtok (NULL, " "))
 434   {
 435     char section[12 + strlen (tok)];
 436
 437     GNUNET_snprintf (section, sizeof (section), "transport-%s", tok);
 438     if (GNUNET_OK !=
 439         GNUNET_CONFIGURATION_get_value_number (cfg, section, "PORT", &bnd_port))
 440     {
 441       FPRINTF (stderr,
 442                _("No port configured for plugin `%s', cannot test it\n"), tok);
 443       continue;
 444     }
 445     if (GNUNET_OK !=
 446         GNUNET_CONFIGURATION_get_value_number (cfg, section, "ADVERTISED_PORT",
 447                                                &adv_port))
 448       adv_port = bnd_port;
 449     if (NULL == resolver)
 450       resolver =
 451           GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL, "gnunet-service-resolver",
 452                                    "gnunet-service-resolver", NULL);
 453     resolver_users++;
 454     GNUNET_RESOLVER_connect (cfg);
 455     tc = GNUNET_malloc (sizeof (struct TestContext));
 456     tc->name = GNUNET_strdup (tok);
 457     tc->tst =
 458         GNUNET_NAT_test_start (cfg,
 459                                (0 ==
 460                                 strcasecmp (tok,
 461                                             "udp")) ? GNUNET_NO : GNUNET_YES,
 462                                (uint16_t) bnd_port, (uint16_t) adv_port,
 463                                &result_callback, tc);
 464     if (NULL == tc->tst)
 465     {
 466       display_test_result (tc, GNUNET_SYSERR);
 467       continue;
 468     }
 469     tc->tsk = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &fail_timeout, tc);
 470   }
 471   GNUNET_free (plugins);
 472 }
 473
 474 /**
 475  * Function called to notify a client about the socket
 476  * begin ready to queue more data.  "buf" will be
 477  * NULL and "size" zero if the socket was closed for
 478  * writing in the meantime.
 479  *
 480  * @param cls closure
 481  * @param size number of bytes available in buf
 482  * @param buf where the callee should write the message
 483  * @return number of bytes written to buf
 484  */
 485 static size_t
 486 transmit_data (void *cls, size_t size, void *buf)
 487 {
 488   struct GNUNET_MessageHeader *m = buf;
 489
 490   if ((NULL == buf) && (0 == size))
 491   {
 492     th = NULL;
 493     return 0;
 494   }
 495
 496   GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
 497   GNUNET_assert (size < GNUNET_SERVER_MAX_MESSAGE_SIZE);
 498   m->size = ntohs (size);
 499   m->type = ntohs (GNUNET_MESSAGE_TYPE_DUMMY);
 500   memset (&m[1], 52, size - sizeof (struct GNUNET_MessageHeader));
 501   traffic_sent += size;
 502   th = GNUNET_TRANSPORT_notify_transmit_ready (handle, &pid, BLOCKSIZE * 1024, 0,
 503                                                GNUNET_TIME_UNIT_FOREVER_REL,
 504                                                &transmit_data, NULL);
 505   if (verbosity > 0)
 506     FPRINTF (stdout, _("Transmitting %u bytes to %s\n"), (unsigned int) size,
 507              GNUNET_i2s (&pid));
 508   return size;
 509 }
 510
 511
 512 /**
 513  * Function called to notify transport users that another
 514  * peer connected to us.
 515  *
 516  * @param cls closure
 517  * @param peer the peer that connected
 518  * @param ats performance data
 519  * @param ats_count number of entries in ats (excluding 0-termination)
 520  */
 521 static void
 522 notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
 523                 const struct GNUNET_ATS_Information *ats, uint32_t ats_count)
 524 {
 525   if (0 != memcmp (&pid, peer, sizeof (struct GNUNET_PeerIdentity)))
 526     return;
 527   ret = 0;
 528   if (try_connect)
 529   {
 530       /* all done, terminate instantly */
 531       FPRINTF (stdout, _("Successfully connected to `%s'\n"), GNUNET_h2s_full (&peer->hashPubKey));
 532       ret = 0;
 533
 534       if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
 535       {
 536         GNUNET_SCHEDULER_cancel (op_timeout);
 537         op_timeout = GNUNET_SCHEDULER_NO_TASK;
 538       }
 539
 540       if (GNUNET_SCHEDULER_NO_TASK != end)
 541         GNUNET_SCHEDULER_cancel (end);
 542       end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
 543       return;
 544   }
 545   if (benchmark_send)
 546   {
 547     if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
 548     {
 549       GNUNET_SCHEDULER_cancel (op_timeout);
 550       op_timeout = GNUNET_SCHEDULER_NO_TASK;
 551     }
 552     if (verbosity > 0)
 553       FPRINTF (stdout, _("Successfully connected to `%s', starting to send benchmark data in %u Kb blocks\n"),
 554           GNUNET_i2s (&pid), BLOCKSIZE);
 555     start_time = GNUNET_TIME_absolute_get ();
 556     if (NULL == th)
 557       th = GNUNET_TRANSPORT_notify_transmit_ready (handle, peer,
 558                                                    BLOCKSIZE * 1024, 0,
 559                                                    GNUNET_TIME_UNIT_FOREVER_REL,
 560                                                    &transmit_data, NULL);
 561     else
 562       GNUNET_break (0);
 563     return;
 564   }
 565 }
 566
 567
 568 /**
 569  * Function called to notify transport users that another
 570  * peer disconnected from us.
 571  *
 572  * @param cls closure
 573  * @param peer the peer that disconnected
 574  */
 575 static void
 576 notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 577 {
 578   if (0 != memcmp (&pid, peer, sizeof (struct GNUNET_PeerIdentity)))
 579     return;
 580
 581   if (NULL != th)
 582   {
 583     GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
 584     th = NULL;
 585   }
 586   if (benchmark_send)
 587   {
 588       FPRINTF (stdout, _("Disconnected from peer `%s' while benchmarking\n"), GNUNET_i2s (&pid));
 589       if (GNUNET_SCHEDULER_NO_TASK != end)
 590         GNUNET_SCHEDULER_cancel (end);
 591       return;
 592   }
 593 }
 594
 595 /**
 596  * Function called to notify transport users that another
 597  * peer connected to us.
 598  *
 599  * @param cls closure
 600  * @param peer the peer that connected
 601  * @param ats performance data
 602  * @param ats_count number of entries in ats (excluding 0-termination)
 603  */
 604 static void
 605 monitor_notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
 606                 const struct GNUNET_ATS_Information *ats, uint32_t ats_count)
 607 {
 608   monitor_connect_counter ++;
 609   struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get();
 610   const char *now_str = GNUNET_STRINGS_absolute_time_to_string (now);
 611
 612   FPRINTF (stdout, _("%24s: %-17s %4s   (%u connections in total)\n"),
 613            now_str,
 614            _("Connected to"),
 615            GNUNET_i2s (peer),
 616            monitor_connect_counter);
 617 }
 618
 619
 620 /**
 621  * Function called to notify transport users that another
 622  * peer disconnected from us.
 623  *
 624  * @param cls closure
 625  * @param peer the peer that disconnected
 626  */
 627 static void
 628 monitor_notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 629 {
 630   struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get();
 631   const char *now_str = GNUNET_STRINGS_absolute_time_to_string (now);
 632
 633   GNUNET_assert (monitor_connect_counter > 0);
 634   monitor_connect_counter --;
 635
 636   FPRINTF (stdout, _("%24s: %-17s %4s   (%u connections in total)\n"),
 637            now_str,
 638            _("Disconnected from"),
 639            GNUNET_i2s (peer),
 640            monitor_connect_counter);
 641 }
 642
 643
 644
 645 /**
 646  * Function called by the transport for each received message.
 647  *
 648  * @param cls closure
 649  * @param peer (claimed) identity of the other peer
 650  * @param message the message
 651  */
 652 static void
 653 notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
 654                 const struct GNUNET_MessageHeader *message)
 655 {
 656   if (benchmark_receive)
 657   {
 658     if (GNUNET_MESSAGE_TYPE_DUMMY != ntohs (message->type))
 659       return;
 660     if (verbosity > 0)
 661       FPRINTF (stdout, _("Received %u bytes from %s\n"),
 662                (unsigned int) ntohs (message->size), GNUNET_i2s (peer));
 663
 664     if (traffic_received == 0)
 665       start_time = GNUNET_TIME_absolute_get ();
 666     traffic_received += ntohs (message->size);
 667     return;
 668   }
 669 }
 670
 671
 672 static void resolve_address (const struct GNUNET_HELLO_Address *address,
 673                                                                                                                  int numeric);
 674
 675
 676 static void
 677 process_string (void *cls, const char *address)
 678 {
 679   struct ResolutionContext *rc = cls;
 680   struct GNUNET_HELLO_Address *addrcp = rc->addrcp;
 681
 682   if (address != NULL)
 683   {
 684     FPRINTF (stdout, _("Peer `%s': %s %s\n"), GNUNET_i2s (&addrcp->peer), addrcp->transport_name, address);
 685     rc->printed = GNUNET_YES;
 686   }
 687   else
 688   {
 689     /* done */
 690     GNUNET_assert (address_resolutions > 0);
 691     address_resolutions --;
 692     if (GNUNET_NO == rc->printed)
 693     {
 694         if (numeric == GNUNET_NO)
 695         {
 696                 resolve_address (rc->addrcp, GNUNET_YES ); /* Failed to resolve address, try numeric lookup */
 697         }
 698         else
 699         FPRINTF (stdout, _("Peer `%s': %s <unable to resolve address>\n"), GNUNET_i2s (&addrcp->peer), addrcp->transport_name);
 700     }
 701     GNUNET_free (rc->addrcp);
 702     GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, rc);
 703     GNUNET_free (rc);
 704     if ((0 == address_resolutions) && (iterate_connections))
 705     {
 706         if (GNUNET_SCHEDULER_NO_TASK != end)
 707         {
 708           GNUNET_SCHEDULER_cancel (end);
 709           end = GNUNET_SCHEDULER_NO_TASK;
 710         }
 711         if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
 712         {
 713                 GNUNET_SCHEDULER_cancel (op_timeout);
 714                 op_timeout = GNUNET_SCHEDULER_NO_TASK;
 715         }
 716         ret = 0;
 717         end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
 718     }
 719   }
 720 }
 721
 722 static void resolve_address (const struct GNUNET_HELLO_Address *address,
 723                                                                                                                  int numeric)
 724 {
 725   struct ResolutionContext *rc;
 726
 727   rc = GNUNET_malloc(sizeof (struct ResolutionContext));
 728   GNUNET_assert (NULL != rc);
 729   GNUNET_CONTAINER_DLL_insert (rc_head, rc_tail, rc);
 730   address_resolutions ++;
 731
 732   rc->addrcp = GNUNET_HELLO_address_copy(address);
 733   rc->printed = GNUNET_NO;
 734   /* Resolve address to string */
 735   rc->asc = GNUNET_TRANSPORT_address_to_string (cfg, address, numeric,
 736                                       RESOLUTION_TIMEOUT, &process_string,
 737                                       rc);
 738 }
 739
 740 /**
 741  * Function to call with a binary address
 742  *
 743  * @param cls closure
 744  * @param peer identity of the peer
 745  * @param address binary address (NULL on disconnect)
 746  */
 747 static void
 748 process_address (void *cls, const struct GNUNET_PeerIdentity *peer,
 749                  const struct GNUNET_HELLO_Address *address)
 750 {
 751   if (peer == NULL)
 752   {
 753     /* done */
 754     address_resolution_in_progress = GNUNET_NO;
 755     pic = NULL;
 756     if (GNUNET_SCHEDULER_NO_TASK != end)
 757       GNUNET_SCHEDULER_cancel (end);
 758     end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
 759     return;
 760   }
 761   if (address == NULL)
 762   {
 763     FPRINTF (stdout, _("Peer `%s' disconnected\n"), GNUNET_i2s (peer));
 764     return;
 765   }
 766
 767   if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
 768         GNUNET_SCHEDULER_cancel (op_timeout);
 769   op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT,
 770                                              &operation_timeout, NULL);
 771
 772   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received address for peer `%s': %s\n",
 773                 GNUNET_i2s (peer), address->transport_name);
 774   resolve_address (address, numeric);
 775 }
 776
 777 void try_connect_cb (void *cls,
 778                      const int result)
 779 {
 780   static int retries = 0;
 781   if (GNUNET_OK == result)
 782   {
 783       tc_handle = NULL;
 784       return;
 785   }
 786   retries ++;
 787   if (retries < 10)
 788     tc_handle = GNUNET_TRANSPORT_try_connect (handle, &pid, try_connect_cb, NULL);
 789   else
 790   {
 791     FPRINTF (stderr, "%s", _("Failed to send connect request to transport service\n"));
 792     if (GNUNET_SCHEDULER_NO_TASK != end)
 793       GNUNET_SCHEDULER_cancel (end);
 794     ret = 1;
 795     end = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
 796     return;
 797   }
 798 }
 799
 800
 801 static void
 802 testservice_task (void *cls,
 803                   const struct GNUNET_SCHEDULER_TaskContext *tc)
 804 {
 805   int counter = 0;
 806   ret = 1;
 807
 808   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
 809   {
 810       FPRINTF (stderr, _("Service `%s' is not running\n"), "transport");
 811       return;
 812   }
 813
 814   if ((NULL != cpid) && (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (cpid, &pid.hashPubKey)))
 815   {
 816       FPRINTF (stderr, _("Failed to parse peer identity `%s'\n"), cpid);
 817       return;
 818   }
 819
 820   counter = benchmark_send + benchmark_receive + iterate_connections +
 821             monitor_connections + monitor_connects + try_connect;
 822
 823   if (1 < counter)
 824   {
 825     FPRINTF (stderr, _("Multiple operations given. Please choose only one operation: %s, %s, %s, %s, %s, %s\n"),
 826              "connect", "benchmark send", "benchmark receive", "information", "monitor", "events");
 827     return;
 828   }
 829   if (0 == counter)
 830   {
 831     FPRINTF (stderr, _("No operation given. Please choose one operation: %s, %s, %s, %s, %s, %s\n"),
 832              "connect", "benchmark send", "benchmark receive", "information", "monitor", "events");
 833     return;
 834   }
 835
 836   if (try_connect) /* -C: Connect to peer */
 837   {
 838     if (NULL == cpid)
 839     {
 840       FPRINTF (stderr, _("Option `%s' makes no sense without option `%s'.\n"),
 841                "-C", "-p");
 842       ret = 1;
 843       return;
 844     }
 845     handle = GNUNET_TRANSPORT_connect (cfg, NULL, NULL,
 846                                        &notify_receive,
 847                                        &notify_connect,
 848                                        &notify_disconnect);
 849     if (NULL == handle)
 850     {
 851         FPRINTF (stderr, "%s", _("Failed to connect to transport service\n"));
 852         ret = 1;
 853         return;
 854     }
 855     tc_handle = GNUNET_TRANSPORT_try_connect (handle, &pid, try_connect_cb, NULL);
 856     if (NULL == tc_handle)
 857     {
 858         FPRINTF (stderr, "%s", _("Failed to send request to transport service\n"));
 859         ret = 1;
 860         return;
 861     }
 862     op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT,
 863                                                &operation_timeout, NULL);
 864
 865   }
 866   else if (benchmark_send) /* -s: Benchmark sending */
 867   {
 868     if (NULL == cpid)
 869     {
 870       FPRINTF (stderr, _("Option `%s' makes no sense without option `%s'.\n"),
 871                "-s", "-p");
 872       ret = 1;
 873       return;
 874     }
 875     handle = GNUNET_TRANSPORT_connect (cfg, NULL, NULL,
 876                                        &notify_receive,
 877                                        &notify_connect,
 878                                        &notify_disconnect);
 879     if (NULL == handle)
 880     {
 881         FPRINTF (stderr, "%s", _("Failed to connect to transport service\n"));
 882         ret = 1;
 883         return;
 884     }
 885     tc_handle =  GNUNET_TRANSPORT_try_connect (handle, &pid, try_connect_cb, NULL);
 886     if (NULL == tc_handle)
 887     {
 888         FPRINTF (stderr, "%s", _("Failed to send request to transport service\n"));
 889         ret = 1;
 890         return;
 891     }
 892     start_time = GNUNET_TIME_absolute_get ();
 893     op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT,
 894                                                &operation_timeout, NULL);
 895   }
 896   else if (benchmark_receive) /* -b: Benchmark receiving */
 897   {
 898     handle =
 899         GNUNET_TRANSPORT_connect (cfg, NULL, NULL, &notify_receive,
 900                                   NULL, NULL);
 901     if (NULL == handle)
 902     {
 903         FPRINTF (stderr, "%s", _("Failed to connect to transport service\n"));
 904         ret = 1;
 905         return;
 906     }
 907     if (verbosity > 0)
 908       FPRINTF (stdout, "%s", _("Starting to receive benchmark data\n"));
 909     start_time = GNUNET_TIME_absolute_get ();
 910
 911   }
 912   else if (iterate_connections) /* -i: List all active addresses once */
 913   {
 914     peers = GNUNET_CONTAINER_multihashmap_create (20, GNUNET_NO);
 915     address_resolution_in_progress = GNUNET_YES;
 916     pic = GNUNET_TRANSPORT_peer_get_active_addresses (cfg,
 917                                                 (NULL == cpid) ? NULL : &pid,
 918                                                 GNUNET_YES,
 919                                                 TIMEOUT,
 920                                                 &process_address, (void *) cfg);
 921     op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT,
 922                                                &operation_timeout, NULL);
 923   }
 924   else if (monitor_connections) /* -m: List all active addresses continously */
 925   {
 926     peers = GNUNET_CONTAINER_multihashmap_create (20, GNUNET_NO);
 927     address_resolution_in_progress = GNUNET_YES;
 928     pic = GNUNET_TRANSPORT_peer_get_active_addresses (cfg,
 929                                                 (NULL == cpid) ? NULL : &pid,
 930                                                 GNUNET_NO,
 931                                                 TIMEOUT,
 932                                                 &process_address, (void *) cfg);
 933   }
 934   else if (monitor_connects) /* -e : Monitor (dis)connect events continously */
 935   {
 936     monitor_connect_counter = 0;
 937     handle = GNUNET_TRANSPORT_connect (cfg, NULL, NULL, NULL,
 938                                        &monitor_notify_connect,
 939                                        &monitor_notify_disconnect);
 940     if (NULL == handle)
 941     {
 942       FPRINTF (stderr, "%s", _("Failed to connect to transport service\n"));
 943       ret = 1;
 944       return;
 945     }
 946     ret = 0;
 947   }
 948   else
 949   {
 950     GNUNET_break (0);
 951     return;
 952   }
 953
 954   end = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
 955                                       &shutdown_task,
 956                                       NULL);
 957
 958 }
 959
 960
 961 /**
 962  * Main function that will be run by the scheduler.
 963  *
 964  * @param cls closure
 965  * @param args remaining command-line arguments
 966  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 967  * @param mycfg configuration
 968  */
 969 static void
 970 run (void *cls, char *const *args, const char *cfgfile,
 971      const struct GNUNET_CONFIGURATION_Handle *mycfg)
 972 {
 973         cfg = (struct GNUNET_CONFIGURATION_Handle *) mycfg;
 974         if (test_configuration)
 975   {
 976     do_test_configuration (cfg);
 977     return;
 978   }
 979
 980   GNUNET_CLIENT_service_test ("transport", cfg,
 981       GNUNET_TIME_UNIT_SECONDS,
 982       &testservice_task,
 983       (void *) cfg);
 984 }
 985
 986
 987 int
 988 main (int argc, char *const *argv)
 989 {
 990   int res;
 991   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 992     {'b', "benchmark", NULL,
 993      gettext_noop ("measure how fast we are receiving data from all peers (until CTRL-C)"),
 994      0, &GNUNET_GETOPT_set_one, &benchmark_receive},
 995     {'C', "connect", NULL,
 996      gettext_noop ("connect to a peer"),
 997      0, &GNUNET_GETOPT_set_one, &try_connect},
 998     {'i', "information", NULL,
 999      gettext_noop ("provide information about all current connections (once)"),
1000      0, &GNUNET_GETOPT_set_one, &iterate_connections},
1001     {'m', "monitor", NULL,
1002      gettext_noop ("provide information about all current connections (continuously)"),
1003      0, &GNUNET_GETOPT_set_one, &monitor_connections},
1004     {'e', "events", NULL,
1005      gettext_noop ("provide information about all connects and disconnect events (continuously)"),
1006      0, &GNUNET_GETOPT_set_one, &monitor_connects},
1007     {'n', "numeric", NULL,
1008      gettext_noop ("do not resolve hostnames"),
1009      0, &GNUNET_GETOPT_set_one, &numeric},
1010      {'p', "peer", "PEER",
1011       gettext_noop ("peer identity"),
1012       1, &GNUNET_GETOPT_set_string, &cpid},
1013     {'s', "send", NULL,
1014      gettext_noop
1015      ("send data for benchmarking to the other peer (until CTRL-C)"),
1016      0, &GNUNET_GETOPT_set_one, &benchmark_send},
1017     {'t', "test", NULL,
1018      gettext_noop ("test transport configuration (involves external server)"),
1019      0, &GNUNET_GETOPT_set_one, &test_configuration},
1020     GNUNET_GETOPT_OPTION_VERBOSE (&verbosity),
1021     GNUNET_GETOPT_OPTION_END
1022   };
1023
1024   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
1025     return 2;
1026
1027   res = GNUNET_PROGRAM_run (argc, argv, "gnunet-transport",
1028                               gettext_noop
1029                               ("Direct access to transport service."), options,
1030                               &run, NULL);
1031   GNUNET_free ((void *) argv);
1032   if (GNUNET_OK == res)
1033     return ret;
1034   return 1;
1035 }
1036
1037
1038 /* end of gnunet-transport.c */