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  * Closure for 'handle_send_transmit_continuation'
 449  */
 450 struct SendTransmitContinuationContext
 451 {
 452   /**
 453    * Client that made the request.
 454    */
 455   struct GNUNET_SERVER_Client *client;
 456
 457   /**
 458    * Peer that was the target.
 459    */
 460   struct GNUNET_PeerIdentity target;
 461 };
 462
 463
 464 /**
 465  * Function called after the transmission is done.  Notify the client that it is
 466  * OK to send the next message.
 467  *
 468  * @param cls closure
 469  * @param success GNUNET_OK on success, GNUNET_NO on failure, GNUNET_SYSERR if we're not connected
 470  */
 471 static void
 472 handle_send_transmit_continuation (void *cls,
 473                                    int success)
 474 {
 475   struct SendTransmitContinuationContext *stcc = cls;
 476   struct SendOkMessage send_ok_msg;
 477
 478   send_ok_msg.header.size = htons (sizeof (send_ok_msg));
 479   send_ok_msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
 480   send_ok_msg.success = htonl (success);
 481   send_ok_msg.latency = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_FOREVER_REL);
 482   send_ok_msg.peer = stcc->target;
 483   GST_clients_unicast (stcc->client, &send_ok_msg.header, GNUNET_NO);
 484   GNUNET_SERVER_client_drop (stcc->client);
 485   GNUNET_free (stcc);
 486 }
 487
 488
 489 /**
 490  * Client asked for transmission to a peer.  Process the request.
 491  *
 492  * @param cls unused
 493  * @param client the client
 494  * @param message the send message that was sent
 495  */
 496 void
 497 GST_clients_handle_send (void *cls,
 498                          struct GNUNET_SERVER_Client *client,
 499                          const struct GNUNET_MessageHeader *message)
 500 {
 501   const struct OutboundMessage *obm;
 502   const struct GNUNET_MessageHeader *obmm;
 503   struct SendTransmitContinuationContext *stcc;
 504   uint16_t size;
 505   uint16_t msize;
 506
 507   size = ntohs (message->size);
 508   if (size < sizeof (struct OutboundMessage) + sizeof (struct GNUNET_MessageHeader))
 509     {
 510       GNUNET_break (0);
 511       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 512       return;
 513     }
 514   obm = (const struct OutboundMessage *) message;
 515   obmm = (const struct GNUNET_MessageHeader *) &obm[1];
 516   msize = size - sizeof (struct OutboundMessage);
 517   if (msize < sizeof (struct GNUNET_MessageHeader))
 518     {
 519       GNUNET_break (0);
 520       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 521       return;
 522     }
 523   GNUNET_STATISTICS_update (GST_stats,
 524                             gettext_noop ("# bytes payload received for other peers"),
 525                             msize,
 526                             GNUNET_NO);
 527 #if DEBUG_TRANSPORT
 528   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 529               "Received `%s' request from client with target `%4s' and first message of type %u and total size %u\n",
 530               "SEND",
 531               GNUNET_i2s (&obm->peer),
 532               ntohs (obmm->type),
 533               msize);
 534 #endif
 535   if (GNUNET_NO ==
 536       GST_neighbours_test_connected (&obm->peer))
 537     {
 538       /* not connected, not allowed to send; can happen due to asynchronous operations */
 539       GNUNET_STATISTICS_update (GST_stats,
 540                                 gettext_noop ("# bytes payload dropped (other peer was not connected)"),
 541                                 msize,
 542                                 GNUNET_NO);
 543       GNUNET_SERVER_receive_done (client, GNUNET_OK);
 544       return;
 545     }
 546   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 547   stcc = GNUNET_malloc (sizeof (struct SendTransmitContinuationContext));
 548   stcc->target = obm->peer;
 549   stcc->client = client;
 550   GNUNET_SERVER_client_keep (client);
 551   GST_neighbours_send (&obm->peer,
 552                        obmm, msize,
 553                        GNUNET_TIME_relative_ntoh (obm->timeout),
 554                        &handle_send_transmit_continuation,
 555                        stcc);
 556 }
 557
 558
 559 /**
 560  * Client asked for a quota change for a particular peer.  Process the request.
 561  *
 562  * @param cls unused
 563  * @param client the client
 564  * @param message the quota changing message
 565  */
 566 void
 567 GST_clients_handle_set_quota (void *cls,
 568                               struct GNUNET_SERVER_Client *client,
 569                               const struct GNUNET_MessageHeader *message)
 570 {
 571   const struct QuotaSetMessage *qsm;
 572
 573   qsm = (const struct QuotaSetMessage *) message;
 574   GNUNET_STATISTICS_update (GST_stats,
 575                             gettext_noop ("# SET QUOTA messages received"),
 576                             1,
 577                             GNUNET_NO);
 578 #if DEBUG_TRANSPORT
 579   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 580               "Received `%s' request (new quota %u) from client for peer `%4s'\n",
 581               "SET_QUOTA",
 582               (unsigned int) ntohl (qsm->quota.value__),
 583               GNUNET_i2s (&qsm->peer));
 584 #endif
 585   GST_neighbours_set_incoming_quota (&qsm->peer,
 586                                      qsm->quota);
 587   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 588 }
 589
 590
 591 /**
 592  * Take the given address and append it to the set of results sent back to
 593  * the client.
 594  *
 595  * @param cls the transmission context used ('struct GNUNET_SERVER_TransmitContext*')
 596  * @param address the resolved name, NULL to indicate the last response
 597  */
 598 static void
 599 transmit_address_to_client (void *cls,
 600                             const char *address)
 601 {
 602   struct GNUNET_SERVER_TransmitContext *tc = cls;
 603
 604   if (NULL == address)
 605     {
 606       GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
 607                                                   GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
 608       GNUNET_SERVER_transmit_context_run (tc,
 609                                           GNUNET_TIME_UNIT_FOREVER_REL);
 610       return;
 611     }
 612   GNUNET_SERVER_transmit_context_append_data (tc,
 613                                               address, strlen (address) + 1,
 614                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
 615 }
 616
 617
 618 /**
 619  * Client asked to resolve an address.  Process the request.
 620  *
 621  * @param cls unused
 622  * @param client the client
 623  * @param message the resolution request
 624  */
 625 void
 626 GST_clients_handle_address_lookup (void *cls,
 627                                    struct GNUNET_SERVER_Client *client,
 628                                    const struct GNUNET_MessageHeader *message)
 629 {
 630   const struct AddressLookupMessage *alum;
 631   struct GNUNET_TRANSPORT_PluginFunctions *papi;
 632   const char *plugin_name;
 633   const char *address;
 634   uint32_t address_len;
 635   uint16_t size;
 636   struct GNUNET_SERVER_TransmitContext *tc;
 637   struct GNUNET_TIME_Relative rtimeout;
 638   int32_t numeric;
 639
 640   size = ntohs (message->size);
 641   if (size < sizeof (struct AddressLookupMessage))
 642     {
 643       GNUNET_break (0);
 644       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 645       return;
 646     }
 647   alum = (const struct AddressLookupMessage *) message;
 648   address_len = ntohl (alum->addrlen);
 649   if (size <= sizeof (struct AddressLookupMessage) + address_len)
 650     {
 651       GNUNET_break (0);
 652       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 653       return;
 654     }
 655   address = (const char *) &alum[1];
 656   plugin_name = (const char *) &address[address_len];
 657   if (plugin_name
 658       [size - sizeof (struct AddressLookupMessage) - address_len - 1] != '\0')
 659     {
 660       GNUNET_break (0);
 661       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
 662       return;
 663     }
 664   rtimeout = GNUNET_TIME_relative_ntoh (alum->timeout);
 665   numeric = ntohl (alum->numeric_only);
 666   tc = GNUNET_SERVER_transmit_context_create (client);
 667   papi = GST_plugins_find (plugin_name);
 668   if (NULL == papi)
 669     {
 670       GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
 671                                                   GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
 672       GNUNET_SERVER_transmit_context_run (tc, rtimeout);
 673       return;
 674     }
 675   GNUNET_SERVER_disable_receive_done_warning (client);
 676   papi->address_pretty_printer (papi->cls,
 677                                 plugin_name,
 678                                 address, address_len,
 679                                 numeric,
 680                                 rtimeout,
 681                                 &transmit_address_to_client, tc);
 682 }
 683
 684
 685 /**
 686  * Send an address to the client.
 687  *
 688  * @param cls our 'struct GNUNET_SERVER_TransmitContext' (for sending)
 689  * @param public_key public key for the peer, never NULL
 690  * @param target peer this change is about, never NULL
 691  * @param valid_until until what time do we consider the address valid?
 692  * @param validation_block  is FOREVER if the address is for an unsupported plugin (from PEERINFO)
 693  *                          is ZERO if the address is considered valid (no validation needed)
 694  *                          is a time in the future if we're currently denying re-validation
 695  * @param plugin_name name of the plugin
 696  * @param plugin_address binary address
 697  * @param plugin_address_len length of address
 698  */
 699 static void
 700 send_address_to_client (void *cls,
 701                         const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key,
 702                         const struct GNUNET_PeerIdentity *target,
 703                         struct GNUNET_TIME_Absolute valid_until,
 704                         struct GNUNET_TIME_Absolute validation_block,
 705                         const char *plugin_name,
 706                         const void *plugin_address,
 707                         size_t plugin_address_len)
 708 {
 709   struct GNUNET_SERVER_TransmitContext *tc = cls;
 710   char *addr_buf;
 711
 712   /* FIXME: move to a binary format!!! */
 713   GNUNET_asprintf (&addr_buf, "%s --- %s, %s",
 714                    GST_plugins_a2s (plugin_name,
 715                                     plugin_address,
 716                                     plugin_address_len),
 717                    (GNUNET_YES == GST_neighbours_test_connected (target))
 718                    ? "CONNECTED"
 719                    : "DISCONNECTED",
 720                    (GNUNET_TIME_absolute_get_remaining (valid_until).rel_value > 0)
 721                    ? "VALIDATED"
 722                    : "UNVALIDATED");
 723   transmit_address_to_client (tc, addr_buf);
 724   GNUNET_free (addr_buf);
 725 }
 726
 727
 728 /**
 729  * Client asked to obtain information about a peer's addresses.
 730  * Process the request.
 731  * FIXME: use better name!
 732  *
 733  * @param cls unused
 734  * @param client the client
 735  * @param message the peer address information request
 736  */
 737 void
 738 GST_clients_handle_peer_address_lookup (void *cls,
 739                                         struct GNUNET_SERVER_Client *client,
 740                                         const struct GNUNET_MessageHeader *message)
 741 {
 742   const struct PeerAddressLookupMessage *peer_address_lookup;
 743   struct GNUNET_SERVER_TransmitContext *tc;
 744
 745   peer_address_lookup = (const struct PeerAddressLookupMessage *) message;
 746   GNUNET_break (ntohl (peer_address_lookup->reserved) == 0);
 747   tc = GNUNET_SERVER_transmit_context_create (client);
 748   GST_validation_get_addresses (&peer_address_lookup->peer,
 749                                 &send_address_to_client,
 750                                 tc);
 751   GNUNET_SERVER_transmit_context_append_data (tc,
 752                                               NULL, 0,
 753                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
 754   GNUNET_SERVER_transmit_context_run (tc,
 755                                       GNUNET_TIME_UNIT_FOREVER_REL);
 756 }
 757
 758
 759 /**
 760  * Output the active address of connected neighbours to the given client.
 761  *
 762  * @param cls the 'struct GNUNET_SERVER_TransmitContext' for transmission to the client
 763  * @param neighbour identity of the neighbour
 764  * @param ats performance data
 765  * @param ats_count number of entries in ats (excluding 0-termination)
 766  */
 767 static void
 768 output_addresses (void *cls,
 769                   const struct GNUNET_PeerIdentity *neighbour,
 770                   const struct GNUNET_TRANSPORT_ATS_Information *ats,
 771                   uint32_t ats_count)
 772 {
 773   struct GNUNET_SERVER_TransmitContext *tc = cls;
 774   char *addr_buf;
 775
 776   /* FIXME: move to a binary format!!! */
 777   GNUNET_asprintf (&addr_buf,
 778                    "%s: %s",
 779                    GNUNET_i2s(neighbour),
 780                    GST_plugins_a2s ("FIXME", NULL, 0));
 781   transmit_address_to_client (tc, addr_buf);
 782   GNUNET_free (addr_buf);
 783 }
 784
 785
 786 /**
 787  * Client asked to obtain information about all actively used addresses.
 788  * Process the request.  FIXME: use better name!
 789  *
 790  * @param cls unused
 791  * @param client the client
 792  * @param message the peer address information request
 793  */
 794 void
 795 GST_clients_handle_address_iterate (void *cls,
 796                                     struct GNUNET_SERVER_Client *client,
 797                                     const struct GNUNET_MessageHeader *message)
 798 {
 799   struct GNUNET_SERVER_TransmitContext *tc;
 800
 801   GNUNET_SERVER_disable_receive_done_warning (client);
 802   tc = GNUNET_SERVER_transmit_context_create (client);
 803   GST_neighbours_iterate (&output_addresses,
 804                           tc);
 805   GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
 806                                               GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_REPLY);
 807   GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
 808 }
 809
 810
 811 /**
 812  * Broadcast the given message to all of our clients.
 813  *
 814  * @param msg message to broadcast
 815  * @param may_drop GNUNET_YES if the message can be dropped
 816  */
 817 void
 818 GST_clients_broadcast (const struct GNUNET_MessageHeader *msg,
 819                        int may_drop)
 820 {
 821   struct TransportClient *tc;
 822
 823   for (tc = clients_head; tc != NULL; tc = tc->next)
 824     unicast (tc, msg, may_drop);
 825 }
 826
 827
 828 /**
 829  * Send the given message to a particular client
 830  *
 831  * @param client target of the message
 832  * @param msg message to transmit
 833  * @param may_drop GNUNET_YES if the message can be dropped
 834  */
 835 void
 836 GST_clients_unicast (struct GNUNET_SERVER_Client *client,
 837                      const struct GNUNET_MessageHeader *msg,
 838                      int may_drop)
 839 {
 840   struct TransportClient *tc;
 841
 842   tc = lookup_client (client);
 843   if (NULL == tc)
 844     tc = setup_client (client);
 845   unicast (tc, msg, may_drop);
 846 }
 847
 848
 849 /* end of file gnunet-service-transport_clients.c */