src/util/server_nc.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2010 GNUnet e.V.
   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., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20
  21 /**
  22  * @file util/server_nc.c
  23  * @brief convenience functions for transmission of
  24  *        a notification stream
  25  * @author Christian Grothoff
  26  */
  27
  28 #include "platform.h"
  29 #include "gnunet_util_lib.h"
  30
  31 #define LOG(kind,...) GNUNET_log_from (kind, "util-server-nc", __VA_ARGS__)
  32
  33
  34 /**
  35  * Entry in list of messages pending to be transmitted.
  36  */
  37 struct PendingMessageList
  38 {
  39
  40   /**
  41    * This is a doubly-linked list.
  42    */
  43   struct PendingMessageList *next;
  44
  45   /**
  46    * This is a doubly-linked list.
  47    */
  48   struct PendingMessageList *prev;
  49
  50   /**
  51    * Message to transmit (allocated at the end of this
  52    * struct, do not free)
  53    */
  54   const struct GNUNET_MessageHeader *msg;
  55
  56   /**
  57    * Can this message be dropped?
  58    */
  59   int can_drop;
  60
  61 };
  62
  63
  64 /**
  65  * Lists of clients we manage for notifications.
  66  */
  67 struct ClientList
  68 {
  69
  70   /**
  71    * This is a doubly linked list.
  72    */
  73   struct ClientList *next;
  74
  75   /**
  76    * This is a doubly linked list.
  77    */
  78   struct ClientList *prev;
  79
  80   /**
  81    * Overall context this client belongs to.
  82    */
  83   struct GNUNET_SERVER_NotificationContext *nc;
  84
  85   /**
  86    * Handle to the client.
  87    */
  88   struct GNUNET_SERVER_Client *client;
  89
  90   /**
  91    * Handle for pending transmission request to the client (or NULL).
  92    */
  93   struct GNUNET_SERVER_TransmitHandle *th;
  94
  95   /**
  96    * Head of linked list of requests queued for transmission.
  97    */
  98   struct PendingMessageList *pending_head;
  99
 100   /**
 101    * Tail of linked list of requests queued for transmission.
 102    */
 103   struct PendingMessageList *pending_tail;
 104
 105   /**
 106    * Number of messages currently in the list.
 107    */
 108   unsigned int num_pending;
 109
 110 };
 111
 112
 113 /**
 114  * The notification context is the key datastructure for a convenience
 115  * API used for transmission of notifications to the client until the
 116  * client disconnects (or the notification context is destroyed, in
 117  * which case we disconnect these clients).  Essentially, all
 118  * (notification) messages are queued up until the client is able to
 119  * read them.
 120  */
 121 struct GNUNET_SERVER_NotificationContext
 122 {
 123
 124   /**
 125    * Server we do notifications for.
 126    */
 127   struct GNUNET_SERVER_Handle *server;
 128
 129   /**
 130    * Head of list of clients receiving notifications.
 131    */
 132   struct ClientList *clients_head;
 133
 134   /**
 135    * Tail of list of clients receiving notifications.
 136    */
 137   struct ClientList *clients_tail;
 138
 139   /**
 140    * Maximum number of optional messages to queue per client.
 141    */
 142   unsigned int queue_length;
 143
 144 };
 145
 146
 147 /**
 148  * Client has disconnected, clean up.
 149  *
 150  * @param cls our `struct GNUNET_SERVER_NotificationContext *`
 151  * @param client handle of client that disconnected
 152  */
 153 static void
 154 handle_client_disconnect (void *cls,
 155                           struct GNUNET_SERVER_Client *client)
 156 {
 157   struct GNUNET_SERVER_NotificationContext *nc = cls;
 158   struct ClientList *pos;
 159   struct PendingMessageList *pml;
 160
 161   if (NULL == client)
 162   {
 163     nc->server = NULL;
 164     return;
 165   }
 166   for (pos = nc->clients_head; NULL != pos; pos = pos->next)
 167     if (pos->client == client)
 168       break;
 169   if (NULL == pos)
 170     return;
 171   LOG (GNUNET_ERROR_TYPE_DEBUG,
 172        "Client disconnected, cleaning up %u messages in NC queue\n",
 173        pos->num_pending);
 174   GNUNET_CONTAINER_DLL_remove (nc->clients_head,
 175                                nc->clients_tail,
 176                                pos);
 177   while (NULL != (pml = pos->pending_head))
 178   {
 179     GNUNET_CONTAINER_DLL_remove (pos->pending_head,
 180                                  pos->pending_tail,
 181                                  pml);
 182     GNUNET_free (pml);
 183     pos->num_pending--;
 184   }
 185   if (NULL != pos->th)
 186   {
 187     GNUNET_SERVER_notify_transmit_ready_cancel (pos->th);
 188     pos->th = NULL;
 189   }
 190   GNUNET_SERVER_client_drop (client);
 191   GNUNET_assert (0 == pos->num_pending);
 192   GNUNET_free (pos);
 193 }
 194
 195
 196 /**
 197  * Create a new notification context.
 198  *
 199  * @param server server for which this function creates the context
 200  * @param queue_length maximum number of messages to keep in
 201  *        the notification queue; optional messages are dropped
 202  *        if the queue gets longer than this number of messages
 203  * @return handle to the notification context
 204  */
 205 struct GNUNET_SERVER_NotificationContext *
 206 GNUNET_SERVER_notification_context_create (struct GNUNET_SERVER_Handle *server,
 207                                            unsigned int queue_length)
 208 {
 209   struct GNUNET_SERVER_NotificationContext *ret;
 210
 211   ret = GNUNET_new (struct GNUNET_SERVER_NotificationContext);
 212   ret->server = server;
 213   ret->queue_length = queue_length;
 214   GNUNET_SERVER_disconnect_notify (server,
 215                                    &handle_client_disconnect,
 216                                    ret);
 217   return ret;
 218 }
 219
 220
 221 /**
 222  * Destroy the context, force disconnect for all clients.
 223  *
 224  * @param nc context to destroy.
 225  */
 226 void
 227 GNUNET_SERVER_notification_context_destroy (struct GNUNET_SERVER_NotificationContext *nc)
 228 {
 229   struct ClientList *pos;
 230   struct PendingMessageList *pml;
 231
 232   while (NULL != (pos = nc->clients_head))
 233   {
 234     GNUNET_CONTAINER_DLL_remove (nc->clients_head,
 235                                  nc->clients_tail,
 236                                  pos);
 237     if (NULL != pos->th)
 238     {
 239       GNUNET_SERVER_notify_transmit_ready_cancel (pos->th);
 240       pos->th = NULL;
 241     }
 242     GNUNET_SERVER_client_drop (pos->client);
 243     while (NULL != (pml = pos->pending_head))
 244     {
 245       GNUNET_CONTAINER_DLL_remove (pos->pending_head,
 246                                    pos->pending_tail,
 247                                    pml);
 248       GNUNET_free (pml);
 249       pos->num_pending--;
 250     }
 251     GNUNET_assert (0 == pos->num_pending);
 252     GNUNET_free (pos);
 253   }
 254   if (NULL != nc->server)
 255     GNUNET_SERVER_disconnect_notify_cancel (nc->server,
 256                                             &handle_client_disconnect,
 257                                             nc);
 258   GNUNET_free (nc);
 259 }
 260
 261
 262 /**
 263  * Add a client to the notification context.
 264  *
 265  * @param nc context to modify
 266  * @param client client to add
 267  */
 268 void
 269 GNUNET_SERVER_notification_context_add (struct GNUNET_SERVER_NotificationContext *nc,
 270                                         struct GNUNET_SERVER_Client *client)
 271 {
 272   struct ClientList *cl;
 273
 274   for (cl = nc->clients_head; NULL != cl; cl = cl->next)
 275     if (cl->client == client)
 276       return; /* already present */
 277   cl = GNUNET_new (struct ClientList);
 278   GNUNET_CONTAINER_DLL_insert (nc->clients_head,
 279                                nc->clients_tail,
 280                                cl);
 281   cl->nc = nc;
 282   cl->client = client;
 283   GNUNET_SERVER_client_keep (client);
 284 }
 285
 286
 287 /**
 288  * Function called to notify a client about the socket begin ready to
 289  * queue more data.  @a buf will be NULL and @a size zero if the socket
 290  * was closed for writing in the meantime.
 291  *
 292  * @param cls the `struct ClientList *`
 293  * @param size number of bytes available in @a buf
 294  * @param buf where the callee should write the message
 295  * @return number of bytes written to buf
 296  */
 297 static size_t
 298 transmit_message (void *cls,
 299                   size_t size,
 300                   void *buf)
 301 {
 302   struct ClientList *cl = cls;
 303   char *cbuf = buf;
 304   struct PendingMessageList *pml;
 305   uint16_t msize;
 306   size_t ret;
 307
 308   cl->th = NULL;
 309   if (NULL == buf)
 310   {
 311     /* 'cl' should be freed via disconnect notification shortly */
 312     LOG (GNUNET_ERROR_TYPE_DEBUG,
 313          "Failed to transmit message from NC queue to client\n");
 314     return 0;
 315   }
 316   ret = 0;
 317   while (NULL != (pml = cl->pending_head))
 318   {
 319     msize = ntohs (pml->msg->size);
 320     if (size < msize)
 321       break;
 322     GNUNET_CONTAINER_DLL_remove (cl->pending_head,
 323                                  cl->pending_tail,
 324                                  pml);
 325     LOG (GNUNET_ERROR_TYPE_DEBUG,
 326          "Copying message of type %u and size %u from pending queue to transmission buffer\n",
 327          ntohs (pml->msg->type),
 328          msize);
 329     memcpy (&cbuf[ret], pml->msg, msize);
 330     ret += msize;
 331     size -= msize;
 332     GNUNET_free (pml);
 333     cl->num_pending--;
 334   }
 335   if (NULL != pml)
 336   {
 337     LOG (GNUNET_ERROR_TYPE_DEBUG,
 338          "Have %u messages left in NC queue, will try transmission again\n",
 339          cl->num_pending);
 340     cl->th =
 341         GNUNET_SERVER_notify_transmit_ready (cl->client,
 342                                              ntohs (pml->msg->size),
 343                                              GNUNET_TIME_UNIT_FOREVER_REL,
 344                                              &transmit_message, cl);
 345   }
 346   else
 347   {
 348     GNUNET_assert (0 == cl->num_pending);
 349   }
 350   return ret;
 351 }
 352
 353
 354 /**
 355  * Send a message to a particular client.
 356  *
 357  * @param nc context to modify
 358  * @param client client to transmit to
 359  * @param msg message to send
 360  * @param can_drop can this message be dropped due to queue length limitations
 361  */
 362 static void
 363 do_unicast (struct GNUNET_SERVER_NotificationContext *nc,
 364             struct ClientList *client,
 365             const struct GNUNET_MessageHeader *msg,
 366             int can_drop)
 367 {
 368   struct PendingMessageList *pml;
 369   uint16_t size;
 370
 371   if ( (client->num_pending > nc->queue_length) &&
 372        (GNUNET_YES == can_drop) )
 373   {
 374     LOG (GNUNET_ERROR_TYPE_INFO,
 375          "Dropping message of type %u and size %u due to full queue (%u entries)\n",
 376          ntohs (msg->type), ntohs (msg->size), (unsigned int) nc->queue_length);
 377     return;                     /* drop! */
 378   }
 379   if (client->num_pending > nc->queue_length)
 380   {
 381     /* FIXME: consider checking for other messages in the
 382      * queue that are 'droppable' */
 383   }
 384   client->num_pending++;
 385   size = ntohs (msg->size);
 386   pml = GNUNET_malloc (sizeof (struct PendingMessageList) + size);
 387   pml->msg = (const struct GNUNET_MessageHeader *) &pml[1];
 388   pml->can_drop = can_drop;
 389   LOG (GNUNET_ERROR_TYPE_DEBUG,
 390        "Adding message of type %u and size %u to pending queue (which has %u entries)\n",
 391        ntohs (msg->type),
 392        ntohs (msg->size),
 393        (unsigned int) nc->queue_length);
 394   memcpy (&pml[1], msg, size);
 395   /* append */
 396   GNUNET_CONTAINER_DLL_insert_tail (client->pending_head,
 397                                     client->pending_tail,
 398                                     pml);
 399   if (NULL == client->th)
 400     client->th =
 401         GNUNET_SERVER_notify_transmit_ready (client->client,
 402                                              ntohs (client->pending_head->
 403                                                     msg->size),
 404                                              GNUNET_TIME_UNIT_FOREVER_REL,
 405                                              &transmit_message, client);
 406 }
 407
 408
 409 /**
 410  * Send a message to a particular client; must have
 411  * already been added to the notification context.
 412  *
 413  * @param nc context to modify
 414  * @param client client to transmit to
 415  * @param msg message to send
 416  * @param can_drop can this message be dropped due to queue length limitations
 417  */
 418 void
 419 GNUNET_SERVER_notification_context_unicast (struct GNUNET_SERVER_NotificationContext *nc,
 420                                             struct GNUNET_SERVER_Client *client,
 421                                             const struct GNUNET_MessageHeader *msg,
 422                                             int can_drop)
 423 {
 424   struct ClientList *pos;
 425
 426   for (pos = nc->clients_head; NULL != pos; pos = pos->next)
 427     if (pos->client == client)
 428       break;
 429   GNUNET_assert (NULL != pos);
 430   do_unicast (nc, pos, msg, can_drop);
 431 }
 432
 433
 434 /**
 435  * Send a message to all clients of this context.
 436  *
 437  * @param nc context to modify
 438  * @param msg message to send
 439  * @param can_drop can this message be dropped due to queue length limitations
 440  */
 441 void
 442 GNUNET_SERVER_notification_context_broadcast (struct
 443                                               GNUNET_SERVER_NotificationContext *nc,
 444                                               const struct GNUNET_MessageHeader *msg,
 445                                               int can_drop)
 446 {
 447   struct ClientList *pos;
 448
 449   for (pos = nc->clients_head; NULL != pos; pos = pos->next)
 450     do_unicast (nc, pos, msg, can_drop);
 451 }
 452
 453
 454 /**
 455  * Return active number of subscribers in this context.
 456  *
 457  * @param nc context to query
 458  * @return number of current subscribers
 459  */
 460 unsigned int
 461 GNUNET_SERVER_notification_context_get_size (struct GNUNET_SERVER_NotificationContext *nc)
 462 {
 463   unsigned int num;
 464   struct ClientList *pos;
 465
 466   num = 0;
 467   for (pos = nc->clients_head; NULL != pos; pos = pos->next)
 468     num++;
 469   return num;
 470 }
 471
 472 /* end of server_nc.c */