refactor DHT for new service API

[oweals/gnunet.git] / src / core / core_api.c

diff --git a/src/core/core_api.c b/src/core/core_api.c
index 86c9d38a250eac210636b6131f9c3342d3bcbfa5..67f17352ddfd9170f8117b04332fabd6b0d4c28a 100644 (file)
--- a/src/core/core_api.c
+++ b/src/core/core_api.c
@@ -541,11 +541,12 @@ handle_notify_inbound (void *cls,
   uint16_t et;
 
   GNUNET_break (GNUNET_NO == h->currently_down);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received inbound message from `%s'.\n",
-       GNUNET_i2s (&ntm->peer));
   em = (const struct GNUNET_MessageHeader *) &ntm[1];
   et = ntohs (em->type);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received inbound message of type %d from `%s'.\n",
+       (int) et,
+       GNUNET_i2s (&ntm->peer));
   for (unsigned int hpos = 0; NULL != h->handlers[hpos].callback; hpos++)
   {
     const struct GNUNET_CORE_MessageHandler *mh;
@@ -674,6 +675,8 @@ handle_send_ready (void *cls,
   struct GNUNET_TIME_Relative delay;
   struct GNUNET_TIME_Relative overdue;
   unsigned int ret;
+  unsigned int priority;
+  int cork;
 
   GNUNET_break (GNUNET_NO == h->currently_down);
   pr = GNUNET_CONTAINER_multipeermap_get (h->peers,
@@ -708,11 +711,12 @@ handle_send_ready (void *cls,
   sm->priority = htonl ((uint32_t) th->priority);
   sm->deadline = GNUNET_TIME_absolute_hton (th->deadline);
   sm->peer = pr->peer;
-  sm->cork = htonl ((uint32_t) th->cork);
+  sm->cork = htonl ((uint32_t) (cork = th->cork));
   sm->reserved = htonl (0);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Calling get_message with buffer of %u bytes\n",
-              (unsigned int) th->msize);
+              "Calling get_message with buffer of %u bytes (%s)\n",
+              (unsigned int) th->msize,
+             cork ? "corked" : "uncorked");
   /* FIXME: this is ugly and a bit brutal, but "get_message"
      may call GNUNET_CORE_notify_transmit_ready() which
      may call GNUNET_MQ_send() as well, and we MUST get this
@@ -725,30 +729,33 @@ handle_send_ready (void *cls,
      be required */
   GNUNET_MQ_send (h->mq,
                   env);
+  delay = GNUNET_TIME_absolute_get_duration (th->request_time);
+  overdue = GNUNET_TIME_absolute_get_duration (th->deadline);
+  priority = th->priority;
   ret = th->get_message (th->get_message_cls,
                          th->msize,
                          &sm[1]);
+  /* after this point, 'th' should not be used anymore, it
+     may now be about another message! */
   sm->header.size = htons (ret + sizeof (struct SendMessage));
-  delay = GNUNET_TIME_absolute_get_duration (th->request_time);
-  overdue = GNUNET_TIME_absolute_get_duration (th->deadline);
   if (overdue.rel_value_us > GNUNET_CONSTANTS_LATENCY_WARN.rel_value_us)
     LOG (GNUNET_ERROR_TYPE_WARNING,
          "Transmitting overdue %u bytes to `%s' at priority %u with %s delay %s\n",
          ret,
          GNUNET_i2s (&pr->peer),
-         (unsigned int) th->priority,
+         priority,
          GNUNET_STRINGS_relative_time_to_string (delay,
                                                  GNUNET_YES),
-         (th->cork) ? " (corked)" : "");
+         (cork) ? " (corked)" : " (uncorked)");
   else
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Transmitting %u bytes to `%s' at priority %u with %s delay %s\n",
          ret,
          GNUNET_i2s (&pr->peer),
-         (unsigned int) th->priority,
+         priority,
          GNUNET_STRINGS_relative_time_to_string (delay,
                                                  GNUNET_YES),
-         (th->cork) ? " (corked)" : "");
+         (cork) ? " (corked)" : " (uncorked)");
 }
 
 
@@ -761,31 +768,31 @@ handle_send_ready (void *cls,
 static void
 reconnect (struct GNUNET_CORE_Handle *h)
 {
-  GNUNET_MQ_hd_fixed_size (init_reply,
-                           GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY,
-                           struct InitReplyMessage);
-  GNUNET_MQ_hd_fixed_size (connect_notify,
-                           GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT,
-                           struct ConnectNotifyMessage);
-  GNUNET_MQ_hd_fixed_size (disconnect_notify,
-                           GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT,
-                           struct DisconnectNotifyMessage);
-  GNUNET_MQ_hd_var_size (notify_inbound,
-                         GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND,
-                         struct NotifyTrafficMessage);
-  GNUNET_MQ_hd_var_size (notify_outbound,
-                         GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND,
-                         struct NotifyTrafficMessage);
-  GNUNET_MQ_hd_fixed_size (send_ready,
-                           GNUNET_MESSAGE_TYPE_CORE_SEND_READY,
-                           struct SendMessageReady);
- struct GNUNET_MQ_MessageHandler handlers[] = {
-    make_init_reply_handler (h),
-    make_connect_notify_handler (h),
-    make_disconnect_notify_handler (h),
-    make_notify_inbound_handler (h),
-    make_notify_outbound_handler (h),
-    make_send_ready_handler (h),
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_fixed_size (init_reply,
+                             GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY,
+                             struct InitReplyMessage,
+                             h),
+    GNUNET_MQ_hd_fixed_size (connect_notify,
+                             GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT,
+                             struct ConnectNotifyMessage,
+                             h),
+    GNUNET_MQ_hd_fixed_size (disconnect_notify,
+                             GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT,
+                             struct DisconnectNotifyMessage,
+                             h),
+    GNUNET_MQ_hd_var_size (notify_inbound,
+                           GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND,
+                           struct NotifyTrafficMessage,
+                           h),
+    GNUNET_MQ_hd_var_size (notify_outbound,
+                           GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND,
+                           struct NotifyTrafficMessage,
+                           h),
+    GNUNET_MQ_hd_fixed_size (send_ready,
+                             GNUNET_MESSAGE_TYPE_CORE_SEND_READY,
+                             struct SendMessageReady,
+                             h),
     GNUNET_MQ_handler_end ()
   };
   struct InitMessage *init;
@@ -891,7 +898,7 @@ GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
   h->handlers = GNUNET_new_array (hcnt + 1,
                                   struct GNUNET_CORE_MessageHandler);
   if (NULL != handlers)
-    memcpy (h->handlers,
+    GNUNET_memcpy (h->handlers,
             handlers,
             hcnt * sizeof (struct GNUNET_CORE_MessageHandler));
   h->hcnt = hcnt;
@@ -995,9 +1002,10 @@ GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle,
     return NULL;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Asking core for transmission of %u bytes to `%s'\n",
+       "Asking core for transmission of %u bytes to `%s'%s\n",
        (unsigned int) notify_size,
-       GNUNET_i2s (target));
+       GNUNET_i2s (target),
+       cork ? " (corked)" : "");
   pr = GNUNET_CONTAINER_multipeermap_get (handle->peers,
                                           target);
   if (NULL == pr)