src/transport/gnunet-service-transport_clients.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2010,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 transport/gnunet-service-transport_clients.c
  23  * @brief plugin management API
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet-service-transport_clients.h"
  28 #include "gnunet-service-transport_hello.h"
  29 #include "gnunet-service-transport_neighbours.h"
  30 #include "gnunet-service-transport_plugins.h"
  31 #include "gnunet-service-transport_validation.h"
  32 #include "gnunet-service-transport.h"
  33 #include "transport.h"
  34
  35 /**
  36  * How many messages can we have pending for a given client process
  37  * before we start to drop incoming messages?  We typically should
  38  * have only one client and so this would be the primary buffer for
  39   * messages, so the number should be chosen rather generously.
  40  *
  41  * The expectation here is that most of the time the queue is large
  42  * enough so that a drop is virtually never required.  Note that
  43  * this value must be about as large as 'TOTAL_MSGS' in the
  44  * 'test_transport_api_reliability.c', otherwise that testcase may
  45  * fail.
  46  */
  47 #define MAX_PENDING (128 * 1024)
  48
  49
  50 /**
  51  * Linked list of messages to be transmitted to the client.  Each
  52  * entry is followed by the actual message.
  53  */
  54 struct ClientMessageQueueEntry
  55 {
  56   /**
  57    * This is a doubly-linked list.
  58    */
  59   struct ClientMessageQueueEntry *next;
  60
  61   /**
  62    * This is a doubly-linked list.
  63    */
  64   struct ClientMessageQueueEntry *prev;
  65 };
  66
  67
  68 /**
  69  * Client connected to the transport service.
  70  */
  71 struct TransportClient
  72 {
  73
  74   /**
  75    * This is a doubly-linked list.
  76    */
  77   struct TransportClient *next;
  78
  79   /**
  80    * This is a doubly-linked list.
  81    */
  82   struct TransportClient *prev;
  83
  84   /**
  85    * Handle to the client.
  86    */
  87   struct GNUNET_SERVER_Client *client;
  88
  89   /**
  90    * Linked list of messages yet to be transmitted to
  91    * the client.
  92    */
  93   struct ClientMessageQueueEntry *message_queue_head;
  94
  95   /**
  96    * Tail of linked list of messages yet to be transmitted to the
  97    * client.
  98    */
  99   struct ClientMessageQueueEntry *message_queue_tail;
 100
 101   /**
 102    * Current transmit request handle.
 103    */
 104   struct GNUNET_CONNECTION_TransmitHandle *th;
 105
 106   /**
 107    * Length of the list of messages pending for this client.
 108    */
 109   unsigned int message_count;
 110
 111 };
 112
 113
 114 /**
 115  * Head of linked list of all clients to this service.
 116  */
 117 static struct TransportClient *clients_head;
 118
 119 /**
 120  * Tail of linked list of all clients to this service.
 121  */
 122 static struct TransportClient *clients_tail;
 123
 124
 125 /**
 126  * Find the internal handle associated with the given client handle
 127  *
 128  * @param client server's client handle to look up
 129  * @return internal client handle
 130  */
 131 static struct TransportClient *
 132 lookup_client (struct GNUNET_SERVER_Client *client)
 133 {
 134   struct TransportClient *tc;
 135
 136   tc = clients_head;
 137   while (tc != NULL)
 138     {
 139       if (tc->client == client)
 140         return tc;
 141       tc = tc->next;
 142     }
 143   return NULL;
 144 }
 145
 146
 147 /**
 148  * Create the internal handle for the given server client handle
 149  *
 150  * @param client server's client handle to create our internal handle for
 151  * @return fresh internal client handle
 152  */
 153 static struct TransportClient *
 154 setup_client (struct GNUNET_SERVER_Client *client)
 155 {
 156   struct TransportClient *tc;
 157
 158   tc = GNUNET_malloc (sizeof (struct TransportClient));
 159   tc->client = client;
 160   GNUNET_CONTAINER_DLL_insert (clients_head,
 161                                clients_tail,
 162                                tc);
 163   return tc;
 164 }
 165
 166
 167 /**
 168  * Function called to notify a client about the socket being ready to
 169  * queue more data.  "buf" will be NULL and "size" zero if the socket
 170  * was closed for writing in the meantime.
 171  *
 172  * @param cls closure
 173  * @param size number of bytes available in buf
 174  * @param buf where the callee should write the message
 175  * @return number of bytes written to buf
 176  */
 177 static size_t
 178 transmit_to_client_callback (void *cls,
 179                              size_t size,
 180                              void *buf)
 181 {
 182   struct TransportClient *tc = cls;
 183   struct ClientMessageQueueEntry *q;
 184   const struct GNUNET_MessageHeader *msg;
 185   char *cbuf;
 186   uint16_t msize;
 187   size_t tsize;
 188
 189   tc->th = NULL;
 190   if (buf == NULL)
 191     {
 192 #if DEBUG_TRANSPORT
 193       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 194                   "Transmission to client failed, closing connection.\n");
 195 #endif
 196       return 0;
 197     }
 198   cbuf = buf;
 199   tsize = 0;
 200   while (NULL != (q = tc->message_queue_head))
 201     {
 202       msg = (const struct GNUNET_MessageHeader *) &q[1];
 203       msize = ntohs (msg->size);
 204       if (msize + tsize > size)
 205         break;
 206 #if DEBUG_TRANSPORT
 207       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 208                   "Transmitting message of type %u to client.\n",
 209                   ntohs (msg->type));
 210 #endif
 211       GNUNET_CONTAINER_DLL_remove (tc->message_queue_head,
 212                                    tc->message_queue_tail,
 213                                    q);
 214       tc->message_count--;
 215       memcpy (&cbuf[tsize],
 216               msg,
 217               msize);
 218       GNUNET_free (q);
 219       tsize += msize;
 220     }
 221   if (NULL != q)
 222     {
 223       GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
 224       tc->th = GNUNET_SERVER_notify_transmit_ready (tc->client,
 225                                                     msize,
 226                                                     GNUNET_TIME_UNIT_FOREVER_REL,
 227                                                     &transmit_to_client_callback,
 228                                                     tc);
 229       GNUNET_assert (tc->th != NULL);
 230     }
 231   return tsize;
 232 }
 233
 234
 235 /**
 236  * Queue the given message for transmission to the given client
 237  *
 238  * @param client target of the message
 239  * @param msg message to transmit
 240  * @param may_drop GNUNET_YES if the message can be dropped
 241  */
 242 static void
 243 unicast (struct TransportClient *tc,
 244          const struct GNUNET_MessageHeader *msg,
 245          int may_drop)
 246 {
 247   struct ClientMessageQueueEntry *q;
 248   uint16_t msize;
 249
 250   if ( (tc->message_count >= MAX_PENDING) &&
 251        (GNUNET_YES == may_drop) )
 252     {
 253       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 254                   _("Dropping message of type %u and size %u, have %u/%u messages pending\n"),
 255                   ntohs (msg->type),
 256                   ntohs (msg->size),
 257                   tc->message_count,
 258                   MAX_PENDING);
 259       GNUNET_STATISTICS_update (GST_stats,
 260                                 gettext_noop ("# messages dropped due to slow client"),
 261                                 1,
 262                                 GNUNET_NO);
 263       return;
 264     }
 265   msize = ntohs (msg->size);
 266   GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
 267   q = GNUNET_malloc (sizeof (struct ClientMessageQueueEntry) + msize);
 268   memcpy (&q[1], msg, msize);
 269   GNUNET_CONTAINER_DLL_insert_tail (tc->message_queue_head,
 270                                     tc->message_queue_tail,
 271                                     q);
 272   tc->message_count++;
 273   if (tc->th != NULL)
 274     return;
 275   tc->th = GNUNET_SERVER_notify_transmit_ready (tc->client,
 276                                                 msize,
 277                                                 GNUNET_TIME_UNIT_FOREVER_REL,
 278                                                 &transmit_to_client_callback,
 279                                                 tc);
 280   GNUNET_assert (tc->th != NULL);
 281 }
 282
 283
 284 /**
 285  * Called whenever a client is disconnected.  Frees our
 286  * resources associated with that client.
 287  *
 288  * @param cls closure
 289  * @param client identification of the client
 290  */
 291 static void
 292 client_disconnect_notification (void *cls,
 293                                 struct GNUNET_SERVER_Client *client)
 294 {
 295   struct TransportClient *tc;
 296   struct ClientMessageQueueEntry *mqe;
 297
 298   if (client == NULL)
 299     return;
 300   tc = lookup_client (client);
 301   if (tc == NULL)
 302     return;
 303 #if DEBUG_TRANSPORT
 304   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
 305               "Client disconnected, cleaning up.\n");
 306 #endif
 307   while (NULL != (mqe = tc->message_queue_head))
 308     {
 309       GNUNET_CONTAINER_DLL_remove (tc->message_queue_head,
 310                                    tc->message_queue_tail,
 311                                    mqe);
 312       tc->message_count--;
 313       GNUNET_free (mqe);
 314     }
 315   GNUNET_CONTAINER_DLL_remove (clients_head,
 316                                clients_tail,
 317                                tc);
 318   if (tc->th != NULL)
 319     {
 320       GNUNET_CONNECTION_notify_transmit_ready_cancel (tc->th);
 321       tc->th = NULL;
 322     }
 323   GNUNET_break (0 == tc->message_count);
 324   GNUNET_free (tc);
 325 }
 326
 327
 328 /**
 329  * Start handling requests from clients.
 330  *
 331  * @param server server used to accept clients from.
 332  */
 333 void
 334 GST_clients_start (struct GNUNET_SERVER_Handle *server)
 335 {
 336   GNUNET_SERVER_disconnect_notify (server,
 337                                    &client_disconnect_notification, NULL);
 338 }
 339
 340
 341 /**
 342  * Stop processing clients.
 343  */
 344 void
 345 GST_clients_stop ()
 346 {
 347   /* nothing to do */
 348 }
 349
 350
 351 /**
 352  * Function called for each of our connected neighbours.  Notify the
 353  * client about the existing neighbour.
 354  *
 355  * @param cls the 'struct TransportClient' to notify
 356  * @param peer identity of the neighbour
 357  * @param ats performance data
 358  * @param ats_count number of entries in ats (excluding 0-termination)
 359  */
 360 static void
 361 notify_client_about_neighbour (void *cls,
 362                                const struct GNUNET_PeerIdentity *peer,
 363                                const struct GNUNET_TRANSPORT_ATS_Information *ats,
 364                                uint32_t ats_count)
 365 {
 366   struct TransportClient *tc = cls;
 367   struct ConnectInfoMessage *cim;
 368   size_t size;
 369
 370   size  = sizeof (struct ConnectInfoMessage) + ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information);
 371   GNUNET_assert (size < GNUNET_SERVER_MAX_MESSAGE_SIZE);
 372   cim = GNUNET_malloc (size);
 373   cim->header.size = htons (size);
 374   cim->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
 375   cim->ats_count = htonl(ats_count);
 376   cim->id = *peer;
 377   memcpy (&cim->ats,
 378           ats,
 379           ats_count * sizeof (struct GNUNET_TRANSPORT_ATS_Information));
 380   unicast (tc, &cim->header, GNUNET_NO);
 381   GNUNET_free (cim);
 382 }
 383
 384
 385 /**
 386  * Initialize a normal client.  We got a start message from this
 387  * client, add him to the list of clients for broadcasting of inbound
 388  * messages.
 389  *
 390  * @param cls unused
 391  * @param client the client
 392  * @param message the start message that was sent
 393  */
 394 void
 395 GST_clients_handle_start (void *cls,
 396                           struct GNUNET_SERVER_Client *client,
 397                           const struct GNUNET_MessageHeader *message)
 398 {
 399   const struct StartMessage *start;
 400   struct TransportClient *tc;
 401
 402   tc = lookup_client (client);
 403   if (tc != NULL)
 404     {
 405       /* got 'start' twice from the same client, not allowed */
 406       GNUNET_break (0);
 407       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 408       return;
 409     }
 410   start = (const struct StartMessage*) message;
 411   if ( (GNUNET_NO != ntohl (start->do_check)) &&
 412        (0 != memcmp (&start->self,
 413                      &GST_my_identity,
 414                      sizeof (struct GNUNET_PeerIdentity))) )
 415     {
 416       /* client thinks this is a different peer, reject */
 417       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 418                   _("Rejecting control connection from peer `%s', which is not me!\n"),
 419                   GNUNET_i2s (&start->self));
 420       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 421       return;
 422     }
 423   tc = setup_client (client);
 424   unicast (tc, GST_hello_get(), GNUNET_NO);
 425   GST_neighbours_iterate (&notify_client_about_neighbour, tc);
 426   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 427 }
 428
 429
 430 /**
 431  * Client sent us a HELLO.  Process the request.
 432  *
 433  * @param cls unused
 434  * @param client the client
 435  * @param message the HELLO message
 436  */
 437 void
 438 GST_clients_handle_hello (void *cls,
 439                           struct GNUNET_SERVER_Client *client,
 440                           const struct GNUNET_MessageHeader *message)
 441 {
 442   GST_validation_handle_hello (message);
 443   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 444 }
 445
 446
 447 /**
 448  * Client asked for transmission to a peer.  Process the request.
 449  *
 450  * @param cls unused
 451  * @param client the client
 452  * @param message the send message that was sent
 453  */
 454 void
 455 GST_clients_handle_send (void *cls,
 456                          struct GNUNET_SERVER_Client *client,
 457                          const struct GNUNET_MessageHeader *message)
 458 {
 459   /* FIXME */
 460   GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 461 }
 462
 463
 464 /**
 465  * Client asked for a quota change for a particular peer.  Process the request.
 466  *
 467  * @param cls unused
 468  * @param client the client
 469  * @param message the quota changing message
 470  */
 471 void
 472 GST_clients_handle_set_quota (void *cls,
 473                               struct GNUNET_SERVER_Client *client,
 474                               const struct GNUNET_MessageHeader *message)
 475 {
 476   const struct QuotaSetMessage *qsm;
 477
 478   qsm = (const struct QuotaSetMessage *) message;
 479   GNUNET_STATISTICS_update (GST_stats,
 480                             gettext_noop ("# SET QUOTA messages received"),
 481                             1,
 482                             GNUNET_NO);
 483 #if DEBUG_TRANSPORT
 484   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 485               "Received `%s' request (new quota %u) from client for peer `%4s'\n",
 486               "SET_QUOTA",
 487               (unsigned int) ntohl (qsm->quota.value__),
 488               GNUNET_i2s (&qsm->peer));
 489 #endif
 490   GST_neighbours_set_incoming_quota (&qsm->peer,
 491                                      qsm->quota);
 492   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 493 }
 494
 495
 496 /**
 497  * Take the given address and append it to the set of results sent back to
 498  * the client.
 499  *
 500  * @param cls the transmission context used ('struct GNUNET_SERVER_TransmitContext*')
 501  * @param address the resolved name, NULL to indicate the last response
 502  */
 503 static void
 504 transmit_address_to_client (void *cls,
 505                             const char *address)
 506 {
 507   struct GNUNET_SERVER_TransmitContext *tc = cls;
 508
 509   if (NULL == address)
 510     {
 511       GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
 512                                                   GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
 513       GNUNET_SERVER_transmit_context_run (tc,
 514                                           GNUNET_TIME_UNIT_FOREVER_REL);
 515       return;
 516     }
 517   GNUNET_SERVER_transmit_context_append_data (tc,
 518                                               address, strlen (address) + 1,
 519                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
 520 }
 521
 522
 523 /**
 524  * Client asked to resolve an address.  Process the request.
 525  *
 526  * @param cls unused
 527  * @param client the client
 528  * @param message the resolution request
 529  */
 530 void
 531 GST_clients_handle_address_lookup (void *cls,
 532                                    struct GNUNET_SERVER_Client *client,
 533                                    const struct GNUNET_MessageHeader *message)
 534 {
 535   const struct AddressLookupMessage *alum;
 536   struct GNUNET_TRANSPORT_PluginFunctions *papi;
 537   const char *plugin_name;
 538   const char *address;
 539   uint32_t address_len;
 540   uint16_t size;
 541   struct GNUNET_SERVER_TransmitContext *tc;
 542   struct GNUNET_TIME_Relative rtimeout;
 543   int32_t numeric;
 544
 545   size = ntohs (message->size);
 546   if (size < sizeof (struct AddressLookupMessage))
 547     {
 548       GNUNET_break (0);
 549       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 550       return;
 551     }
 552   alum = (const struct AddressLookupMessage *) message;
 553   address_len = ntohl (alum->addrlen);
 554   if (size <= sizeof (struct AddressLookupMessage) + address_len)
 555     {
 556       GNUNET_break (0);
 557       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 558       return;
 559     }
 560   address = (const char *) &alum[1];
 561   plugin_name = (const char *) &address[address_len];
 562   if (plugin_name
 563       [size - sizeof (struct AddressLookupMessage) - address_len - 1] != '\0')
 564     {
 565       GNUNET_break (0);
 566       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 567       return;
 568     }
 569   rtimeout = GNUNET_TIME_relative_ntoh (alum->timeout);
 570   numeric = ntohl (alum->numeric_only);
 571   tc = GNUNET_SERVER_transmit_context_create (client);
 572   papi = GST_plugins_find (plugin_name);
 573   if (NULL == papi)
 574     {
 575       GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
 576                                                   GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
 577       GNUNET_SERVER_transmit_context_run (tc, rtimeout);
 578       return;
 579     }
 580   GNUNET_SERVER_disable_receive_done_warning (client);
 581   papi->address_pretty_printer (papi->cls,
 582                                 plugin_name,
 583                                 address, address_len,
 584                                 numeric,
 585                                 rtimeout,
 586                                 &transmit_address_to_client, tc);
 587 }
 588
 589
 590 /**
 591  * Send an address to the client.
 592  *
 593  * @param cls our 'struct GNUNET_SERVER_TransmitContext' (for sending)
 594  * @param target peer this change is about, never NULL
 595  * @param last_validated_at is FOREVER if the address has not been validated (we're currently checking)
 596  *                          is ZERO if the address was validated a long time ago (from PEERINFO)
 597  *                          is a time in the past if this process validated the address
 598  * @param validation_block  is FOREVER if the address is for an unsupported plugin (from PEERINFO)
 599  *                          is ZERO if the address is considered valid (no validation needed)
 600  *                          is a time in the future if we're currently denying re-validation
 601  * @param plugin_name name of the plugin
 602  * @param plugin_address binary address
 603  * @param plugin_address_len length of address
 604  */
 605 static void
 606 send_address_to_client (void *cls,
 607                         const struct GNUNET_PeerIdentity *target,
 608                         struct GNUNET_TIME_Absolute last_validated_at,
 609                         struct GNUNET_TIME_Absolute validation_block,
 610                         const char *plugin_name,
 611                         const void *plugin_address,
 612                         size_t plugin_address_len)
 613 {
 614   struct GNUNET_SERVER_TransmitContext *tc = cls;
 615   char *addr_buf;
 616
 617   /* FIXME: move to a binary format!!! */
 618   GNUNET_asprintf (&addr_buf, "%s --- %s, %s",
 619                    GST_plugins_a2s (plugin_name,
 620                                     plugin_address,
 621                                     plugin_address_len),
 622                    (GNUNET_YES == GST_neighbours_test_connected (target))
 623                    ? "CONNECTED"
 624                    : "DISCONNECTED",
 625                    (last_validated_at.abs_value < GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
 626                    ? "VALIDATED"
 627                    : "UNVALIDATED");
 628   transmit_address_to_client (tc, addr_buf);
 629   GNUNET_free (addr_buf);
 630 }
 631
 632
 633 /**
 634  * Client asked to obtain information about a peer's addresses.
 635  * Process the request.
 636  * FIXME: use better name!
 637  *
 638  * @param cls unused
 639  * @param client the client
 640  * @param message the peer address information request
 641  */
 642 void
 643 GST_clients_handle_peer_address_lookup (void *cls,
 644                                         struct GNUNET_SERVER_Client *client,
 645                                         const struct GNUNET_MessageHeader *message)
 646 {
 647   const struct PeerAddressLookupMessage *peer_address_lookup;
 648   struct GNUNET_SERVER_TransmitContext *tc;
 649
 650   peer_address_lookup = (const struct PeerAddressLookupMessage *) message;
 651   GNUNET_break (ntohl (peer_address_lookup->reserved) == 0);
 652   tc = GNUNET_SERVER_transmit_context_create (client);
 653   (void) GST_validation_get_addresses (&peer_address_lookup->peer,
 654                                        GNUNET_YES,
 655                                        &send_address_to_client,
 656                                        tc);
 657   GNUNET_SERVER_transmit_context_append_data (tc,
 658                                               NULL, 0,
 659                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
 660   GNUNET_SERVER_transmit_context_run (tc,
 661                                       GNUNET_TIME_UNIT_FOREVER_REL);
 662 }
 663
 664
 665 /**
 666  * Output the active address of connected neighbours to the given client.
 667  *
 668  * @param cls the 'struct GNUNET_SERVER_TransmitContext' for transmission to the client
 669  * @param neighbour identity of the neighbour
 670  * @param ats performance data
 671  * @param ats_count number of entries in ats (excluding 0-termination)
 672  */
 673 static void
 674 output_addresses (void *cls,
 675                   const struct GNUNET_PeerIdentity *neighbour,
 676                   const struct GNUNET_TRANSPORT_ATS_Information *ats,
 677                   uint32_t ats_count)
 678 {
 679   struct GNUNET_SERVER_TransmitContext *tc = cls;
 680   char *addr_buf;
 681
 682   /* FIXME: move to a binary format!!! */
 683   GNUNET_asprintf (&addr_buf,
 684                    "%s: %s",
 685                    GNUNET_i2s(neighbour),
 686                    GST_plugins_a2s ("FIXME", NULL, 0));
 687   transmit_address_to_client (tc, addr_buf);
 688   GNUNET_free (addr_buf);
 689 }
 690
 691
 692 /**
 693  * Client asked to obtain information about all actively used addresses.
 694  * Process the request.  FIXME: use better name!
 695  *
 696  * @param cls unused
 697  * @param client the client
 698  * @param message the peer address information request
 699  */
 700 void
 701 GST_clients_handle_address_iterate (void *cls,
 702                                     struct GNUNET_SERVER_Client *client,
 703                                     const struct GNUNET_MessageHeader *message)
 704 {
 705   struct GNUNET_SERVER_TransmitContext *tc;
 706
 707   GNUNET_SERVER_disable_receive_done_warning (client);
 708   tc = GNUNET_SERVER_transmit_context_create (client);
 709   GST_neighbours_iterate (&output_addresses,
 710                           tc);
 711   GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
 712                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
 713   GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
 714 }
 715
 716
 717 /**
 718  * Broadcast the given message to all of our clients.
 719  *
 720  * @param msg message to broadcast
 721  * @param may_drop GNUNET_YES if the message can be dropped
 722  */
 723 void
 724 GST_clients_broadcast (const struct GNUNET_MessageHeader *msg,
 725                        int may_drop)
 726 {
 727   struct TransportClient *tc;
 728
 729   for (tc = clients_head; tc != NULL; tc = tc->next)
 730     unicast (tc, msg, may_drop);
 731 }
 732
 733
 734 /**
 735  * Send the given message to a particular client
 736  *
 737  * @param client target of the message
 738  * @param msg message to transmit
 739  * @param may_drop GNUNET_YES if the message can be dropped
 740  */
 741 void
 742 GST_clients_unicast (struct GNUNET_SERVER_Client *client,
 743                      const struct GNUNET_MessageHeader *msg,
 744                      int may_drop)
 745 {
 746   struct TransportClient *tc;
 747
 748   tc = lookup_client (client);
 749   if (NULL == tc)
 750     tc = setup_client (client);
 751   unicast (tc, msg, may_drop);
 752 }
 753
 754
 755 /* end of file gnunet-service-transport_clients.c */