src/util/nc.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2010, 2016 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14 */
  15
  16 /**
  17  * @file util/nc.c
  18  * @brief convenience functions for transmission of
  19  *        messages to multiple clients
  20  * @author Christian Grothoff
  21  */
  22
  23 #include "platform.h"
  24 #include "gnunet_util_lib.h"
  25
  26 #define LOG(kind,...) GNUNET_log_from (kind, "util-nc", __VA_ARGS__)
  27
  28
  29 /**
  30  * Lists of subscribers we manage for notifications.
  31  */
  32 struct SubscriberList
  33 {
  34
  35   /**
  36    * This is a doubly linked list.
  37    */
  38   struct SubscriberList *next;
  39
  40   /**
  41    * This is a doubly linked list.
  42    */
  43   struct SubscriberList *prev;
  44
  45   /**
  46    * Overall context this subscriber belongs to.
  47    */
  48   struct GNUNET_NotificationContext *nc;
  49
  50   /**
  51    * Handle where we registered with @e mq to be told about
  52    * the MQ's destruction.
  53    */
  54   struct GNUNET_MQ_DestroyNotificationHandle *mq_nh;
  55
  56   /**
  57    * Message queue for the subscriber.
  58    */
  59   struct GNUNET_MQ_Handle *mq;
  60
  61 };
  62
  63
  64 /**
  65  * The notification context is the key datastructure for a convenience
  66  * API used for transmission of notifications to the subscriber until the
  67  * subscriber disconnects (or the notification context is destroyed, in
  68  * which case we disconnect these subscribers).  Essentially, all
  69  * (notification) messages are queued up until the subscriber is able to
  70  * read them.
  71  */
  72 struct GNUNET_NotificationContext
  73 {
  74
  75   /**
  76    * Head of list of subscribers receiving notifications.
  77    */
  78   struct SubscriberList *subscribers_head;
  79
  80   /**
  81    * Tail of list of subscribers receiving notifications.
  82    */
  83   struct SubscriberList *subscribers_tail;
  84
  85   /**
  86    * Maximum number of optional messages to queue per subscriber.
  87    */
  88   unsigned int queue_length;
  89
  90 };
  91
  92
  93 /**
  94  * Subscriber has disconnected, clean up.
  95  *
  96  * @param cls our `struct SubscriberList *`
  97  */
  98 static void
  99 handle_mq_destroy (void *cls)
 100 {
 101   struct SubscriberList *pos = cls;
 102   struct GNUNET_NotificationContext *nc = pos->nc;
 103
 104   GNUNET_CONTAINER_DLL_remove (nc->subscribers_head,
 105                                nc->subscribers_tail,
 106                                pos);
 107   GNUNET_free (pos);
 108 }
 109
 110
 111 /**
 112  * Create a new notification context.
 113  *
 114  * @param queue_length maximum number of messages to keep in
 115  *        the notification queue; optional messages are dropped
 116  *        if the queue gets longer than this number of messages
 117  * @return handle to the notification context
 118  */
 119 struct GNUNET_NotificationContext *
 120 GNUNET_notification_context_create (unsigned int queue_length)
 121 {
 122   struct GNUNET_NotificationContext *nc;
 123
 124   nc = GNUNET_new (struct GNUNET_NotificationContext);
 125   nc->queue_length = queue_length;
 126   return nc;
 127 }
 128
 129
 130 /**
 131  * Destroy the context, force disconnect for all subscribers.
 132  *
 133  * @param nc context to destroy.
 134  */
 135 void
 136 GNUNET_notification_context_destroy (struct GNUNET_NotificationContext *nc)
 137 {
 138   struct SubscriberList *pos;
 139
 140   while (NULL != (pos = nc->subscribers_head))
 141   {
 142     GNUNET_CONTAINER_DLL_remove (nc->subscribers_head,
 143                                  nc->subscribers_tail,
 144                                  pos);
 145     GNUNET_MQ_destroy_notify_cancel (pos->mq_nh);
 146     GNUNET_free (pos);
 147   }
 148   GNUNET_free (nc);
 149 }
 150
 151
 152 /**
 153  * Add a subscriber to the notification context.
 154  *
 155  * @param nc context to modify
 156  * @param mq message queue add
 157  */
 158 void
 159 GNUNET_notification_context_add (struct GNUNET_NotificationContext *nc,
 160                                  struct GNUNET_MQ_Handle *mq)
 161 {
 162   struct SubscriberList *cl;
 163
 164   for (cl = nc->subscribers_head; NULL != cl; cl = cl->next)
 165     if (cl->mq == mq)
 166       return; /* already present */
 167   cl = GNUNET_new (struct SubscriberList);
 168   GNUNET_CONTAINER_DLL_insert (nc->subscribers_head,
 169                                nc->subscribers_tail,
 170                                cl);
 171   cl->nc = nc;
 172   cl->mq = mq;
 173   cl->mq_nh = GNUNET_MQ_destroy_notify (cl->mq,
 174                                         &handle_mq_destroy,
 175                                         cl);
 176 }
 177
 178
 179 /**
 180  * Send a message to all subscribers of this context.
 181  *
 182  * @param nc context to modify
 183  * @param msg message to send
 184  * @param can_drop can this message be dropped due to queue length limitations
 185  */
 186 void
 187 GNUNET_notification_context_broadcast (struct GNUNET_NotificationContext *nc,
 188                                        const struct GNUNET_MessageHeader *msg,
 189                                        int can_drop)
 190 {
 191   struct SubscriberList *pos;
 192   struct GNUNET_MQ_Envelope *env;
 193
 194   for (pos = nc->subscribers_head; NULL != pos; pos = pos->next)
 195   {
 196     if ( (GNUNET_YES == can_drop) &&
 197          (GNUNET_MQ_get_length (pos->mq) > nc->queue_length) )
 198       continue;
 199     env = GNUNET_MQ_msg_copy (msg);
 200     GNUNET_MQ_send (pos->mq,
 201                     env);
 202   }
 203 }
 204
 205
 206 /**
 207  * Return active number of subscribers in this context.
 208  *
 209  * @param nc context to query
 210  * @return number of current subscribers
 211  */
 212 unsigned int
 213 GNUNET_notification_context_get_size (struct GNUNET_NotificationContext *nc)
 214 {
 215   unsigned int num;
 216   struct SubscriberList *pos;
 217
 218   num = 0;
 219   for (pos = nc->subscribers_head; NULL != pos; pos = pos->next)
 220     num++;
 221   return num;
 222 }
 223
 224 /* end of nc.c */