-removing useless parts of old code, work on DHT API

2 files changed, 268 insertions, 1844 deletions

diff --git a/src/dv/dv_api.c b/src/dv/dv_api.c
index ca4334f2f..3f9f11423 100644
--- a/src/dv/dv_api.c
+++ b/src/dv/dv_api.c
@@ -39,18 +39,39 @@
  */
 struct GNUNET_DV_TransmitHandle
 {
+  /**
+   * Kept in a DLL.
+   */
   struct GNUNET_DV_TransmitHandle *next;
 
+  /**
+   * Kept in a DLL.
+   */
   struct GNUNET_DV_TransmitHandle *prev;
 
+  /**
+   * Handle to the service.
+   */
   struct GNUNET_DV_ServiceHandle *sh;
 
+  /**
+   * Function to call upon completion.
+   */
   GNUNET_DV_MessageSentCallback cb;
 
+  /**
+   * Closure for 'cb'.
+   */
   void *cb_cls;
   
+  /**
+   * The actual message (allocated at the end of this struct).
+   */
   const struct GNUNET_MessageHeader *msg;
 
+  /**
+   * Destination for the message.
+   */
   struct GNUNET_PeerIdentity target;
 
 };
@@ -62,412 +83,131 @@ struct GNUNET_DV_TransmitHandle
 struct GNUNET_DV_ServiceHandle
 {
 
-  struct GNUNET_ClientHandle *client;
-
-  const struct GNUNET_CONFIGURATION_Handle *cfg;
-
-  void *cls;
-  
-  GNUNET_DV_ConnectCallback connect_cb;
-
-  GNUNET_DV_DisconnectCallback disconnect_cb;
-
-  GNUNET_DV_MessageReceivedCallback message_cb;
-
-  struct GNUNET_DV_TransmitHandle *th_head;
-
-  struct GNUNET_DV_TransmitHandle *th_tail;
-
-};
-
-
-/**
- * Connect to the DV service.
- *
- * @param cfg configuration
- * @param cls closure for callbacks
- * @param connect_cb function to call on connects
- * @param disconnect_cb function to call on disconnects
- * @param message_cb function to call if we receive messages
- * @return handle to access the service
- */
-struct GNUNET_DV_ServiceHandle *
-GNUNET_DV_service_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                           void *cls,
-                           GNUNET_DV_ConnectCallback connect_cb,
-                           GNUNET_DV_DisconnectCallback disconnect_cb,
-                           GNUNET_DV_MessageReceivedCallback message_cb)
-{
-  GNUNET_break (0);
-  return NULL;
-}
-
-
-/**
- * Disconnect from DV service.
- *
- * @param sh service handle
- */
-void
-GNUNET_DV_service_disconnect (struct GNUNET_DV_ServiceHandle *sh)
-{
-  GNUNET_break (0);
-}
-
-
-
-/**
- * Send a message via DV service.
- *
- * @param sh service handle
- * @param target intended recpient
- * @param msg message payload
- * @param cb function to invoke when done
- * @param cb_cls closure for 'cb'
- * @return handle to cancel the operation
- */
-struct GNUNET_DV_TransmitHandle *
-GNUNET_DV_send (struct GNUNET_DV_ServiceHandle *sh,
-                const struct GNUNET_PeerIdentity *target,
-                const struct GNUNET_MessageHeader *msg,
-                GNUNET_DV_MessageSentCallback cb,
-                void *cb_cls)
-{
-  GNUNET_break (0);
-  return NULL;
-}
-
-
-/**
- * Abort send operation (naturally, the message may have
- * already been transmitted; this only stops the 'cb'
- * from being called again).
- *
- * @param th send operation to cancel
- */
-void
-GNUNET_DV_send_cancel (struct GNUNET_DV_TransmitHandle *th)
-{
-  GNUNET_break (0);
-}
-
-
-
-#if 0
-
-
-
-
-
-
-
-
-
-
-
-
-/**
- * Store ready to send messages
- */
-struct PendingMessages
-{
-  /**
-   * Linked list of pending messages
-   */
-  struct PendingMessages *next;
-
-  /**
-   * Message that is pending
-   */
-  struct GNUNET_DV_SendMessage *msg;
-
-  /**
-   * Timeout for this message
-   */
-  struct GNUNET_TIME_Absolute timeout;
-
-};
-
-/**
- * Handle for the service.
- */
-struct GNUNET_DV_Handle
-{
-
-  /**
-   * Configuration to use.
-   */
-  const struct GNUNET_CONFIGURATION_Handle *cfg;
-
   /**
-   * Socket (if available).
+   * Connection to DV service.
    */
   struct GNUNET_CLIENT_Connection *client;
 
   /**
-   * Currently pending transmission request.
+   * Active request for transmission to DV service.
    */
   struct GNUNET_CLIENT_TransmitHandle *th;
 
   /**
-   * List of the currently pending messages for the DV service.
-   */
-  struct PendingMessages *pending_list;
-
-  /**
-   * Message we are currently sending.
-   */
-  struct PendingMessages *current;
-
-  /**
-   * Handler for messages we receive from the DV service
-   */
-  GNUNET_DV_MessageReceivedHandler receive_handler;
-
-  /**
-   * Closure for the receive handler
+   * Our configuration.
    */
-  void *receive_cls;
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
 
   /**
-   * Current unique ID
+   * Closure for the callbacks.
    */
-  uint32_t uid_gen;
-
+  void *cls;
+  
   /**
-   * Hashmap containing outstanding send requests awaiting confirmation.
+   * Function to call on connect events.
    */
-  struct GNUNET_CONTAINER_MultiHashMap *send_callbacks;
-
-};
-
+  GNUNET_DV_ConnectCallback connect_cb;
 
-struct StartContext
-{
   /**
-   * Start message
+   * Function to call on disconnect events.
    */
-  struct GNUNET_MessageHeader *message;
+  GNUNET_DV_DisconnectCallback disconnect_cb;
 
   /**
-   * Handle to service, in case of timeout
+   * Function to call on receiving messages events.
    */
-  struct GNUNET_DV_Handle *handle;
-};
+  GNUNET_DV_MessageReceivedCallback message_cb;
 
-struct SendCallbackContext
-{
   /**
-   * The continuation to call once a message is confirmed sent (or failed)
+   * Head of messages to transmit.
    */
-  GNUNET_TRANSPORT_TransmitContinuation cont;
+  struct GNUNET_DV_TransmitHandle *th_head;
 
   /**
-   * Closure to call with send continuation.
+   * Tail of messages to transmit.
    */
-  void *cont_cls;
+  struct GNUNET_DV_TransmitHandle *th_tail;
 
   /**
-   * Target of the message.
+   * Mapping of peer identities to TransmitHandles to invoke
+   * upon successful transmission.  The respective
+   * transmissions have already been done.
    */
-  struct GNUNET_PeerIdentity target;
+  struct GNUNET_CONTAINER_MultiHashMap *send_callbacks;
 
   /**
-   * Payload size in bytes
+   * Current unique ID
    */
-  size_t payload_size;
+  uint32_t uid_gen;
 
-  /**
-   * DV message size
-   */
-  size_t msg_size;
 };
 
-/**
- * Convert unique ID to hash code.
- *
- * @param uid unique ID to convert
- * @param hash set to uid (extended with zeros)
- */
-static void
-hash_from_uid (uint32_t uid, struct GNUNET_HashCode * hash)
-{
-  memset (hash, 0, sizeof (struct GNUNET_HashCode));
-  *((uint32_t *) hash) = uid;
-}
-
-/**
- * Try to (re)connect to the dv service.
- *
- * @param ret handle to the (disconnected) dv service
- *
- * @return GNUNET_YES on success, GNUNET_NO on failure.
- */
-static int
-try_connect (struct GNUNET_DV_Handle *ret)
-{
-  if (ret->client != NULL)
-    return GNUNET_OK;
-  ret->client = GNUNET_CLIENT_connect ("dv", ret->cfg);
-  if (ret->client != NULL)
-    return GNUNET_YES;
-#if DEBUG_DV_MESSAGES
-  LOG (GNUNET_ERROR_TYPE_DEBUG, _("Failed to connect to the dv service!\n"));
-#endif
-  return GNUNET_NO;
-}
-
-static void
-process_pending_message (struct GNUNET_DV_Handle *handle);
 
 /**
- * Send complete, schedule next
+ * Disconnect and then reconnect to the DV service.
  *
- * @param handle handle to the dv service
- * @param code return code for send (unused)
+ * @param sh service handle
  */
 static void
-finish (struct GNUNET_DV_Handle *handle, int code)
-{
-  struct PendingMessages *pos = handle->current;
+reconnect (struct GNUNET_DV_ServiceHandle *sh);
 
-  handle->current = NULL;
-  process_pending_message (handle);
-
-  GNUNET_free (pos->msg);
-  GNUNET_free (pos);
-}
 
 /**
- * Notification that we can send data
+ * Gives a message from our queue to the DV service.
  *
- * @param cls handle to the dv service (struct GNUNET_DV_Handle)
+ * @param cls handle to the dv service (struct GNUNET_DV_ServiceHandle)
  * @param size how many bytes can we send
  * @param buf where to copy the message to send
- *
  * @return how many bytes we copied to buf
  */
 static size_t
 transmit_pending (void *cls, size_t size, void *buf)
 {
-  struct GNUNET_DV_Handle *handle = cls;
+  struct GNUNET_DV_ServiceHandle *sh = cls;
   size_t ret;
   size_t tsize;
 
-#if DEBUG_DV
-  if (handle->current != NULL)
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "DV API: Transmit pending called with message type %d\n",
-         ntohs (handle->current->msg->header.type));
-#endif
-
-  if (buf == NULL)
+  sh->th = NULL;
+  if (NULL == buf)
   {
-#if DEBUG_DV
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "DV API: Transmit pending FAILED!\n\n\n");
-#endif
-    finish (handle, GNUNET_SYSERR);
+    reconnect (sh);
     return 0;
   }
-  handle->th = NULL;
-
   ret = 0;
-
-  if (handle->current != NULL)
+  // FIXME: yuck! -- copy multiple, remove from DLL, and add to hash map!
+  if (NULL != sh->th_head)
   {
-    tsize = ntohs (handle->current->msg->header.size);
+    tsize = ntohs (sh->th_head->msg->size);
     if (size >= tsize)
     {
-      memcpy (buf, handle->current->msg, tsize);
-#if DEBUG_DV
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "DV API: Copied %d bytes into buffer!\n\n\n", tsize);
-#endif
-      finish (handle, GNUNET_OK);
+      memcpy (buf, sh->th_head->msg, tsize);
       return tsize;
     }
-
   }
-
   return ret;
 }
 
+
 /**
- * Try to send messages from list of messages to send
+ * Start sending messages from our queue to the service.
  *
- * @param handle handle to the distance vector service
+ * @param sh service handle
  */
 static void
-process_pending_message (struct GNUNET_DV_Handle *handle)
+start_transmit (struct GNUNET_DV_ServiceHandle *sh)
 {
-
-  if (handle->current != NULL)
-    return;                     /* action already pending */
-  if (GNUNET_YES != try_connect (handle))
-  {
-    finish (handle, GNUNET_SYSERR);
-    return;
-  }
-
-  /* schedule next action */
-  handle->current = handle->pending_list;
-  if (NULL == handle->current)
-  {
+  if (NULL != sh->th)
     return;
-  }
-  handle->pending_list = handle->pending_list->next;
-  handle->current->next = NULL;
-
-  if (NULL ==
-      (handle->th =
-       GNUNET_CLIENT_notify_transmit_ready (handle->client,
-                                            ntohs (handle->current->msg->
-                                                   header.size),
-                                            handle->current->msg->timeout,
-                                            GNUNET_YES, &transmit_pending,
-                                            handle)))
-  {
-#if DEBUG_DV
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Failed to transmit request to dv service.\n");
-#endif
-    finish (handle, GNUNET_SYSERR);
-  }
+  if (NULL == sh->th_head)
+    return; 
+  sh->th =
+    GNUNET_CLIENT_notify_transmit_ready (sh->client,
+                                         ntohs (sh->th_head->msg->size),
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         GNUNET_NO, 
+                                         &transmit_pending, sh);
 }
 
-/**
- * Add a pending message to the linked list
- *
- * @param handle handle to the specified DV api
- * @param msg the message to add to the list
- */
-static void
-add_pending (struct GNUNET_DV_Handle *handle, struct GNUNET_DV_SendMessage *msg)
-{
-  struct PendingMessages *new_message;
-  struct PendingMessages *pos;
-  struct PendingMessages *last;
-
-  new_message = GNUNET_malloc (sizeof (struct PendingMessages));
-  new_message->msg = msg;
-
-  if (handle->pending_list != NULL)
-  {
-    pos = handle->pending_list;
-    while (pos != NULL)
-    {
-      last = pos;
-      pos = pos->next;
-    }
-    last->next = new_message;
-  }
-  else
-  {
-    handle->pending_list = new_message;
-  }
-
-  process_pending_message (handle);
-}
 
 /**
  * Handles a message sent from the DV service to us.
@@ -476,295 +216,255 @@ add_pending (struct GNUNET_DV_Handle *handle, struct GNUNET_DV_SendMessage *msg)
  * @param cls the handle to the DV API
  * @param msg the message that was received
  */
-void
-handle_message_receipt (void *cls, const struct GNUNET_MessageHeader *msg)
+static void
+handle_message_receipt (void *cls, 
+                        const struct GNUNET_MessageHeader *msg)
 {
-  struct GNUNET_DV_Handle *handle = cls;
-  struct GNUNET_DV_MessageReceived *received_msg;
-  struct GNUNET_DV_SendResultMessage *send_result_msg;
-  size_t packed_msg_len;
-  size_t sender_address_len;
-  char *sender_address;
-  char *packed_msg;
-  char *packed_msg_start;
-  struct GNUNET_HashCode uidhash;
-  struct SendCallbackContext *send_ctx;
-
-  if (msg == NULL)
+  struct GNUNET_DV_ServiceHandle *sh = cls;
+  const struct GNUNET_DV_ConnectMessage *cm;
+  const struct GNUNET_DV_DisconnectMessage *dm;
+  const struct GNUNET_DV_ReceivedMessage *rm;
+
+  if (NULL == msg)
   {
-#if DEBUG_DV_MESSAGES
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "DV_API receive: connection closed\n");
-#endif
-    return;                     /* Connection closed? */
+    /* Connection closed */
+    reconnect (sh);
+    return;
   }
-
-  GNUNET_assert ((ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TRANSPORT_DV_RECEIVE)
-                 || (ntohs (msg->type) ==
-                     GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND_RESULT));
-
   switch (ntohs (msg->type))
   {
-  case GNUNET_MESSAGE_TYPE_TRANSPORT_DV_RECEIVE:
-    if (ntohs (msg->size) < sizeof (struct GNUNET_DV_MessageReceived))
+  case GNUNET_MESSAGE_TYPE_DV_CONNECT:
+    if (ntohs (msg->size) != sizeof (struct GNUNET_DV_ConnectMessage))
+    {
+      GNUNET_break (0);
+      reconnect (sh);
       return;
-
-    received_msg = (struct GNUNET_DV_MessageReceived *) msg;
-    packed_msg_len = ntohl (received_msg->msg_len);
-    sender_address_len =
-        ntohs (msg->size) - packed_msg_len -
-        sizeof (struct GNUNET_DV_MessageReceived);
-    GNUNET_assert (sender_address_len > 0);
-    sender_address = GNUNET_malloc (sender_address_len);
-    memcpy (sender_address, &received_msg[1], sender_address_len);
-    packed_msg_start = (char *) &received_msg[1];
-    packed_msg = GNUNET_malloc (packed_msg_len);
-    memcpy (packed_msg, &packed_msg_start[sender_address_len], packed_msg_len);
-
-#if DEBUG_DV_MESSAGES
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "DV_API receive: packed message type: %d or %d\n",
-         ntohs (((struct GNUNET_MessageHeader *) packed_msg)->type),
-         ((struct GNUNET_MessageHeader *) packed_msg)->type);
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "DV_API receive: message sender reported as %s\n",
-         GNUNET_i2s (&received_msg->sender));
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "DV_API receive: distance is %u\n",
-         ntohl (received_msg->distance));
-#endif
-
-    handle->receive_handler (handle->receive_cls, &received_msg->sender,
-                             packed_msg, packed_msg_len,
-                             ntohl (received_msg->distance), sender_address,
-                             sender_address_len);
-
-    GNUNET_free (sender_address);
+    }
+    cm = (const struct GNUNET_DV_ConnectMessage *) msg;
+    // FIXME
     break;
-  case GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND_RESULT:
-    if (ntohs (msg->size) < sizeof (struct GNUNET_DV_SendResultMessage))
+  case GNUNET_MESSAGE_TYPE_DV_DISCONNECT:
+    if (ntohs (msg->size) != sizeof (struct GNUNET_DV_DisconnectMessage))
+    {
+      GNUNET_break (0);
+      reconnect (sh);
       return;
-
-    send_result_msg = (struct GNUNET_DV_SendResultMessage *) msg;
-    hash_from_uid (ntohl (send_result_msg->uid), &uidhash);
-    send_ctx =
-        GNUNET_CONTAINER_multihashmap_get (handle->send_callbacks, &uidhash);
-
-    if ((send_ctx != NULL) && (send_ctx->cont != NULL))
+    }
+    dm = (const struct GNUNET_DV_DisconnectMessage *) msg;
+    // FIXME
+    break;
+  case GNUNET_MESSAGE_TYPE_DV_RECV:
+    if (ntohs (msg->size) < sizeof (struct GNUNET_DV_ReceivedMessage))
     {
-      if (ntohl (send_result_msg->result) == 0)
-      {
-        send_ctx->cont (send_ctx->cont_cls, &send_ctx->target, GNUNET_OK,
-                        send_ctx->payload_size, send_ctx->msg_size);
-      }
-      else
-      {
-        send_ctx->cont (send_ctx->cont_cls, &send_ctx->target, GNUNET_SYSERR,
-                        send_ctx->payload_size, 0);
-      }
+      GNUNET_break (0);
+      reconnect (sh);
+      return;
     }
-    GNUNET_free_non_null (send_ctx);
+    rm = (const struct GNUNET_DV_ReceivedMessage *) msg;
+    // FIXME
     break;
   default:
+    reconnect (sh);
     break;
   }
-  GNUNET_CLIENT_receive (handle->client, &handle_message_receipt, handle,
+  GNUNET_CLIENT_receive (sh->client, 
+                         &handle_message_receipt, sh,
                          GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
-/**
- * Send a message from the plugin to the DV service indicating that
- * a message should be sent via DV to some peer.
- *
- * @param dv_handle the handle to the DV api
- * @param target the final target of the message
- * @param msgbuf the msg(s) to send
- * @param msgbuf_size the size of msgbuf
- * @param priority priority to pass on to core when sending the message
- * @param timeout how long can this message be delayed (pass through to core)
- * @param addr the address of this peer (internally known to DV)
- * @param addrlen the length of the peer address
- * @param cont continuation to call once the message has been sent (or failed)
- * @param cont_cls closure for continuation
- *
- */
-int
-GNUNET_DV_send (struct GNUNET_DV_Handle *dv_handle,
-                const struct GNUNET_PeerIdentity *target, const char *msgbuf,
-                size_t msgbuf_size, unsigned int priority,
-                struct GNUNET_TIME_Relative timeout, const void *addr,
-                size_t addrlen, GNUNET_TRANSPORT_TransmitContinuation cont,
-                void *cont_cls)
-{
-  struct GNUNET_DV_SendMessage *msg;
-  struct SendCallbackContext *send_ctx;
-  char *end_of_message;
-  struct GNUNET_HashCode uidhash;
-  int msize;
-
-#if DEBUG_DV_MESSAGES
-  dv_handle->uid_gen =
-      GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, UINT32_MAX);
-#else
-  dv_handle->uid_gen++;
-#endif
-
-  msize = sizeof (struct GNUNET_DV_SendMessage) + addrlen + msgbuf_size;
-  msg = GNUNET_malloc (msize);
-  msg->header.size = htons (msize);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND);
-  memcpy (&msg->target, target, sizeof (struct GNUNET_PeerIdentity));
-  msg->priority = htonl (priority);
-  msg->timeout = timeout;
-  msg->addrlen = htonl (addrlen);
-  msg->uid = htonl (dv_handle->uid_gen);
-  memcpy (&msg[1], addr, addrlen);
-  end_of_message = (char *) &msg[1];
-  end_of_message = &end_of_message[addrlen];
-  memcpy (end_of_message, msgbuf, msgbuf_size);
-  add_pending (dv_handle, msg);
-  send_ctx = GNUNET_malloc (sizeof (struct SendCallbackContext));
-  send_ctx->payload_size = msgbuf_size;
-  send_ctx->msg_size = msize;
-  send_ctx->cont = cont;
-  send_ctx->cont_cls = cont_cls;
-  memcpy (&send_ctx->target, target, sizeof (struct GNUNET_PeerIdentity));
-  hash_from_uid (dv_handle->uid_gen, &uidhash);
-  GNUNET_CONTAINER_multihashmap_put (dv_handle->send_callbacks, &uidhash,
-                                     send_ctx,
-                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
-
-  return GNUNET_OK;
-}
 
 /**
- * Callback to transmit a start message to
- * the DV service, once we can send
+ * Transmit the start message to the DV service.
  *
- * @param cls struct StartContext
- * @param size how much can we send
+ * @param cls the 'struct GNUNET_DV_ServiceHandle'
+ * @param size number of bytes available in buf
  * @param buf where to copy the message
- *
- * @return number of bytes copied to buf
- */
+ * @return number of bytes written to buf
+ */ 
 static size_t
-transmit_start (void *cls, size_t size, void *buf)
+transmit_start (void *cls,
+                size_t size,
+                void *buf)
 {
-  struct StartContext *start_context = cls;
-  struct GNUNET_DV_Handle *handle = start_context->handle;
-  size_t tsize;
+  struct GNUNET_DV_ServiceHandle *sh = cls;
+  struct GNUNET_MessageHeader start_message;
 
-#if DEBUG_DV
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "DV API: sending start request to service\n");
-#endif
-  if (buf == NULL)
+  sh->th = NULL;
+  if (NULL == buf)
   {
-    GNUNET_free (start_context->message);
-    GNUNET_free (start_context);
-    GNUNET_DV_disconnect (handle);
+    GNUNET_break (0);
+    reconnect (sh);
     return 0;
   }
-
-  tsize = ntohs (start_context->message->size);
-  if (size >= tsize)
-  {
-    memcpy (buf, start_context->message, tsize);
-    GNUNET_free (start_context->message);
-    GNUNET_free (start_context);
-    GNUNET_CLIENT_receive (handle->client, &handle_message_receipt, handle,
-                           GNUNET_TIME_UNIT_FOREVER_REL);
-
-
-    return tsize;
-  }
-
-  return 0;
+  GNUNET_assert (size >= sizeof (start_message));
+  start_message.size = htons (sizeof (struct GNUNET_MessageHeader));
+  start_message.type = htons (GNUNET_MESSAGE_TYPE_DV_START);
+  memcpy (buf, &start_message, sizeof (start_message));
+  GNUNET_CLIENT_receive (sh->client,
+                         &handle_message_receipt, sh,
+                         GNUNET_TIME_UNIT_FOREVER_REL);
+  start_transmit (sh);
+  return sizeof (start_message);
 }
 
+
 /**
- * Connect to the DV service
+ * Disconnect and then reconnect to the DV service.
  *
- * @param cfg the configuration to use
- * @param receive_handler method call when on receipt from the service
- * @param receive_handler_cls closure for receive_handler
- *
- * @return handle to the DV service
+ * @param sh service handle
  */
-struct GNUNET_DV_Handle *
-GNUNET_DV_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                   GNUNET_DV_MessageReceivedHandler receive_handler,
-                   void *receive_handler_cls)
+static void
+reconnect (struct GNUNET_DV_ServiceHandle *sh)
 {
-  struct GNUNET_DV_Handle *handle;
-  struct GNUNET_MessageHeader *start_message;
-  struct StartContext *start_context;
-
-  handle = GNUNET_malloc (sizeof (struct GNUNET_DV_Handle));
-
-  handle->cfg = cfg;
-  handle->pending_list = NULL;
-  handle->current = NULL;
-  handle->th = NULL;
-  handle->client = GNUNET_CLIENT_connect ("dv", cfg);
-  handle->receive_handler = receive_handler;
-  handle->receive_cls = receive_handler_cls;
-
-  if (handle->client == NULL)
+  if (NULL != sh->th)
   {
-    GNUNET_free (handle);
-    return NULL;
+    GNUNET_CLIENT_notify_transmit_ready_cancel (sh->th);
+    sh->th = NULL;
   }
+  if (NULL != sh->client)
+  {
+    GNUNET_CLIENT_disconnect (sh->client);
+    sh->client = NULL;
+  }
+  sh->client = GNUNET_CLIENT_connect ("dv", sh->cfg);
+  if (NULL == sh->client)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  sh->th = GNUNET_CLIENT_notify_transmit_ready (sh->client,
+                                                sizeof (struct GNUNET_MessageHeader),
+                                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                                GNUNET_YES,
+                                                &transmit_start,
+                                                sh);
+}
 
-  start_message = GNUNET_malloc (sizeof (struct GNUNET_MessageHeader));
-  start_message->size = htons (sizeof (struct GNUNET_MessageHeader));
-  start_message->type = htons (GNUNET_MESSAGE_TYPE_DV_START);
-
-  start_context = GNUNET_malloc (sizeof (struct StartContext));
-  start_context->handle = handle;
-  start_context->message = start_message;
-  GNUNET_CLIENT_notify_transmit_ready (handle->client,
-                                       sizeof (struct GNUNET_MessageHeader),
-                                       GNUNET_TIME_relative_multiply
-                                       (GNUNET_TIME_UNIT_SECONDS, 60),
-                                       GNUNET_YES, &transmit_start,
-                                       start_context);
 
-  handle->send_callbacks = GNUNET_CONTAINER_multihashmap_create (100, GNUNET_NO);
+/**
+ * Connect to the DV service.
+ *
+ * @param cfg configuration
+ * @param cls closure for callbacks
+ * @param connect_cb function to call on connects
+ * @param disconnect_cb function to call on disconnects
+ * @param message_cb function to call if we receive messages
+ * @return handle to access the service
+ */
+struct GNUNET_DV_ServiceHandle *
+GNUNET_DV_service_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                           void *cls,
+                           GNUNET_DV_ConnectCallback connect_cb,
+                           GNUNET_DV_DisconnectCallback disconnect_cb,
+                           GNUNET_DV_MessageReceivedCallback message_cb)
+{
+  struct GNUNET_DV_ServiceHandle *sh;
 
-  return handle;
+  sh = GNUNET_malloc (sizeof (struct GNUNET_DV_ServiceHandle));
+  sh->cfg = cfg;
+  sh->cls = cls;
+  sh->connect_cb = connect_cb;
+  sh->disconnect_cb = disconnect_cb;
+  sh->message_cb = message_cb;
+  sh->send_callbacks = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_YES);
+  reconnect (sh);
+  return sh;
 }
 
+
 /**
- * Disconnect from the DV service
+ * Disconnect from DV service.
  *
- * @param handle the current handle to the service to disconnect
+ * @param sh service handle
  */
 void
-GNUNET_DV_disconnect (struct GNUNET_DV_Handle *handle)
+GNUNET_DV_service_disconnect (struct GNUNET_DV_ServiceHandle *sh)
 {
-  struct PendingMessages *pos;
-
-  GNUNET_assert (handle != NULL);
-
-  if (handle->th != NULL)       /* We have a live transmit request in the Aether */
+  struct GNUNET_DV_TransmitHandle *pos;
+  
+  if (NULL == sh)
+    return;
+  if (NULL != sh->th)
   {
-    GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th);
-    handle->th = NULL;
+    GNUNET_CLIENT_notify_transmit_ready_cancel (sh->th);
+    sh->th = NULL;
   }
-  if (handle->current != NULL)  /* We are trying to send something now, clean it up */
-    GNUNET_free (handle->current);
-  while (NULL != (pos = handle->pending_list))  /* Remove all pending sends from the list */
+  while (NULL != (pos = sh->th_head))
   {
-    handle->pending_list = pos->next;
+    GNUNET_CONTAINER_DLL_remove (sh->th_head,
+                                 sh->th_tail,
+                                 pos);
     GNUNET_free (pos);
   }
-  if (handle->client != NULL)   /* Finally, disconnect from the service */
+  if (NULL != sh->client) 
   {
-    GNUNET_CLIENT_disconnect (handle->client);
-    handle->client = NULL;
+    GNUNET_CLIENT_disconnect (sh->client);
+    sh->client = NULL;
   }
+  // FIXME: handle and/or free entries in 'send_callbacks'!
+  GNUNET_CONTAINER_multihashmap_destroy (sh->send_callbacks);
+  GNUNET_free (sh);
+}
 
-  GNUNET_free (handle);
+
+/**
+ * Send a message via DV service.
+ *
+ * @param sh service handle
+ * @param target intended recpient
+ * @param msg message payload
+ * @param cb function to invoke when done
+ * @param cb_cls closure for 'cb'
+ * @return handle to cancel the operation
+ */
+struct GNUNET_DV_TransmitHandle *
+GNUNET_DV_send (struct GNUNET_DV_ServiceHandle *sh,
+                const struct GNUNET_PeerIdentity *target,
+                const struct GNUNET_MessageHeader *msg,
+                GNUNET_DV_MessageSentCallback cb,
+                void *cb_cls)
+{
+  struct GNUNET_DV_TransmitHandle *th;
+
+  th = GNUNET_malloc (sizeof (struct GNUNET_DV_TransmitHandle) +
+                      ntohs (msg->size));
+  th->sh = sh;
+  th->target = *target;
+  th->cb = cb;
+  th->cb_cls = cb_cls;
+  // FIXME: wrong, need to box 'msg' AND generate UID!
+  th->msg = (const struct GNUNET_MessageHeader *) &th[1];
+  memcpy (&th[1], msg, ntohs (msg->size));
+  GNUNET_CONTAINER_DLL_insert (sh->th_head,
+                               sh->th_tail,
+                               th);
+  start_transmit (sh);
+  return th;
+}
+
+
+/**
+ * Abort send operation (naturally, the message may have
+ * already been transmitted; this only stops the 'cb'
+ * from being called again).
+ *
+ * @param th send operation to cancel
+ */
+void
+GNUNET_DV_send_cancel (struct GNUNET_DV_TransmitHandle *th)
+{
+  struct GNUNET_DV_ServiceHandle *sh = th->sh;
+  int ret;
+
+  ret = GNUNET_CONTAINER_multihashmap_remove (sh->send_callbacks,
+                                              &th->target.hashPubKey,
+                                              th);
+  if (GNUNET_YES != ret)
+    GNUNET_CONTAINER_DLL_remove (sh->th_head,
+                                 sh->th_tail,
+                                 th);
+  GNUNET_free (th);
 }
 
-#endif
 
 /* end of dv_api.c */
diff --git a/src/dv/gnunet-service-dv.c b/src/dv/gnunet-service-dv.c
index 451a438f9..c9b45b4e0 100644
--- a/src/dv/gnunet-service-dv.c
+++ b/src/dv/gnunet-service-dv.c
@@ -445,7 +445,7 @@ send_data_to_plugin (const struct GNUNET_MessageHeader *message,
   pending_message = GNUNET_malloc (sizeof (struct PendingMessage) + size);
   received_msg = (struct GNUNET_DV_ReceivedMessage *) &pending_message[1];
   received_msg->header.size = htons (size);
-  received_msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_RECV);
+  received_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DV_RECV);
   received_msg->distance = htonl (distance);
   received_msg->sender = *distant_neighbor;
   memcpy (&received_msg[1], message, ntohs (message->size));
@@ -490,7 +490,7 @@ send_ack_to_plugin (struct GNUNET_PeerIdentity *target,
   pending_message = GNUNET_malloc (sizeof (struct PendingMessage) + size);
   ack_msg = (struct GNUNET_DV_AckMessage *) &pending_message[1];
   ack_msg->header.size = htons (size);
-  ack_msg->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND_ACK);
+  ack_msg->header.type = htons (GNUNET_MESSAGE_TYPE_DV_SEND_ACK);
   ack_msg->uid = htonl (uid);
   ack_msg->target = *target;
   GNUNET_CONTAINER_DLL_insert_tail (plugin_pending_head, 
@@ -556,1282 +556,6 @@ core_transmit_notify (void *cls, size_t size, void *buf)
 }
 
 
-#if 0
-// ////////////////////////////////////////////////////////////////////////
-
-
-/**
- * Send a DV data message via DV.
- *
- * @param sender the original sender of the message
- * @param recipient the next hop recipient, may be our direct peer, maybe not
- * @param send_context the send context
- */
-static int
-send_message_via (const struct GNUNET_PeerIdentity *sender,
-                  const struct GNUNET_PeerIdentity *recipient,
-                  struct DV_SendContext *send_context)
-{
-  p2p_dv_MESSAGE_Data *toSend;
-  unsigned int msg_size;
-  unsigned int recipient_id;
-  unsigned int sender_id;
-  struct DistantNeighbor *source;
-  struct PendingMessage *pending_message;
-  struct FindIDContext find_context;
-
-  msg_size = send_context->message_size + sizeof (p2p_dv_MESSAGE_Data);
-
-  find_context.dest = send_context->distant_peer;
-  find_context.via = recipient;
-  find_context.tid = 0;
-  GNUNET_CONTAINER_multihashmap_get_multiple (extended_neighbors,
-                                              &send_context->
-                                              distant_peer->hashPubKey,
-                                              &find_specific_id, &find_context);
-
-  if (find_context.tid == 0)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "%s: find_specific_id failed to find peer!\n", my_short_id);
-    /* target unknown to us, drop! */
-    return GNUNET_SYSERR;
-  }
-  recipient_id = find_context.tid;
-
-  if (0 == (memcmp (&my_identity, sender, sizeof (struct GNUNET_PeerIdentity))))
-  {
-    sender_id = 0;
-    source =
-        GNUNET_CONTAINER_multihashmap_get (extended_neighbors,
-                                           &sender->hashPubKey);
-    if (source != NULL)
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "%s: send_message_via found %s, myself in extended peer list???\n",
-                  my_short_id, GNUNET_i2s (&source->identity));
-  }
-  else
-  {
-    source =
-        GNUNET_CONTAINER_multihashmap_get (extended_neighbors,
-                                           &sender->hashPubKey);
-    if (source == NULL)
-    {
-      /* sender unknown to us, drop! */
-      return GNUNET_SYSERR;
-    }
-    sender_id = source->our_id;
-  }
-
-  pending_message = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
-  pending_message->msg = (struct GNUNET_MessageHeader *) &pending_message[1];
-  pending_message->send_result = send_context->send_result;
-  memcpy (&pending_message->recipient, recipient,
-          sizeof (struct GNUNET_PeerIdentity));
-  pending_message->msg_size = msg_size;
-  pending_message->importance = send_context->importance;
-  pending_message->timeout = send_context->timeout;
-  toSend = (p2p_dv_MESSAGE_Data *) pending_message->msg;
-  toSend->header.size = htons (msg_size);
-  toSend->header.type = htons (GNUNET_MESSAGE_TYPE_DV_DATA);
-  toSend->sender = htonl (sender_id);
-  toSend->recipient = htonl (recipient_id);
-#if DEBUG_DV_MESSAGES
-  toSend->uid = send_context->uid;      /* Still sent around in network byte order */
-#else
-  toSend->uid = htonl (0);
-#endif
-
-  memcpy (&toSend[1], send_context->message, send_context->message_size);
-
-#if DEBUG_DV
-  memcpy (&shortname, GNUNET_i2s (send_context->distant_peer), 4);
-  shortname[4] = '\0';
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%s: Notifying core of send to destination `%s' via `%s' size %u\n",
-              "DV", &shortname, GNUNET_i2s (recipient), msg_size);
-#endif
-
-  GNUNET_CONTAINER_DLL_insert_after (core_pending_head, core_pending_tail,
-                                     core_pending_tail, pending_message);
-
-  GNUNET_SCHEDULER_add_now (try_core_send, NULL);
-
-  return GNUNET_YES;
-}
-
-/**
- * Given a FindLeastCostContext, and a set
- * of peers that match the target, return the cheapest.
- *
- * @param cls closure, a struct FindLeastCostContext
- * @param key the key identifying the target peer
- * @param value the target peer
- *
- * @return GNUNET_YES to continue iteration, GNUNET_NO to stop
- */
-static int
-find_least_cost_peer (void *cls, const struct GNUNET_HashCode * key, void *value)
-{
-  struct FindLeastCostContext *find_context = cls;
-  struct DistantNeighbor *dn = value;
-
-  if (dn->cost < find_context->least_cost)
-  {
-    find_context->target = dn;
-  }
-  if (dn->cost == DIRECT_NEIGHBOR_COST)
-    return GNUNET_NO;
-  return GNUNET_YES;
-}
-
-/**
- * Send a DV data message via DV.
- *
- * @param recipient the ultimate recipient of this message
- * @param sender the original sender of the message
- * @param specific_neighbor the specific neighbor to send this message via
- * @param message the packed message
- * @param message_size size of the message
- * @param importance what priority to send this message with
- * @param uid the unique identifier of this message (or 0 for none)
- * @param timeout how long to possibly delay sending this message
- */
-static int
-send_message (const struct GNUNET_PeerIdentity *recipient,
-              const struct GNUNET_PeerIdentity *sender,
-              const struct DistantNeighbor *specific_neighbor,
-              const struct GNUNET_MessageHeader *message, size_t message_size,
-              unsigned int importance, unsigned int uid,
-              struct GNUNET_TIME_Relative timeout)
-{
-  p2p_dv_MESSAGE_Data *toSend;
-  unsigned int msg_size;
-  unsigned int cost;
-  unsigned int recipient_id;
-  unsigned int sender_id;
-  struct DistantNeighbor *target;
-  struct DistantNeighbor *source;
-  struct PendingMessage *pending_message;
-  struct FindLeastCostContext find_least_ctx;
-
-#if DEBUG_DV_PEER_NUMBERS
-  struct GNUNET_CRYPTO_HashAsciiEncoded encPeerFrom;
-  struct GNUNET_CRYPTO_HashAsciiEncoded encPeerTo;
-  struct GNUNET_CRYPTO_HashAsciiEncoded encPeerVia;
-#endif
-  msg_size = message_size + sizeof (p2p_dv_MESSAGE_Data);
-
-  find_least_ctx.least_cost = -1;
-  find_least_ctx.target = NULL;
-  /*
-   * Need to find the least cost peer, lest the transport selection keep
-   * picking the same DV route for the same destination which results
-   * in messages looping forever.  Relatively cheap, we don't iterate
-   * over all known peers, just those that apply.
-   */
-  GNUNET_CONTAINER_multihashmap_get_multiple (extended_neighbors,
-                                              &recipient->hashPubKey,
-                                              &find_least_cost_peer,
-                                              &find_least_ctx);
-  target = find_least_ctx.target;
-
-  if (target == NULL)
-  {
-    /* target unknown to us, drop! */
-    return GNUNET_SYSERR;
-  }
-  recipient_id = target->referrer_id;
-
-  source =
-      GNUNET_CONTAINER_multihashmap_get (extended_neighbors,
-                                         &sender->hashPubKey);
-  if (source == NULL)
-  {
-    if (0 !=
-        (memcmp (&my_identity, sender, sizeof (struct GNUNET_PeerIdentity))))
-    {
-      /* sender unknown to us, drop! */
-      return GNUNET_SYSERR;
-    }
-    sender_id = 0;              /* 0 == us */
-  }
-  else
-  {
-    /* find out the number that we use when we gossip about
-     * the sender */
-    sender_id = source->our_id;
-  }
-
-#if DEBUG_DV_PEER_NUMBERS
-  GNUNET_CRYPTO_hash_to_enc (&source->identity.hashPubKey, &encPeerFrom);
-  GNUNET_CRYPTO_hash_to_enc (&target->referrer->identity.hashPubKey,
-                             &encPeerVia);
-  encPeerFrom.encoding[4] = '\0';
-  encPeerVia.encoding[4] = '\0';
-#endif
-  if ((sender_id != 0) &&
-      (0 ==
-       memcmp (&source->identity, &target->referrer->identity,
-               sizeof (struct GNUNET_PeerIdentity))))
-  {
-    return 0;
-  }
-
-  cost = target->cost;
-  pending_message = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
-  pending_message->msg = (struct GNUNET_MessageHeader *) &pending_message[1];
-  pending_message->send_result = NULL;
-  pending_message->importance = importance;
-  pending_message->timeout = timeout;
-  memcpy (&pending_message->recipient, &target->referrer->identity,
-          sizeof (struct GNUNET_PeerIdentity));
-  pending_message->msg_size = msg_size;
-  toSend = (p2p_dv_MESSAGE_Data *) pending_message->msg;
-  toSend->header.size = htons (msg_size);
-  toSend->header.type = htons (GNUNET_MESSAGE_TYPE_DV_DATA);
-  toSend->sender = htonl (sender_id);
-  toSend->recipient = htonl (recipient_id);
-#if DEBUG_DV_MESSAGES
-  toSend->uid = htonl (uid);
-#else
-  toSend->uid = htonl (0);
-#endif
-
-#if DEBUG_DV_PEER_NUMBERS
-  GNUNET_CRYPTO_hash_to_enc (&target->identity.hashPubKey, &encPeerTo);
-  encPeerTo.encoding[4] = '\0';
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%s: Sending DATA message. Sender id %u, source %s, destination %s, via %s\n",
-              GNUNET_i2s (&my_identity), sender_id, &encPeerFrom, &encPeerTo,
-              &encPeerVia);
-#endif
-  memcpy (&toSend[1], message, message_size);
-  if ((source != NULL) && (source->pkey == NULL))       /* Test our hypothesis about message failures! */
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "%s: Sending message, but anticipate recipient will not know sender!!!\n\n\n",
-                my_short_id);
-  }
-  GNUNET_CONTAINER_DLL_insert_after (core_pending_head, core_pending_tail,
-                                     core_pending_tail, pending_message);
-#if DEBUG_DV
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%s: Notifying core of send size %d to destination `%s'\n",
-              "DV SEND MESSAGE", msg_size, GNUNET_i2s (recipient));
-#endif
-
-  GNUNET_SCHEDULER_add_now (try_core_send, NULL);
-  return (int) cost;
-}
-
-#if USE_PEER_ID
-struct CheckPeerContext
-{
-  /**
-   * Peer we found
-   */
-  struct DistantNeighbor *peer;
-
-  /**
-   * Sender id to search for
-   */
-  unsigned int sender_id;
-};
-
-/**
- * Iterator over hash map entries.
- *
- * @param cls closure
- * @param key current key code
- * @param value value in the hash map
- * @return GNUNET_YES if we should continue to
- *         iterate,
- *         GNUNET_NO if not.
- */
-int
-checkPeerID (void *cls, const struct GNUNET_HashCode * key, void *value)
-{
-  struct CheckPeerContext *ctx = cls;
-  struct DistantNeighbor *distant = value;
-
-  if (memcmp (key, &ctx->sender_id, sizeof (unsigned int)) == 0)
-  {
-    ctx->peer = distant;
-    return GNUNET_NO;
-  }
-  return GNUNET_YES;
-
-}
-#endif
-
-
-/**
- * Handler for messages parsed out by the tokenizer from
- * DV DATA received for this peer.
- *
- * @param cls NULL
- * @param client the TokenizedMessageContext which contains message information
- * @param message the actual message
- */
-int
-tokenized_message_handler (void *cls, void *client,
-                           const struct GNUNET_MessageHeader *message)
-{
-  struct TokenizedMessageContext *ctx = client;
-
-  GNUNET_break_op (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_GOSSIP);
-  GNUNET_break_op (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_DATA);
-  if ((ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_GOSSIP) &&
-      (ntohs (message->type) != GNUNET_MESSAGE_TYPE_DV_DATA))
-  {
-#if DEBUG_DV_MESSAGES
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "%s: Receives %s message for me, uid %u, size %d, type %d cost %u from %s!\n",
-                my_short_id, "DV DATA", ctx->uid, ntohs (message->size),
-                ntohs (message->type), ctx->distant->cost,
-                GNUNET_i2s (&ctx->distant->identity));
-#endif
-    GNUNET_assert (memcmp
-                   (ctx->peer, &ctx->distant->identity,
-                    sizeof (struct GNUNET_PeerIdentity)) != 0);
-    send_to_plugin (ctx->peer, message, ntohs (message->size),
-                    &ctx->distant->identity, ctx->distant->cost);
-  }
-  return GNUNET_OK;
-}
-
-#if DELAY_FORWARDS
-struct DelayedMessageContext
-{
-  struct GNUNET_PeerIdentity dest;
-  struct GNUNET_PeerIdentity sender;
-  struct GNUNET_MessageHeader *message;
-  size_t message_size;
-  uint32_t uid;
-};
-
-void
-send_message_delayed (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  struct DelayedMessageContext *msg_ctx = cls;
-
-  if (msg_ctx != NULL)
-  {
-    send_message (&msg_ctx->dest, &msg_ctx->sender, NULL, msg_ctx->message,
-                  msg_ctx->message_size, default_dv_priority, msg_ctx->uid,
-                  GNUNET_TIME_UNIT_FOREVER_REL);
-    GNUNET_free (msg_ctx->message);
-    GNUNET_free (msg_ctx);
-  }
-}
-#endif
-
-/**
- * Find latency information in 'atsi'.
- *
- * @param atsi performance data
- * @param atsi_count number of entries in atsi
- * @return connection latency
- */
-static struct GNUNET_TIME_Relative
-get_atsi_latency (const struct GNUNET_ATS_Information *atsi,
-                  unsigned int atsi_count)
-{
-  unsigned int i;
-
-  for (i = 0; i < atsi_count; i++)
-    if (ntohl (atsi[i].type) == GNUNET_ATS_QUALITY_NET_DELAY)
-      return GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
-                                            ntohl (atsi->value));
-  GNUNET_break (0);
-  /* how can we not have latency data? */
-  return GNUNET_TIME_UNIT_SECONDS;
-}
-
-
-#if DEBUG_DV
-/**
- * Iterator over hash map entries.
- *
- * @param cls closure (NULL)
- * @param key current key code
- * @param value value in the hash map (DistantNeighbor)
- * @return GNUNET_YES if we should continue to
- *         iterate,
- *         GNUNET_NO if not.
- */
-int
-print_neighbors (void *cls, const struct GNUNET_HashCode * key, void *abs_value)
-{
-  struct DistantNeighbor *distant_neighbor = abs_value;
-  char my_shortname[5];
-  char referrer_shortname[5];
-
-  memcpy (&my_shortname, GNUNET_i2s (&my_identity), 4);
-  my_shortname[4] = '\0';
-  memcpy (&referrer_shortname,
-          GNUNET_i2s (&distant_neighbor->referrer->identity), 4);
-  referrer_shortname[4] = '\0';
-
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "`%s' %s: Peer `%s', distance %d, referrer `%s' pkey: %s\n",
-              &my_shortname, "DV", GNUNET_i2s (&distant_neighbor->identity),
-              distant_neighbor->cost, &referrer_shortname,
-              distant_neighbor->pkey == NULL ? "no" : "yes");
-  return GNUNET_YES;
-}
-#endif
-
-/**
- *  Scheduled task which gossips about known direct peers to other connected
- *  peers.  Will run until called with reason shutdown.
- */
-static void
-neighbor_send_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  struct NeighborSendContext *send_context = cls;
-
-#if DEBUG_DV_GOSSIP_SEND
-  char *encPeerAbout;
-  char *encPeerTo;
-#endif
-  struct DistantNeighbor *about;
-  struct DirectNeighbor *to;
-  struct FastGossipNeighborList *about_list;
-
-  p2p_dv_MESSAGE_NeighborInfo *message;
-  struct PendingMessage *pending_message;
-
-  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-  {
-#if DEBUG_DV_GOSSIP
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "%s: Called with reason shutdown, shutting down!\n",
-                GNUNET_i2s (&my_identity));
-#endif
-    return;
-  }
-
-  if (send_context->fast_gossip_list_head != NULL)
-  {
-    about_list = send_context->fast_gossip_list_head;
-    about = about_list->about;
-    GNUNET_CONTAINER_DLL_remove (send_context->fast_gossip_list_head,
-                                 send_context->fast_gossip_list_tail,
-                                 about_list);
-    GNUNET_free (about_list);
-  }
-  else
-  {
-    /* FIXME: this may become a problem, because the heap walk has only one internal "walker".  This means
-     * that if two neighbor_send_tasks are operating in lockstep (which is quite possible, given default
-     * values for all connected peers) there may be a serious bias as to which peers get gossiped about!
-     * Probably the *best* way to fix would be to have an opaque pointer to the walk position passed as
-     * part of the walk_get_next call.  Then the heap would have to keep a list of walks, or reset the walk
-     * whenever a modification has been detected.  Yuck either way.  Perhaps we could iterate over the heap
-     * once to get a list of peers to gossip about and gossip them over time... But then if one goes away
-     * in the mean time that becomes nasty.  For now we'll just assume that the walking is done
-     * asynchronously enough to avoid major problems (-;
-     *
-     * NOTE: probably fixed once we decided send rate based on allowed bandwidth.
-     */
-    about = GNUNET_CONTAINER_heap_walk_get_next (neighbor_min_heap);
-  }
-  to = send_context->toNeighbor;
-
-  if ((about != NULL) && (to != about->referrer /* split horizon */ ) &&
-#if SUPPORT_HIDING
-      (about->hidden == GNUNET_NO) &&
-#endif
-      (to != NULL) &&
-      (0 !=
-       memcmp (&about->identity, &to->identity,
-               sizeof (struct GNUNET_PeerIdentity))) && (about->pkey != NULL))
-  {
-#if DEBUG_DV_GOSSIP_SEND
-    encPeerAbout = GNUNET_strdup (GNUNET_i2s (&about->identity));
-    encPeerTo = GNUNET_strdup (GNUNET_i2s (&to->identity));
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "%s: Sending info about peer %s id %u to directly connected peer %s\n",
-                GNUNET_i2s (&my_identity), encPeerAbout, about->our_id,
-                encPeerTo);
-    GNUNET_free (encPeerAbout);
-    GNUNET_free (encPeerTo);
-#endif
-    about->last_gossip = GNUNET_TIME_absolute_get ();
-    pending_message =
-        GNUNET_malloc (sizeof (struct PendingMessage) +
-                       sizeof (p2p_dv_MESSAGE_NeighborInfo));
-    pending_message->msg = (struct GNUNET_MessageHeader *) &pending_message[1];
-    pending_message->importance = default_dv_priority;
-    pending_message->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-    memcpy (&pending_message->recipient, &to->identity,
-            sizeof (struct GNUNET_PeerIdentity));
-    pending_message->msg_size = sizeof (p2p_dv_MESSAGE_NeighborInfo);
-    message = (p2p_dv_MESSAGE_NeighborInfo *) pending_message->msg;
-    message->header.size = htons (sizeof (p2p_dv_MESSAGE_NeighborInfo));
-    message->header.type = htons (GNUNET_MESSAGE_TYPE_DV_GOSSIP);
-    message->cost = htonl (about->cost);
-    message->neighbor_id = htonl (about->our_id);
-
-    memcpy (&message->pkey, about->pkey,
-            sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded));
-    memcpy (&message->neighbor, &about->identity,
-            sizeof (struct GNUNET_PeerIdentity));
-
-    GNUNET_CONTAINER_DLL_insert_after (core_pending_head, core_pending_tail,
-                                       core_pending_tail, pending_message);
-
-    GNUNET_SCHEDULER_add_now (try_core_send, NULL);
-    /*if (core_transmit_handle == NULL)
-     * core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, GNUNET_YES,  default_dv_priority, GNUNET_TIME_UNIT_FOREVER_REL, &to->identity, sizeof(p2p_dv_MESSAGE_NeighborInfo), &core_transmit_notify, NULL); */
-
-  }
-
-  if (send_context->fast_gossip_list_head != NULL)      /* If there are other peers in the fast list, schedule right away */
-  {
-#if DEBUG_DV_PEER_NUMBERS
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "DV SERVICE: still in fast send mode\n");
-#endif
-    send_context->task =
-        GNUNET_SCHEDULER_add_now (&neighbor_send_task, send_context);
-  }
-  else
-  {
-#if DEBUG_DV_PEER_NUMBERS
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "DV SERVICE: entering slow send mode\n");
-#endif
-    send_context->task =
-        GNUNET_SCHEDULER_add_delayed (GNUNET_DV_DEFAULT_SEND_INTERVAL,
-                                      &neighbor_send_task, send_context);
-  }
-
-  return;
-}
-
-
-
-#if UNSIMPLER
-/**
- * Iterate over hash map entries for a distant neighbor,
- * if direct neighbor matches context call send message
- *
- * @param cls closure, a DV_SendContext
- * @param key current key code
- * @param value value in the hash map
- * @return GNUNET_YES if we should continue to
- *         iterate,
- *         GNUNET_NO if not.
- */
-int
-send_iterator (void *cls, const struct GNUNET_HashCode * key, void *abs_value)
-{
-  struct DV_SendContext *send_context = cls;
-  struct DistantNeighbor *distant_neighbor = abs_value;
-
-  if (memcmp (distant_neighbor->referrer, send_context->direct_peer, sizeof (struct GNUNET_PeerIdentity)) == 0) /* They match, send and free */
-  {
-    send_message_via (&my_identity, distant_neighbor, send_context);
-    return GNUNET_NO;
-  }
-  return GNUNET_YES;
-}
-#endif
-
-
-/** Forward declarations **/
-static int
-handle_dv_gossip_message (void *cls, const struct GNUNET_PeerIdentity *peer,
-                          const struct GNUNET_MessageHeader *message,
-                          const struct GNUNET_ATS_Information *atsi,
-                          unsigned int atsi_count);
-
-static int
-handle_dv_disconnect_message (void *cls, const struct GNUNET_PeerIdentity *peer,
-                              const struct GNUNET_MessageHeader *message,
-                              const struct GNUNET_ATS_Information *atsi,
-                              unsigned int atsi_count);
-/** End forward declarations **/
-
-
-/**
- * Free a DistantNeighbor node, including removing it
- * from the referer's list.
- */
-static void
-distant_neighbor_free (struct DistantNeighbor *referee)
-{
-  struct DirectNeighbor *referrer;
-
-  referrer = referee->referrer;
-  if (referrer != NULL)
-  {
-    GNUNET_CONTAINER_DLL_remove (referrer->referee_head, referrer->referee_tail,
-                                 referee);
-  }
-  GNUNET_CONTAINER_heap_remove_node (referee->max_loc);
-  GNUNET_CONTAINER_heap_remove_node (referee->min_loc);
-  GNUNET_CONTAINER_multihashmap_remove_all (extended_neighbors,
-                                            &referee->identity.hashPubKey);
-  GNUNET_free_non_null (referee->pkey);
-  GNUNET_free (referee);
-}
-
-/**
- * Free a DirectNeighbor node, including removing it
- * from the referer's list.
- */
-static void
-direct_neighbor_free (struct DirectNeighbor *direct)
-{
-  struct NeighborSendContext *send_context;
-  struct FastGossipNeighborList *about_list;
-  struct FastGossipNeighborList *prev_about;
-
-  send_context = direct->send_context;
-
-  if (send_context->task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (send_context->task);
-
-  about_list = send_context->fast_gossip_list_head;
-  while (about_list != NULL)
-  {
-    GNUNET_CONTAINER_DLL_remove (send_context->fast_gossip_list_head,
-                                 send_context->fast_gossip_list_tail,
-                                 about_list);
-    prev_about = about_list;
-    about_list = about_list->next;
-    GNUNET_free (prev_about);
-  }
-  GNUNET_free (send_context);
-  GNUNET_free (direct);
-}
-
-/**
- * Multihashmap iterator for sending out disconnect messages
- * for a peer.
- *
- * @param cls the peer that was disconnected
- * @param key key value stored under
- * @param value the direct neighbor to send disconnect to
- *
- * @return GNUNET_YES to continue iteration, GNUNET_NO to stop
- */
-static int
-schedule_disconnect_messages (void *cls, const struct GNUNET_HashCode * key,
-                              void *value)
-{
-  struct DisconnectContext *disconnect_context = cls;
-  struct DirectNeighbor *disconnected = disconnect_context->direct;
-  struct DirectNeighbor *notify = value;
-  struct PendingMessage *pending_message;
-  p2p_dv_MESSAGE_Disconnect *disconnect_message;
-
-  if (memcmp
-      (&notify->identity, &disconnected->identity,
-       sizeof (struct GNUNET_PeerIdentity)) == 0)
-    return GNUNET_YES;          /* Don't send disconnect message to peer that disconnected! */
-
-  pending_message =
-      GNUNET_malloc (sizeof (struct PendingMessage) +
-                     sizeof (p2p_dv_MESSAGE_Disconnect));
-  pending_message->msg = (struct GNUNET_MessageHeader *) &pending_message[1];
-  pending_message->importance = default_dv_priority;
-  pending_message->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-  memcpy (&pending_message->recipient, &notify->identity,
-          sizeof (struct GNUNET_PeerIdentity));
-  pending_message->msg_size = sizeof (p2p_dv_MESSAGE_Disconnect);
-  disconnect_message = (p2p_dv_MESSAGE_Disconnect *) pending_message->msg;
-  disconnect_message->header.size = htons (sizeof (p2p_dv_MESSAGE_Disconnect));
-  disconnect_message->header.type = htons (GNUNET_MESSAGE_TYPE_DV_DISCONNECT);
-  disconnect_message->peer_id = htonl (disconnect_context->distant->our_id);
-
-  GNUNET_CONTAINER_DLL_insert_after (core_pending_head, core_pending_tail,
-                                     core_pending_tail, pending_message);
-
-  GNUNET_SCHEDULER_add_now (try_core_send, NULL);
-  /*if (core_transmit_handle == NULL)
-   * core_transmit_handle = GNUNET_CORE_notify_transmit_ready(coreAPI, GNUNET_YES, default_dv_priority, GNUNET_TIME_UNIT_FOREVER_REL, &notify->identity, sizeof(p2p_dv_MESSAGE_Disconnect), &core_transmit_notify, NULL); */
-
-  return GNUNET_YES;
-}
-
-
-#if PKEY_NO_NEIGHBOR_ON_ADD
-/**
- * Iterator over hash map entries.
- *
- * @param cls closure
- * @param key current key code
- * @param value value in the hash map
- * @return GNUNET_YES if we should continue to
- *         iterate,
- *         GNUNET_NO if not.
- */
-static int
-add_pkey_to_extended (void *cls, const struct GNUNET_HashCode * key, void *abs_value)
-{
-  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *pkey = cls;
-  struct DistantNeighbor *distant_neighbor = abs_value;
-
-  if (distant_neighbor->pkey == NULL)
-  {
-    distant_neighbor->pkey =
-        GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded));
-    memcpy (distant_neighbor->pkey, pkey,
-            sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded));
-  }
-
-  return GNUNET_YES;
-}
-#endif
-
-/**
- * Iterator over hash map entries.
- *
- * @param cls closure
- * @param key current key code
- * @param value value in the hash map
- * @return GNUNET_YES if we should continue to
- *         iterate,
- *         GNUNET_NO if not.
- */
-static int
-update_matching_neighbors (void *cls, const struct GNUNET_HashCode * key, void *value)
-{
-  struct NeighborUpdateInfo *update_info = cls;
-  struct DistantNeighbor *distant_neighbor = value;
-
-  if (update_info->referrer == distant_neighbor->referrer)      /* Direct neighbor matches, update it's info and return GNUNET_NO */
-  {
-    /* same referrer, cost change! */
-    GNUNET_CONTAINER_heap_update_cost (neighbor_max_heap,
-                                       update_info->neighbor->max_loc,
-                                       update_info->cost);
-    GNUNET_CONTAINER_heap_update_cost (neighbor_min_heap,
-                                       update_info->neighbor->min_loc,
-                                       update_info->cost);
-    update_info->neighbor->last_activity = update_info->now;
-    update_info->neighbor->cost = update_info->cost;
-    update_info->neighbor->referrer_id = update_info->referrer_peer_id;
-    return GNUNET_NO;
-  }
-
-  return GNUNET_YES;
-}
-
-
-/**
- * Iterate over all current direct peers, add DISTANT newly connected
- * peer to the fast gossip list for that peer so we get DV routing
- * information out as fast as possible!
- *
- * @param cls the newly connected neighbor we will gossip about
- * @param key the hashcode of the peer
- * @param value the direct neighbor we should gossip to
- *
- * @return GNUNET_YES to continue iteration, GNUNET_NO otherwise
- */
-static int
-add_distant_all_direct_neighbors (void *cls, const struct GNUNET_HashCode * key,
-                                  void *value)
-{
-  struct DirectNeighbor *direct = (struct DirectNeighbor *) value;
-  struct DistantNeighbor *distant = (struct DistantNeighbor *) cls;
-  struct NeighborSendContext *send_context = direct->send_context;
-  struct FastGossipNeighborList *gossip_entry;
-
-#if DEBUG_DV
-  char *encPeerAbout;
-  char *encPeerTo;
-#endif
-
-  if (distant == NULL)
-  {
-    return GNUNET_YES;
-  }
-
-  if (memcmp
-      (&direct->identity, &distant->identity,
-       sizeof (struct GNUNET_PeerIdentity)) == 0)
-  {
-    return GNUNET_YES;          /* Don't gossip to a peer about itself! */
-  }
-
-#if SUPPORT_HIDING
-  if (distant->hidden == GNUNET_YES)
-    return GNUNET_YES;          /* This peer should not be gossipped about (hidden) */
-#endif
-  gossip_entry = GNUNET_malloc (sizeof (struct FastGossipNeighborList));
-  gossip_entry->about = distant;
-
-  GNUNET_CONTAINER_DLL_insert_after (send_context->fast_gossip_list_head,
-                                     send_context->fast_gossip_list_tail,
-                                     send_context->fast_gossip_list_tail,
-                                     gossip_entry);
-#if DEBUG_DV
-  encPeerAbout = GNUNET_strdup (GNUNET_i2s (&distant->identity));
-  encPeerTo = GNUNET_strdup (GNUNET_i2s (&direct->identity));
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%s: Fast send info about peer %s id %u for directly connected peer %s\n",
-              GNUNET_i2s (&my_identity), encPeerAbout, distant->our_id,
-              encPeerTo);
-  GNUNET_free (encPeerAbout);
-  GNUNET_free (encPeerTo);
-#endif
-  /*if (send_context->task != GNUNET_SCHEDULER_NO_TASK)
-   * GNUNET_SCHEDULER_cancel(send_context->task); */
-
-  send_context->task =
-      GNUNET_SCHEDULER_add_now (&neighbor_send_task, send_context);
-  return GNUNET_YES;
-}
-
-/**
- * Callback for hello address creation.
- *
- * @param cls closure, a struct HelloContext
- * @param max maximum number of bytes that can be written to buf
- * @param buf where to write the address information
- *
- * @return number of bytes written, 0 to signal the
- *         end of the iteration.
- */
-static size_t
-generate_hello_address (void *cls, size_t max, void *buf)
-{
-  struct HelloContext *hello_context = cls;
-  struct GNUNET_HELLO_Address hello_address;
-  char *addr_buffer;
-  size_t offset;
-  size_t size;
-  size_t ret;
-
-  if (hello_context->addresses_to_add == 0)
-    return 0;
-
-  /* Hello "address" will be concatenation of distant peer and direct peer identities */
-  size = 2 * sizeof (struct GNUNET_PeerIdentity);
-  GNUNET_assert (max >= size);
-
-  addr_buffer = GNUNET_malloc (size);
-  offset = 0;
-  /* Copy the distant peer identity to buffer */
-  memcpy (addr_buffer, &hello_context->distant_peer,
-          sizeof (struct GNUNET_PeerIdentity));
-  offset += sizeof (struct GNUNET_PeerIdentity);
-  /* Copy the direct peer identity to buffer */
-  memcpy (&addr_buffer[offset], hello_context->direct_peer,
-          sizeof (struct GNUNET_PeerIdentity));
-  memset (&hello_address.peer, 0, sizeof (struct GNUNET_PeerIdentity));
-  hello_address.address = addr_buffer;
-  hello_address.transport_name = "dv";
-  hello_address.address_length = size;
-  ret =
-      GNUNET_HELLO_add_address (&hello_address,
-                                GNUNET_TIME_relative_to_absolute
-                                (GNUNET_TIME_UNIT_HOURS), buf, max);
-
-  hello_context->addresses_to_add--;
-
-  GNUNET_free (addr_buffer);
-  return ret;
-}
-
-
-/**
- * Handles when a peer is either added due to being newly connected
- * or having been gossiped about, also called when the cost for a neighbor
- * needs to be updated.
- *
- * @param peer identity of the peer whose info is being added/updated
- * @param pkey public key of the peer whose info is being added/updated
- * @param referrer_peer_id id to use when sending to 'peer'
- * @param referrer if this is a gossiped peer, who did we hear it from?
- * @param cost the cost of communicating with this peer via 'referrer'
- *
- * @return the added neighbor, the updated neighbor or NULL (neighbor
- *         not added)
- */
-static struct DistantNeighbor *
-addUpdateNeighbor (const struct GNUNET_PeerIdentity *peer,
-                   struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *pkey,
-                   unsigned int referrer_peer_id,
-                   struct DirectNeighbor *referrer, unsigned int cost)
-{
-  struct DistantNeighbor *neighbor;
-  struct DistantNeighbor *max;
-  struct GNUNET_TIME_Absolute now;
-  struct NeighborUpdateInfo *neighbor_update;
-  struct HelloContext *hello_context;
-  struct GNUNET_HELLO_Message *hello_msg;
-  unsigned int our_id;
-  char *addr1;
-  char *addr2;
-  int i;
-
-#if DEBUG_DV_PEER_NUMBERS
-  char *encAbout;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s Received sender id (%u)!\n",
-              "DV SERVICE", referrer_peer_id);
-#endif
-
-  now = GNUNET_TIME_absolute_get ();
-  neighbor =
-      GNUNET_CONTAINER_multihashmap_get (extended_neighbors, &peer->hashPubKey);
-  neighbor_update = GNUNET_malloc (sizeof (struct NeighborUpdateInfo));
-  neighbor_update->neighbor = neighbor;
-  neighbor_update->cost = cost;
-  neighbor_update->now = now;
-  neighbor_update->referrer = referrer;
-  neighbor_update->referrer_peer_id = referrer_peer_id;
-
-  if (neighbor != NULL)
-  {
-#if USE_PEER_ID
-    memcpy (&our_id, &neighbor->identity, sizeof (unsigned int));
-#else
-    our_id = neighbor->our_id;
-#endif
-  }
-  else
-  {
-#if USE_PEER_ID
-    memcpy (&our_id, peer, sizeof (unsigned int));
-#else
-    our_id =
-        GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG,
-                                  RAND_MAX - 1) + 1;
-#endif
-  }
-
-  /* Either we do not know this peer, or we already do but via a different immediate peer */
-  if ((neighbor == NULL) ||
-      (GNUNET_CONTAINER_multihashmap_get_multiple
-       (extended_neighbors, &peer->hashPubKey, &update_matching_neighbors,
-        neighbor_update) != GNUNET_SYSERR))
-  {
-#if AT_MOST_ONE
-    if ((neighbor != NULL) && (cost < neighbor->cost))  /* New cost is less than old, remove old */
-    {
-      distant_neighbor_free (neighbor);
-    }
-    else if (neighbor != NULL)  /* Only allow one DV connection to each peer */
-    {
-      return NULL;
-    }
-#endif
-    /* new neighbor! */
-    if (cost > fisheye_depth)
-    {
-      /* too costly */
-      GNUNET_free (neighbor_update);
-      return NULL;
-    }
-
-#if DEBUG_DV_PEER_NUMBERS
-    encAbout = GNUNET_strdup (GNUNET_i2s (peer));
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "%s: %s Chose NEW id (%u) for peer %s!\n",
-                GNUNET_i2s (&my_identity), "DV SERVICE", our_id, encAbout);
-    GNUNET_free (encAbout);
-#endif
-
-    if (max_table_size <=
-        GNUNET_CONTAINER_multihashmap_size (extended_neighbors))
-    {
-      /* remove most expensive entry */
-      max = GNUNET_CONTAINER_heap_peek (neighbor_max_heap);
-      GNUNET_assert (max != NULL);
-      if (cost > max->cost)
-      {
-        /* new entry most expensive, don't create */
-        GNUNET_free (neighbor_update);
-        return NULL;
-      }
-      if (max->cost > 1)
-      {
-        /* only free if this is not a direct connection;
-         * we could theoretically have more direct
-         * connections than DV entries allowed total! */
-        distant_neighbor_free (max);
-      }
-    }
-
-    neighbor = GNUNET_malloc (sizeof (struct DistantNeighbor));
-    GNUNET_CONTAINER_DLL_insert (referrer->referee_head, referrer->referee_tail,
-                                 neighbor);
-    neighbor->max_loc =
-        GNUNET_CONTAINER_heap_insert (neighbor_max_heap, neighbor, cost);
-    neighbor->min_loc =
-        GNUNET_CONTAINER_heap_insert (neighbor_min_heap, neighbor, cost);
-    neighbor->referrer = referrer;
-    memcpy (&neighbor->identity, peer, sizeof (struct GNUNET_PeerIdentity));
-    if (pkey != NULL)           /* pkey will be null on direct neighbor addition */
-    {
-      neighbor->pkey =
-          GNUNET_malloc (sizeof
-                         (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded));
-      memcpy (neighbor->pkey, pkey,
-              sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded));
-    }
-    else
-      neighbor->pkey = pkey;
-
-    neighbor->last_activity = now;
-    neighbor->cost = cost;
-    neighbor->referrer_id = referrer_peer_id;
-    neighbor->our_id = our_id;
-    neighbor->hidden =
-        (cost ==
-         DIRECT_NEIGHBOR_COST)
-        ? (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 4) ==
-           0) : GNUNET_NO;
-
-    GNUNET_CONTAINER_multihashmap_put (extended_neighbors, &peer->hashPubKey,
-                                       neighbor,
-                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-    if (referrer_peer_id != 0)
-    {
-      for (i = 0; i < MAX_OUTSTANDING_MESSAGES; i++)
-      {
-        if (referrer->pending_messages[i].sender_id == referrer_peer_id)        /* We have a queued message from just learned about peer! */
-        {
-#if DEBUG_DV_MESSAGES
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "%s: learned about peer %llu from which we have a previous unknown message, processing!\n",
-                      my_short_id, referrer_peer_id);
-#endif
-          struct GNUNET_ATS_Information atsi[2];
-
-          atsi[0].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
-          atsi[0].value = htonl (referrer->pending_messages[i].distance);
-          atsi[1].type = htonl (GNUNET_ATS_QUALITY_NET_DELAY);
-          atsi[1].value =
-              htonl ((uint32_t) referrer->pending_messages[i].
-                     latency.rel_value);
-          handle_dv_data_message (NULL, &referrer->pending_messages[i].sender,
-                                  referrer->pending_messages[i].message, atsi,
-                                  2);
-          GNUNET_free (referrer->pending_messages[i].message);
-          referrer->pending_messages[i].sender_id = 0;
-        }
-      }
-    }
-    if ((cost != DIRECT_NEIGHBOR_COST) && (neighbor->pkey != NULL))
-    {
-      /* Added neighbor, now send HELLO to transport */
-      hello_context = GNUNET_malloc (sizeof (struct HelloContext));
-      hello_context->direct_peer = &referrer->identity;
-      memcpy (&hello_context->distant_peer, peer,
-              sizeof (struct GNUNET_PeerIdentity));
-      hello_context->addresses_to_add = 1;
-      hello_msg =
-          GNUNET_HELLO_create (pkey, &generate_hello_address, hello_context);
-      GNUNET_assert (memcmp
-                     (hello_context->direct_peer, &hello_context->distant_peer,
-                      sizeof (struct GNUNET_PeerIdentity)) != 0);
-      addr1 = GNUNET_strdup (GNUNET_i2s (hello_context->direct_peer));
-      addr2 = GNUNET_strdup (GNUNET_i2s (&hello_context->distant_peer));
-#if DEBUG_DV
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "%s: GIVING HELLO size %d for %s via %s to TRANSPORT\n",
-                  my_short_id, GNUNET_HELLO_size (hello_msg), addr2, addr1);
-#endif
-      GNUNET_free (addr1);
-      GNUNET_free (addr2);
-      send_to_plugin (hello_context->direct_peer,
-                      GNUNET_HELLO_get_header (hello_msg),
-                      GNUNET_HELLO_size (hello_msg),
-                      &hello_context->distant_peer, cost);
-      GNUNET_free (hello_context);
-      GNUNET_free (hello_msg);
-    }
-
-  }
-  else
-  {
-#if DEBUG_DV_GOSSIP
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "%s: Already know peer %s distance %d, referrer id %d!\n", "dv",
-                GNUNET_i2s (peer), cost, referrer_peer_id);
-#endif
-  }
-#if DEBUG_DV
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s: Size of extended_neighbors is %d\n",
-              "dv", GNUNET_CONTAINER_multihashmap_size (extended_neighbors));
-#endif
-
-  GNUNET_free (neighbor_update);
-  return neighbor;
-}
-
-
-/**
- * Core handler for dv disconnect messages.  These will be used
- * by us to tell transport via the dv plugin that a peer can
- * no longer be contacted by us via a certain address.  We should
- * then propagate these messages on, given that the distance to
- * the peer indicates we would have gossiped about it to others.
- *
- * @param cls closure
- * @param peer peer which sent the message (immediate sender)
- * @param message the message
- * @param atsi performance data
- * @param atsi_count number of entries in atsi
- */
-static int
-handle_dv_disconnect_message (void *cls, const struct GNUNET_PeerIdentity *peer,
-                              const struct GNUNET_MessageHeader *message,
-                              const struct GNUNET_ATS_Information *atsi,
-                              unsigned int atsi_count)
-{
-  struct DirectNeighbor *referrer;
-  struct DistantNeighbor *distant;
-  p2p_dv_MESSAGE_Disconnect *enc_message =
-      (p2p_dv_MESSAGE_Disconnect *) message;
-
-  if (ntohs (message->size) < sizeof (p2p_dv_MESSAGE_Disconnect))
-  {
-    return GNUNET_SYSERR;       /* invalid message */
-  }
-
-  referrer =
-      GNUNET_CONTAINER_multihashmap_get (direct_neighbors, &peer->hashPubKey);
-  if (referrer == NULL)
-    return GNUNET_OK;
-
-  distant = referrer->referee_head;
-  while (distant != NULL)
-  {
-    if (distant->referrer_id == ntohl (enc_message->peer_id))
-    {
-      distant_neighbor_free (distant);
-      distant = referrer->referee_head;
-    }
-    else
-      distant = distant->next;
-  }
-
-  return GNUNET_OK;
-}
-
-
-/**
- * Iterate over all currently known peers, add them to the
- * fast gossip list for this peer so we get DV routing information
- * out as fast as possible!
- *
- * @param cls the direct neighbor we will gossip to
- * @param key the hashcode of the peer
- * @param value the distant neighbor we should add to the list
- *
- * @return GNUNET_YES to continue iteration, GNUNET_NO otherwise
- */
-static int
-add_all_extended_peers (void *cls, const struct GNUNET_HashCode * key, void *value)
-{
-  struct NeighborSendContext *send_context = (struct NeighborSendContext *) cls;
-  struct DistantNeighbor *distant = (struct DistantNeighbor *) value;
-  struct FastGossipNeighborList *gossip_entry;
-
-  if (memcmp
-      (&send_context->toNeighbor->identity, &distant->identity,
-       sizeof (struct GNUNET_PeerIdentity)) == 0)
-    return GNUNET_YES;          /* Don't gossip to a peer about itself! */
-
-#if SUPPORT_HIDING
-  if (distant->hidden == GNUNET_YES)
-    return GNUNET_YES;          /* This peer should not be gossipped about (hidden) */
-#endif
-  gossip_entry = GNUNET_malloc (sizeof (struct FastGossipNeighborList));
-  gossip_entry->about = distant;
-
-  GNUNET_CONTAINER_DLL_insert_after (send_context->fast_gossip_list_head,
-                                     send_context->fast_gossip_list_tail,
-                                     send_context->fast_gossip_list_tail,
-                                     gossip_entry);
-
-  return GNUNET_YES;
-}
-
-
-/**
- * Iterate over all current direct peers, add newly connected peer
- * to the fast gossip list for that peer so we get DV routing
- * information out as fast as possible!
- *
- * @param cls the newly connected neighbor we will gossip about
- * @param key the hashcode of the peer
- * @param value the direct neighbor we should gossip to
- *
- * @return GNUNET_YES to continue iteration, GNUNET_NO otherwise
- */
-static int
-add_all_direct_neighbors (void *cls, const struct GNUNET_HashCode * key, void *value)
-{
-  struct DirectNeighbor *direct = (struct DirectNeighbor *) value;
-  struct DirectNeighbor *to = (struct DirectNeighbor *) cls;
-  struct DistantNeighbor *distant;
-  struct NeighborSendContext *send_context = direct->send_context;
-  struct FastGossipNeighborList *gossip_entry;
-  char *direct_id;
-
-
-  distant =
-      GNUNET_CONTAINER_multihashmap_get (extended_neighbors,
-                                         &to->identity.hashPubKey);
-  if (distant == NULL)
-  {
-    return GNUNET_YES;
-  }
-
-  if (memcmp
-      (&direct->identity, &to->identity,
-       sizeof (struct GNUNET_PeerIdentity)) == 0)
-  {
-    return GNUNET_YES;          /* Don't gossip to a peer about itself! */
-  }
-
-#if SUPPORT_HIDING
-  if (distant->hidden == GNUNET_YES)
-    return GNUNET_YES;          /* This peer should not be gossipped about (hidden) */
-#endif
-  direct_id = GNUNET_strdup (GNUNET_i2s (&direct->identity));
-#if DEBUG_DV_GOSSIP
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "%s: adding peer %s to fast send list for %s\n", my_short_id,
-              GNUNET_i2s (&distant->identity), direct_id);
-#endif
-  GNUNET_free (direct_id);
-  gossip_entry = GNUNET_malloc (sizeof (struct FastGossipNeighborList));
-  gossip_entry->about = distant;
-
-  GNUNET_CONTAINER_DLL_insert_after (send_context->fast_gossip_list_head,
-                                     send_context->fast_gossip_list_tail,
-                                     send_context->fast_gossip_list_tail,
-                                     gossip_entry);
-  if (send_context->task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (send_context->task);
-
-  send_context->task =
-      GNUNET_SCHEDULER_add_now (&neighbor_send_task, send_context);
-  //tc.reason = GNUNET_SCHEDULER_REASON_TIMEOUT;
-  //neighbor_send_task(send_context, &tc);
-  return GNUNET_YES;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-#endif
-
-
-
 /**
  * Method called whenever a peer connects.
  *
@@ -2168,7 +892,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
      GNUNET_MESSAGE_TYPE_DV_START, 
      sizeof (struct GNUNET_MessageHeader) },
     { &handle_dv_send_message, NULL, 
-      GNUNET_MESSAGE_TYPE_TRANSPORT_DV_SEND, 
+      GNUNET_MESSAGE_TYPE_DV_SEND, 
       0},
     {NULL, NULL, 0, 0}
   };