src/util/server_nc.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2010 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 2, 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 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_common.h"
  30 #include "gnunet_connection_lib.h"
  31 #include "gnunet_container_lib.h"
  32 #include "gnunet_scheduler_lib.h"
  33 #include "gnunet_server_lib.h"
  34 #include "gnunet_time_lib.h"
  35
  36
  37 #define DEBUG_SERVER_NC GNUNET_NO
  38
  39 /**
  40  * Entry in list of messages pending to be transmitted.
  41  */
  42 struct PendingMessageList
  43 {
  44
  45   /**
  46    * This is a doubly-linked list.
  47    */
  48   struct PendingMessageList *next;
  49
  50   /**
  51    * This is a doubly-linked list.
  52    */
  53   struct PendingMessageList *prev;
  54
  55   /**
  56    * Message to transmit (allocated at the end of this
  57    * struct, do not free)
  58    */
  59   const struct GNUNET_MessageHeader *msg;
  60
  61   /**
  62    * Can this message be dropped?
  63    */
  64   int can_drop;
  65
  66 };
  67
  68
  69 /**
  70  * Lists of clients we manage for notifications.
  71  */
  72 struct ClientList
  73 {
  74
  75   /**
  76    * This is a linked list.
  77    */
  78   struct ClientList *next;
  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_CONNECTION_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    * List of clients receiving notifications.
 131    */
 132   struct ClientList *clients;
 133
 134   /**
 135    * Maximum number of optional messages to queue per client.
 136    */
 137   unsigned int queue_length;
 138
 139 };
 140
 141
 142 /**
 143  * Client has disconnected, clean up.
 144  *
 145  * @param cls our 'struct GNUNET_SERVER_NotificationContext *'
 146  * @param client handle of client that disconnected
 147  */
 148 static void
 149 handle_client_disconnect (void *cls,
 150                           struct GNUNET_SERVER_Client *client)
 151 {
 152   struct GNUNET_SERVER_NotificationContext *nc = cls;
 153   struct ClientList *pos;
 154   struct ClientList *prev;
 155   struct PendingMessageList *pml;
 156
 157   if (client == NULL)
 158     {
 159       nc->server = NULL;
 160       return;
 161     }
 162   prev = NULL;
 163   pos = nc->clients;
 164   while (NULL != pos)
 165     {
 166       if (pos->client == client)
 167         break;
 168       prev = pos;
 169       pos = pos->next;
 170     }
 171   if (pos == NULL)
 172     return;
 173 #if DEBUG_SERVER_NC
 174   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 175               "Client disconnected, cleaning up %u messages in NC queue\n",
 176               pos->num_pending);
 177 #endif
 178   if (prev == NULL)
 179     nc->clients = pos->next;
 180   else
 181     prev->next = pos->next;
 182   while (NULL != (pml = pos->pending_head))
 183     {
 184       GNUNET_CONTAINER_DLL_remove (pos->pending_head,
 185                                    pos->pending_tail,
 186                                    pml);
 187       GNUNET_free (pml);
 188     }
 189   GNUNET_SERVER_client_drop (client);
 190   if (pos->th != NULL)
 191     {
 192       GNUNET_CONNECTION_notify_transmit_ready_cancel (pos->th);
 193       pos->th = NULL;
 194     }
 195   GNUNET_free (pos);
 196 }
 197
 198
 199 /**
 200  * Create a new notification context.
 201  *
 202  * @param server server for which this function creates the context
 203  * @param queue_length maximum number of messages to keep in
 204  *        the notification queue; optional messages are dropped
 205  *        it the queue gets longer than this number of messages
 206  * @return handle to the notification context
 207  */
 208 struct GNUNET_SERVER_NotificationContext *
 209 GNUNET_SERVER_notification_context_create (struct GNUNET_SERVER_Handle *server,
 210                                            unsigned int queue_length)
 211 {
 212   struct GNUNET_SERVER_NotificationContext *ret;
 213
 214   ret = GNUNET_malloc (sizeof (struct GNUNET_SERVER_NotificationContext));
 215   ret->server = server;
 216   ret->queue_length = queue_length;
 217   GNUNET_SERVER_disconnect_notify (server,
 218                                    &handle_client_disconnect,
 219                                    ret);
 220   return ret;
 221 }
 222
 223
 224 /**
 225  * Destroy the context, force disconnect for all clients.
 226  *
 227  * @param nc context to destroy.
 228  */
 229 void
 230 GNUNET_SERVER_notification_context_destroy (struct GNUNET_SERVER_NotificationContext *nc)
 231 {
 232   struct ClientList *pos;
 233   struct PendingMessageList *pml;
 234
 235   while (NULL != (pos = nc->clients))
 236     {
 237       nc->clients = pos->next;
 238       GNUNET_SERVER_client_drop (pos->client);
 239       GNUNET_SERVER_receive_done (pos->client, GNUNET_NO);
 240       while (NULL != (pml = pos->pending_head))
 241         {
 242           GNUNET_CONTAINER_DLL_remove (pos->pending_head,
 243                                        pos->pending_tail,
 244                                        pml);
 245           GNUNET_free (pml);
 246         }
 247       GNUNET_free (pos);
 248     }
 249   if (nc->server != NULL)
 250     GNUNET_SERVER_disconnect_notify_cancel (nc->server,
 251                                             &handle_client_disconnect,
 252                                             nc);
 253   GNUNET_free (nc);
 254 }
 255
 256
 257 /**
 258  * Add a client to the notification context.
 259  *
 260  * @param nc context to modify
 261  * @param client client to add
 262  */
 263 void
 264 GNUNET_SERVER_notification_context_add (struct GNUNET_SERVER_NotificationContext *nc,
 265                                         struct GNUNET_SERVER_Client *client)
 266 {
 267   struct ClientList *cl;
 268
 269   cl = GNUNET_malloc (sizeof (struct ClientList));
 270   cl->next = nc->clients;
 271   cl->nc = nc;
 272   cl->client = client;
 273   GNUNET_SERVER_client_keep (client);
 274   nc->clients = cl;
 275 }
 276
 277
 278 /**
 279  * Function called to notify a client about the socket begin ready to
 280  * queue more data.  "buf" will be NULL and "size" zero if the socket
 281  * was closed for writing in the meantime.
 282  *
 283  * @param cls the 'struct ClientList *'
 284  * @param size number of bytes available in buf
 285  * @param buf where the callee should write the message
 286  * @return number of bytes written to buf
 287  */
 288 static size_t
 289 transmit_message (void *cls,
 290                   size_t size,
 291                   void *buf)
 292 {
 293   struct ClientList *cl = cls;
 294   char *cbuf = buf;
 295   struct PendingMessageList *pml;
 296   uint16_t msize;
 297   size_t ret;
 298
 299   cl->th = NULL;
 300   if (buf == NULL)
 301     {
 302       /* 'cl' should be freed via disconnect notification shortly */
 303 #if DEBUG_SERVER_NC
 304       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 305                   "Failed to transmit message from NC queue to client\n");
 306 #endif
 307       return 0;
 308     }
 309   ret = 0;
 310   while (NULL != (pml = cl->pending_head) )
 311     {
 312       msize = ntohs (pml->msg->size);
 313       if (size < msize)
 314         break;
 315       GNUNET_CONTAINER_DLL_remove (cl->pending_head,
 316                                    cl->pending_tail,
 317                                    pml);
 318 #if DEBUG_SERVER_NC
 319       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 320                   "Copying message of type %u and size %u from pending queue to transmission buffer\n",
 321                   ntohs (pml->msg->type),
 322                   msize);
 323 #endif
 324       memcpy (&cbuf[ret], pml->msg, msize);
 325       ret += msize;
 326       size -= msize;
 327       GNUNET_free (pml);
 328       cl->num_pending--;
 329     }
 330   if (pml != NULL)
 331     {
 332 #if DEBUG_SERVER_NC
 333       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 334                   "Have %u messages left in NC queue, will try transmission again\n",
 335                   cl->num_pending);
 336 #endif
 337       cl->th = GNUNET_SERVER_notify_transmit_ready (cl->client,
 338                                                     ntohs (pml->msg->size),
 339                                                     GNUNET_TIME_UNIT_FOREVER_REL,
 340                                                     &transmit_message,
 341                                                     cl);
 342     }
 343   else
 344     GNUNET_assert (cl->num_pending == 0);
 345   return ret;
 346 }
 347
 348
 349 /**
 350  * Send a message to a particular client.
 351  *
 352  * @param nc context to modify
 353  * @param client client to transmit to
 354  * @param msg message to send
 355  * @param can_drop can this message be dropped due to queue length limitations
 356  */
 357 static void
 358 do_unicast (struct GNUNET_SERVER_NotificationContext *nc,
 359             struct ClientList *client,
 360             const struct GNUNET_MessageHeader *msg,
 361             int can_drop)
 362 {
 363   struct PendingMessageList *pml;
 364   uint16_t size;
 365
 366   if ( (client->num_pending > nc->queue_length) &&
 367        (GNUNET_YES == can_drop) )
 368     {
 369       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
 370                   "Dropping message of type %u and size %u due to full queue (%u entries)\n",
 371                   ntohs (msg->type),
 372                   ntohs (msg->size),
 373                   (unsigned int) nc->queue_length);
 374       return; /* drop! */
 375     }
 376   if (client->num_pending > nc->queue_length)
 377     {
 378       /* FIXME: consider checking for other messages in the
 379          queue that are 'droppable' */
 380     }
 381   client->num_pending++;
 382   size = ntohs (msg->size);
 383   pml = GNUNET_malloc (sizeof (struct PendingMessageList) + size);
 384   pml->msg = (const struct GNUNET_MessageHeader*) &pml[1];
 385   pml->can_drop = can_drop;
 386 #if DEBUG_SERVER_NC
 387   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 388               "Adding message of type %u and size %u to pending queue (which has %u entries)\n",
 389               ntohs (msg->type),
 390               ntohs (msg->size),
 391               (unsigned int) nc->queue_length);
 392 #endif
 393   memcpy (&pml[1], msg, size);
 394   /* append */
 395   GNUNET_CONTAINER_DLL_insert_tail (client->pending_head,
 396                                     client->pending_tail,
 397                                     pml);
 398   if (client->th == NULL)
 399     client->th = GNUNET_SERVER_notify_transmit_ready (client->client,
 400                                                       ntohs (client->pending_head->msg->size),
 401                                                       GNUNET_TIME_UNIT_FOREVER_REL,
 402                                                       &transmit_message,
 403                                                       client);
 404 }
 405
 406
 407 /**
 408  * Send a message to a particular client; must have
 409  * already been added to the notification context.
 410  *
 411  * @param nc context to modify
 412  * @param client client to transmit to
 413  * @param msg message to send
 414  * @param can_drop can this message be dropped due to queue length limitations
 415  */
 416 void
 417 GNUNET_SERVER_notification_context_unicast (struct GNUNET_SERVER_NotificationContext *nc,
 418                                             struct GNUNET_SERVER_Client *client,
 419                                             const struct GNUNET_MessageHeader *msg,
 420                                             int can_drop)
 421 {
 422   struct ClientList *pos;
 423
 424   pos = nc->clients;
 425   while (NULL != pos)
 426     {
 427       if (pos->client == client)
 428         break;
 429       pos = pos->next;
 430     }
 431   GNUNET_assert (pos != NULL);
 432   do_unicast (nc, pos, msg, can_drop);
 433 }
 434
 435
 436 /**
 437  * Send a message to all clients of this context.
 438  *
 439  * @param nc context to modify
 440  * @param msg message to send
 441  * @param can_drop can this message be dropped due to queue length limitations
 442  */
 443 void
 444 GNUNET_SERVER_notification_context_broadcast (struct GNUNET_SERVER_NotificationContext *nc,
 445                                               const struct GNUNET_MessageHeader *msg,
 446                                               int can_drop)
 447 {
 448   struct ClientList *pos;
 449
 450   pos = nc->clients;
 451   while (NULL != pos)
 452     {
 453       do_unicast (nc, pos, msg, can_drop);
 454       pos = pos->next;
 455     }
 456 }
 457
 458
 459 /* end of server_nc.c */