stuff

2 files changed, 56 insertions, 243 deletions

diff --git a/src/core/core_api.c b/src/core/core_api.c
index e7e958bd7..a23313499 100644
--- a/src/core/core_api.c
+++ b/src/core/core_api.c
@@ -87,9 +87,14 @@ struct GNUNET_CORE_Handle
   const struct GNUNET_CORE_MessageHandler *handlers;
 
   /**
-   * Our connection to the service.
+   * Our connection to the service for notifications.
    */
-  struct GNUNET_CLIENT_Connection *client;
+  struct GNUNET_CLIENT_Connection *client_notifications;
+
+  /**
+   * Our connection to the service for normal requests.
+   */
+  struct GNUNET_CLIENT_Connection *client_requests;
 
   /**
    * Handle for our current transmission request.
@@ -263,10 +268,10 @@ static size_t transmit_start (void *cls, size_t size, void *buf);
 static void
 reconnect (struct GNUNET_CORE_Handle *h)
 {
-  GNUNET_CLIENT_disconnect (h->client);
+  GNUNET_CLIENT_disconnect (h->client_notifications);
   h->currently_down = GNUNET_YES;
-  h->client = GNUNET_CLIENT_connect (h->sched, "core", h->cfg);
-  h->th = GNUNET_CLIENT_notify_transmit_ready (h->client,
+  h->client_notifications = GNUNET_CLIENT_connect (h->sched, "core", h->cfg);
+  h->th = GNUNET_CLIENT_notify_transmit_ready (h->client_notifications,
                                                sizeof (struct InitMessage) +
                                                sizeof (uint16_t) * h->hcnt,
                                                GNUNET_TIME_UNIT_SECONDS,
@@ -346,6 +351,7 @@ static void
 trigger_next_request (struct GNUNET_CORE_Handle *h)
 {
   struct GNUNET_CORE_TransmitHandle *th;
+
   if (h->currently_down)
     return;                     /* connection temporarily down */
   if (NULL == (th = h->pending_head))
@@ -356,7 +362,7 @@ trigger_next_request (struct GNUNET_CORE_Handle *h)
       GNUNET_SCHEDULER_cancel (h->sched, th->timeout_task);
       th->timeout_task = GNUNET_SCHEDULER_NO_TASK;
     }
-  h->th = GNUNET_CLIENT_notify_transmit_ready (h->client,
+  h->th = GNUNET_CLIENT_notify_transmit_ready (h->client_requests,
                                                th->msize,
                                                GNUNET_TIME_absolute_get_remaining
                                                (th->timeout), 
@@ -367,20 +373,19 @@ trigger_next_request (struct GNUNET_CORE_Handle *h)
 
 
 /**
- * Handler for most messages received from the core.
+ * Handler for notification messages received from the core.
  *
  * @param cls our "struct GNUNET_CORE_Handle"
  * @param msg the message received from the core service
  */
 static void
-main_handler (void *cls, const struct GNUNET_MessageHeader *msg)
+main_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_CORE_Handle *h = cls;
   unsigned int hpos;
   const struct ConnectNotifyMessage *cnm;
   const struct DisconnectNotifyMessage *dnm;
   const struct NotifyTrafficMessage *ntm;
-  const struct ConfigurationInfoMessage *cim;
   const struct GNUNET_MessageHeader *em;
   uint16_t msize;
   uint16_t et;
@@ -524,38 +529,15 @@ main_handler (void *cls, const struct GNUNET_MessageHeader *msg)
                           GNUNET_TIME_relative_ntoh (ntm->latency),
                           ntohl (ntm->distance));
       break;
-    case GNUNET_MESSAGE_TYPE_CORE_CONFIGURATION_INFO:
-      if (msize != sizeof (struct ConfigurationInfoMessage))
-        {
-          GNUNET_break (0);
-          break;
-        }
-      if (NULL == h->submitted)
-        break;
-      cim = (const struct ConfigurationInfoMessage *) msg;
-
-      /* process configuration data */
-      if (h->submitted->info != NULL)
-        h->submitted->info (h->submitted->info_cls,
-                            &h->submitted->peer,
-                            ntohl (cim->bpm_in),
-                            ntohl (cim->bpm_out),
-                            (int) ntohl (cim->reserved_amount),
-                            cim->preference);
-      /* done, clean up! */      
-      GNUNET_CORE_notify_transmit_ready_cancel (h->submitted); // HUH?
-      trigger_next_request (h);
-      break;
     default:
       GNUNET_break (0);
       break;
     }
-  GNUNET_CLIENT_receive (h->client,
-                         &main_handler, h, GNUNET_TIME_UNIT_FOREVER_REL);
+  GNUNET_CLIENT_receive (h->client_notifications,
+                         &main_notify_handler, h, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
-
 /**
  * Function called when we are ready to transmit our
  * "START" message (or when this operation timed out).
@@ -606,8 +588,8 @@ init_reply_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 #endif
   h->currently_down = GNUNET_NO;
   trigger_next_request (h);
-  GNUNET_CLIENT_receive (h->client,
-                         &main_handler, h, GNUNET_TIME_UNIT_FOREVER_REL);
+  GNUNET_CLIENT_receive (h->client_notifications,
+                         &main_notify_handler, h, GNUNET_TIME_UNIT_FOREVER_REL);
   if (NULL != (init = h->init))
     {
       /* mark so we don't call init on reconnect */
@@ -710,7 +692,7 @@ transmit_start (void *cls, size_t size, void *buf)
   ts = (uint16_t *) & init[1];
   for (hpos = 0; hpos < h->hcnt; hpos++)
     ts[hpos] = htons (h->handlers[hpos].type);
-  GNUNET_CLIENT_receive (h->client,
+  GNUNET_CLIENT_receive (h->client_notifications,
                          &init_reply_handler,
                          h,
                          GNUNET_TIME_absolute_get_remaining
@@ -774,8 +756,8 @@ GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched,
   h->inbound_hdr_only = inbound_hdr_only;
   h->outbound_hdr_only = outbound_hdr_only;
   h->handlers = handlers;
-  h->client = GNUNET_CLIENT_connect (sched, "core", cfg);
-  if (h->client == NULL)
+  h->client_notifications = GNUNET_CLIENT_connect (sched, "core", cfg);
+  if (h->client_notifications == NULL)
     {
       GNUNET_free (h);
       return NULL;
@@ -793,7 +775,7 @@ GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched,
               timeout.value);
 #endif
   h->th =
-    GNUNET_CLIENT_notify_transmit_ready (h->client,
+    GNUNET_CLIENT_notify_transmit_ready (h->client_notifications,
                                          sizeof (struct InitMessage) +
                                          sizeof (uint16_t) * h->hcnt, timeout,
                                          GNUNET_YES,
@@ -816,7 +798,9 @@ GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
     GNUNET_CORE_notify_transmit_ready_cancel (handle->solicit_transmit_req);
   if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (handle->sched, handle->reconnect_task);
-  GNUNET_CLIENT_disconnect (handle->client);
+  GNUNET_CLIENT_disconnect (handle->client_notifications);
+  if (handle->client_requests != NULL)
+    GNUNET_CLIENT_disconnect (handle->client_requests);
   GNUNET_free_non_null (handle->solicit_buffer);
   GNUNET_free (handle);
 }
diff --git a/src/core/gnunet-service-core.c b/src/core/gnunet-service-core.c
index 915217ea1..842197fb1 100644
--- a/src/core/gnunet-service-core.c
+++ b/src/core/gnunet-service-core.c
@@ -539,31 +539,6 @@ struct Neighbour
 
 
 /**
- * Events are messages for clients.  The struct
- * itself is followed by the actual message.
- */
-struct Event
-{
-  /**
-   * This is a linked list.
-   */
-  struct Event *next;
-
-  /**
-   * Size of the message.
-   */
-  size_t size;
-
-  /**
-   * Could this event be dropped if this queue
-   * is getting too large? (NOT YET USED!)
-   */
-  int can_drop;
-
-};
-
-
-/**
  * Data structure for each client connected to the core service.
  */
 struct Client
@@ -579,23 +554,6 @@ struct Client
   struct GNUNET_SERVER_Client *client_handle;
 
   /**
-   * Linked list of messages we still need to deliver to
-   * this client.
-   */
-  struct Event *event_head;
-
-  /**
-   * Tail of the linked list of events.
-   */
-  struct Event *event_tail;
-
-  /**
-   * Current transmit handle, NULL if no transmission request
-   * is pending.
-   */
-  struct GNUNET_CONNECTION_TransmitHandle *th;
-
-  /**
    * Array of the types of messages this peer cares
    * about (with "tcnt" entries).  Allocated as part
    * of this client struct, do not free!
@@ -658,6 +616,11 @@ static struct GNUNET_TRANSPORT_Handle *transport;
 static struct Client *clients;
 
 /**
+ * Context for notifications we need to send to our clients.
+ */
+static struct GNUNET_SERVER_NotificationContext *notifier;
+
+/**
  * We keep neighbours in a linked list (for now).
  */
 static struct Neighbour *neighbours;
@@ -762,110 +725,6 @@ find_neighbour (const struct GNUNET_PeerIdentity *peer)
 
 
 /**
- * Find the entry for the given client.
- *
- * @param client handle for the client
- * @return NULL if we are not connected, otherwise the
- *         client's struct.
- */
-static struct Client *
-find_client (const struct GNUNET_SERVER_Client *client)
-{
-  struct Client *ret;
-
-  ret = clients;
-  while ((ret != NULL) && (client != ret->client_handle))
-    ret = ret->next;
-  return ret;
-}
-
-
-/**
- * If necessary, initiate a request with the server to
- * transmit messages from the queue of the given client.
- * @param client who to transfer messages to
- */
-static void request_transmit (struct Client *client);
-
-
-/**
- * Client is ready to receive data, provide it.
- *
- * @param cls closure
- * @param size number of bytes available in buf
- * @param buf where the callee should write the message
- * @return number of bytes written to buf
- */
-static size_t
-do_client_transmit (void *cls, size_t size, void *buf)
-{
-  struct Client *client = cls;
-  struct Event *e;
-  char *tgt;
-  size_t ret;
-
-  client->th = NULL;
-#if DEBUG_CORE_CLIENT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client ready to receive %u bytes.\n", size);
-#endif
-  if (buf == NULL)
-    {
-#if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Failed to transmit data to client (disconnect)?\n");
-#endif
-      return 0;                 /* we'll surely get a disconnect soon... */
-    }
-  tgt = buf;
-  ret = 0;
-  while ((NULL != (e = client->event_head)) && (e->size <= size))
-    {
-      memcpy (&tgt[ret], &e[1], e->size);
-      size -= e->size;
-      ret += e->size;
-      client->event_head = e->next;
-      GNUNET_free (e);
-    }
-  GNUNET_assert (ret > 0);
-  if (client->event_head == NULL)
-    client->event_tail = NULL;
-#if DEBUG_CORE_CLIENT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitting %u bytes to client\n", ret);
-#endif
-  request_transmit (client);
-  return ret;
-}
-
-
-/**
- * If necessary, initiate a request with the server to
- * transmit messages from the queue of the given client.
- * @param client who to transfer messages to
- */
-static void
-request_transmit (struct Client *client)
-{
-
-  if (NULL != client->th)
-    return;                     /* already pending */
-  if (NULL == client->event_head)
-    return;                     /* no more events pending */
-#if DEBUG_CORE_CLIENT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking server to transmit %u bytes to client\n",
-              client->event_head->size);
-#endif
-  client->th
-    = GNUNET_SERVER_notify_transmit_ready (client->client_handle,
-                                           client->event_head->size,
-                                           GNUNET_TIME_UNIT_FOREVER_REL,
-                                           &do_client_transmit, client);
-}
-
-
-/**
  * Send a message to one of our clients.
  *
  * @param client target for the message
@@ -875,51 +734,28 @@ request_transmit (struct Client *client)
  */
 static void
 send_to_client (struct Client *client,
-                const struct GNUNET_MessageHeader *msg, int can_drop)
+                const struct GNUNET_MessageHeader *msg, 
+                int can_drop)
 {
-  struct Event *e;
-  unsigned int queue_size;
-  uint16_t msize;
-
 #if DEBUG_CORE_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Preparing to send message of type %u to client.\n",
               ntohs (msg->type));
-#endif
-  queue_size = 0;
-  e = client->event_head;
-  while (e != NULL)
-    {
-      queue_size++;
-      e = e->next;
-    }
-  if ( (queue_size >= MAX_CLIENT_QUEUE_SIZE) &&
-       (can_drop == GNUNET_YES) )
-    {
-#if DEBUG_CORE
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  "Too many messages in queue for the client, dropping the new message.\n");
-#endif
-      return;
-    }
-
-  msize = ntohs (msg->size);
-  e = GNUNET_malloc (sizeof (struct Event) + msize);
-  /* append */
-  if (client->event_tail != NULL)
-    client->event_tail->next = e;
-  else
-    client->event_head = e;
-  client->event_tail = e;
-  e->can_drop = can_drop;
-  e->size = msize;
-  memcpy (&e[1], msg, msize);
-  request_transmit (client);
+#endif  
+  GNUNET_SERVER_notification_context_unicast (notifier,
+                                              client->client_handle,
+                                              msg,
+                                              can_drop);
 }
 
 
 /**
- * Send a message to all of our current clients.
+ * Send a message to all of our current clients that have
+ * the right options set.
+ * 
+ * @param msg message to multicast
+ * @param can_drop can this message be discarded if the queue is too long
+ * @param options mask to use 
  */
 static void
 send_to_all_clients (const struct GNUNET_MessageHeader *msg, 
@@ -978,6 +814,7 @@ handle_client_init (void *cls,
       GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
       return;
     }
+  GNUNET_SERVER_notification_context_add (notifier, client);
   im = (const struct InitMessage *) message;
   types = (const uint16_t *) &im[1];
   msize -= sizeof (struct InitMessage);
@@ -1017,7 +854,6 @@ handle_client_init (void *cls,
       send_to_client (c, &cnm.header, GNUNET_NO);
       n = n->next;
     }
-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
 
@@ -1032,7 +868,6 @@ handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
 {
   struct Client *pos;
   struct Client *prev;
-  struct Event *e;
 
   if (client == NULL)
     return;
@@ -1050,13 +885,6 @@ handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
             clients = pos->next;
           else
             prev->next = pos->next;
-          if (pos->th != NULL)
-            GNUNET_CONNECTION_notify_transmit_ready_cancel (pos->th);
-          while (NULL != (e = pos->event_head))
-            {
-              pos->event_head = e->next;
-              GNUNET_free (e);
-            }
           GNUNET_free (pos);
           return;
         }
@@ -1072,15 +900,15 @@ handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
  */
 static void
 handle_client_request_info (void *cls,
-                                 struct GNUNET_SERVER_Client *client,
-                                 const struct GNUNET_MessageHeader *message)
+                            struct GNUNET_SERVER_Client *client,
+                            const struct GNUNET_MessageHeader *message)
 {
   const struct RequestInfoMessage *rcm;
   struct Neighbour *n;
   struct ConfigurationInfoMessage cim;
-  struct Client *c;
   int reserv;
   unsigned long long old_preference;
+  struct GNUNET_SERVER_TransmitContext *tc;
 
 #if DEBUG_CORE_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -1128,17 +956,15 @@ handle_client_request_info (void *cls,
   cim.header.size = htons (sizeof (struct ConfigurationInfoMessage));
   cim.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_CONFIGURATION_INFO);
   cim.peer = rcm->peer;
-  c = find_client (client);
-  if (c == NULL)
-    {
-      GNUNET_break (0);
-      return;
-    }
+
 #if DEBUG_CORE_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Sending `%s' message to client.\n", "CONFIGURATION_INFO");
 #endif
-  send_to_client (c, &cim.header, GNUNET_NO);
+  tc = GNUNET_SERVER_transmit_context_create (client);
+  GNUNET_SERVER_transmit_context_append_message (tc, &cim.header);
+  GNUNET_SERVER_transmit_context_run (tc,
+                                      GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
@@ -3252,6 +3078,8 @@ cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       neighbour_count--;
       free_neighbour (n);
     }
+  GNUNET_SERVER_notification_context_destroy (notifier);
+  notifier = NULL;
   while (NULL != (c = clients))
     handle_client_disconnect (NULL, c->client_handle);
   if (my_private_key != NULL)
@@ -3281,7 +3109,7 @@ run (void *cls,
   char *keyfile;
 
   sched = s;
-  cfg = c;
+  cfg = c;  
   /* parse configuration */
   if (
        (GNUNET_OK !=
@@ -3330,6 +3158,7 @@ run (void *cls,
                       sizeof (my_public_key), &my_identity.hashPubKey);
   /* setup notification */
   server = serv;
+  notifier = GNUNET_SERVER_notification_context_create (server, 0);
   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
   /* setup transport connection */
   transport = GNUNET_TRANSPORT_connect (sched,