[GNUnet-SVN] r24862 - in gnunet/src: core dht include testbed testing_old topology transport

[gnunet]

Author: wachs
Date: 2012-11-09 14:33:40 +0100 (Fri, 09 Nov 2012)
New Revision: 24862

Modified:
   gnunet/src/core/test_core_api.c
   gnunet/src/core/test_core_api_reliability.c
   gnunet/src/core/test_core_quota_compliance.c
   gnunet/src/dht/gnunet-service-dht_neighbours.c
   gnunet/src/include/gnunet_transport_service.h
   gnunet/src/testbed/gnunet-service-testbed.c
   gnunet/src/testing_old/testing.c
   gnunet/src/topology/gnunet-daemon-topology.c
   gnunet/src/transport/gnunet-transport.c
   gnunet/src/transport/test_transport_api_restart_1peer.c
   gnunet/src/transport/test_transport_api_restart_2peers.c
   gnunet/src/transport/transport-testing.c
   gnunet/src/transport/transport_api.c
Log:
changes to transport api

Modified: gnunet/src/core/test_core_api.c
===================================================================
--- gnunet/src/core/test_core_api.c     2012-11-09 12:34:17 UTC (rev 24861)
+++ gnunet/src/core/test_core_api.c     2012-11-09 13:33:40 UTC (rev 24862)
@@ -267,7 +267,7 @@
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Asking transport (1) to connect to peer `%4s'\n",
               GNUNET_i2s (&p2.id));
-  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id);
+  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id, NULL, NULL); /*FIXME 
TRY_CONNECT change */
 }
 
 

Modified: gnunet/src/core/test_core_api_reliability.c
===================================================================
--- gnunet/src/core/test_core_api_reliability.c 2012-11-09 12:34:17 UTC (rev 
24861)
+++ gnunet/src/core/test_core_api_reliability.c 2012-11-09 13:33:40 UTC (rev 
24862)
@@ -174,7 +174,7 @@
   connect_task =
       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &try_connect,
                                     NULL);
-  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id);
+  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id, NULL, NULL); /*FIXME 
TRY_CONNECT change */
 }
 
 

Modified: gnunet/src/core/test_core_quota_compliance.c
===================================================================
--- gnunet/src/core/test_core_quota_compliance.c        2012-11-09 12:34:17 UTC 
(rev 24861)
+++ gnunet/src/core/test_core_quota_compliance.c        2012-11-09 13:33:40 UTC 
(rev 24862)
@@ -189,8 +189,8 @@
   connect_task =
       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &try_connect,
                                     NULL);
-  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id);
-  GNUNET_TRANSPORT_try_connect (p2.th, &p1.id);
+  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id, NULL, NULL); /*FIXME 
TRY_CONNECT change */
+  GNUNET_TRANSPORT_try_connect (p2.th, &p1.id, NULL, NULL); /*FIXME 
TRY_CONNECT change */
 }
 
 /**

Modified: gnunet/src/dht/gnunet-service-dht_neighbours.c
===================================================================
--- gnunet/src/dht/gnunet-service-dht_neighbours.c      2012-11-09 12:34:17 UTC 
(rev 24861)
+++ gnunet/src/dht/gnunet-service-dht_neighbours.c      2012-11-09 13:33:40 UTC 
(rev 24862)
@@ -1948,7 +1948,7 @@
           GNUNET_TRANSPORT_offer_hello (GDS_transport_handle, h, NULL, NULL);
          if (GNUNET_YES !=
              disable_try_connect)
-           GNUNET_TRANSPORT_try_connect (GDS_transport_handle, &pid);
+           GNUNET_TRANSPORT_try_connect (GDS_transport_handle, &pid, NULL, 
NULL); /*FIXME TRY_CONNECT change */
         }
       }
     }

Modified: gnunet/src/include/gnunet_transport_service.h
===================================================================
--- gnunet/src/include/gnunet_transport_service.h       2012-11-09 12:34:17 UTC 
(rev 24861)
+++ gnunet/src/include/gnunet_transport_service.h       2012-11-09 13:33:40 UTC 
(rev 24862)
@@ -99,6 +99,18 @@
 
 
 /**
+ * Function to call with result of the try connect request.
+ *
+ *
+ * @param cls closure
+ * @param result GNUNET_OK if message was transmitted to transport service
+ *               GNUNET_SYSERR if message was not transmitted to transport 
service
+ */
+typedef void (*GNUNET_TRANSPORT_TryConnectCallback) (void *cls,
+                                                     const int result);
+
+
+/**
  * Function to call with a textual representation of an address.
  * This function will be called several times with different possible
  * textual representations, and a last time with NULL to signal the end
@@ -159,21 +171,39 @@
 
 
 /**
+ * Opaque handle for a transmission-ready request.
+ */
+struct GNUNET_TRANSPORT_TryConnectHandle;
+
+
+/**
  * Ask the transport service to establish a connection to
  * the given peer.
  *
  * @param handle connection to transport service
  * @param target who we should try to connect to
- * @return GNUNET_OK if request can be scheduled
- *         GNUNET_NO please retry later because we are reconnecting
- *         GNUNET_SYSERR on failure
+ * @param cb callback to be called when request was transmitted to transport
+ *         service
+ * @return a GNUNET_TRANSPORT_TryConnectHandle handle or
+ *         NULL on failure (cb will not be called)
  */
-int
+struct GNUNET_TRANSPORT_TryConnectHandle *
 GNUNET_TRANSPORT_try_connect (struct GNUNET_TRANSPORT_Handle *handle,
-                              const struct GNUNET_PeerIdentity *target);
+                              const struct GNUNET_PeerIdentity *target,
+                              GNUNET_TRANSPORT_TryConnectCallback cb,
+                              void *cb_cls);
 
 
 /**
+ * Cancel the request to transport to try a connect
+ * Callback will not be called
+ *
+ * @param tch GNUNET_TRANSPORT_TryConnectHandle handle to cancel
+ */
+void
+GNUNET_TRANSPORT_try_connect_cancel (struct GNUNET_TRANSPORT_TryConnectHandle 
*tch);
+
+/**
  * Opaque handle for a transmission-ready request.
  */
 struct GNUNET_TRANSPORT_TransmitHandle;
@@ -255,7 +285,7 @@
 /**
  * Stop receiving updates about changes to our HELLO message.
  *
- * @param ghh handle returned from 'GNUNET_TRANSPORT_get_hello')
+ * @param ghh handle to cancel
  */
 void
 GNUNET_TRANSPORT_get_hello_cancel (struct GNUNET_TRANSPORT_GetHelloHandle 
*ghh);
@@ -270,14 +300,24 @@
  * @param hello the hello message
  * @param cont continuation to call when HELLO has been sent
  * @param cls closure for continuation
+ * @return a GNUNET_TRANSPORT_OfferHelloHandle handle or NULL on failure
+ *
  */
-void
+struct GNUNET_TRANSPORT_OfferHelloHandle *
 GNUNET_TRANSPORT_offer_hello (struct GNUNET_TRANSPORT_Handle *handle,
                               const struct GNUNET_MessageHeader *hello,
                               GNUNET_SCHEDULER_Task cont, void *cls);
 
 
 /**
+ * Cancel the request to transport to offer the HELLO message
+ *
+ * @param ohh the GNUNET_TRANSPORT_OfferHelloHandle to cancel
+ */
+void
+GNUNET_TRANSPORT_offer_hello_cancel (struct GNUNET_TRANSPORT_OfferHelloHandle 
*ohh);
+
+/**
  * Handle to cancel a pending address lookup.
  */
 struct GNUNET_TRANSPORT_AddressToStringContext;

Modified: gnunet/src/testbed/gnunet-service-testbed.c
===================================================================
--- gnunet/src/testbed/gnunet-service-testbed.c 2012-11-09 12:34:17 UTC (rev 
24861)
+++ gnunet/src/testbed/gnunet-service-testbed.c 2012-11-09 13:33:40 UTC (rev 
24862)
@@ -2964,7 +2964,7 @@
 
     /* FIXME: once offer_hello offers a handle to cancel remove the following 
lines */
     GNUNET_TRANSPORT_offer_hello (occ->p2th, occ->hello, NULL, NULL);
-    GNUNET_TRANSPORT_try_connect (occ->p2th, &occ->peer_identity);
+    GNUNET_TRANSPORT_try_connect (occ->p2th, &occ->peer_identity, NULL, NULL); 
/*FIXME TRY_CONNECT change */
     occ->send_hello_task =
         GNUNET_SCHEDULER_add_delayed
         (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
@@ -3518,7 +3518,7 @@
 
   rocc->attempt_connect_task_id = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_TRANSPORT_offer_hello (rocc->th, rocc->hello, NULL, NULL);
-  GNUNET_TRANSPORT_try_connect (rocc->th, &rocc->a_id);
+  GNUNET_TRANSPORT_try_connect (rocc->th, &rocc->a_id, NULL, NULL); /*FIXME 
TRY_CONNECT change */
   rocc->attempt_connect_task_id = 
       GNUNET_SCHEDULER_add_delayed 
       (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,

Modified: gnunet/src/testing_old/testing.c
===================================================================
--- gnunet/src/testing_old/testing.c    2012-11-09 12:34:17 UTC (rev 24861)
+++ gnunet/src/testing_old/testing.c    2012-11-09 13:33:40 UTC (rev 24862)
@@ -1860,7 +1860,7 @@
                 "Sending connect request to TRANSPORT of %s for peer %s\n",
                 GNUNET_i2s (&ctx->d1->id),
                 GNUNET_h2s (&ctx->d2->id.hashPubKey));
-    GNUNET_TRANSPORT_try_connect (ctx->d1th, &ctx->d2->id);
+    GNUNET_TRANSPORT_try_connect (ctx->d1th, &ctx->d2->id, NULL, NULL); 
/*FIXME TRY_CONNECT change */
     ctx->timeout_hello =
         GNUNET_TIME_relative_add (ctx->timeout_hello,
                                   GNUNET_TIME_relative_multiply
@@ -1887,7 +1887,7 @@
 
   if (connect_ctx->send_hello == GNUNET_NO)
   {
-    GNUNET_TRANSPORT_try_connect (connect_ctx->d1th, &connect_ctx->d2->id);
+    GNUNET_TRANSPORT_try_connect (connect_ctx->d1th, &connect_ctx->d2->id, 
NULL, NULL); /*FIXME TRY_CONNECT change */
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Sending connect request to TRANSPORT of %s for peer %s\n",
                 connect_ctx->d1->shortname, connect_ctx->d2->shortname);
@@ -2012,7 +2012,7 @@
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to reconnect %s to %s\n",
                 ctx->d1->shortname, ctx->d2->shortname);
-    GNUNET_TRANSPORT_try_connect (ctx->d1th, &ctx->d2->id);
+    GNUNET_TRANSPORT_try_connect (ctx->d1th, &ctx->d2->id, NULL, NULL); 
/*FIXME TRY_CONNECT change */
   }
   ctx->timeout_task =
       GNUNET_SCHEDULER_add_delayed (ctx->relative_timeout,

Modified: gnunet/src/topology/gnunet-daemon-topology.c
===================================================================
--- gnunet/src/topology/gnunet-daemon-topology.c        2012-11-09 12:34:17 UTC 
(rev 24861)
+++ gnunet/src/topology/gnunet-daemon-topology.c        2012-11-09 13:33:40 UTC 
(rev 24862)
@@ -386,7 +386,7 @@
                             gettext_noop
                             ("# connect requests issued to transport"), 1,
                             GNUNET_NO);
-  GNUNET_TRANSPORT_try_connect (transport, &pos->pid);
+  GNUNET_TRANSPORT_try_connect (transport, &pos->pid, NULL, NULL); /*FIXME 
TRY_CONNECT change */
 }
 
 

Modified: gnunet/src/transport/gnunet-transport.c
===================================================================
--- gnunet/src/transport/gnunet-transport.c     2012-11-09 12:34:17 UTC (rev 
24861)
+++ gnunet/src/transport/gnunet-transport.c     2012-11-09 13:33:40 UTC (rev 
24862)
@@ -752,7 +752,7 @@
         ret = 1;
         return;
     }
-    GNUNET_TRANSPORT_try_connect (handle, &pid);
+    GNUNET_TRANSPORT_try_connect (handle, &pid, NULL, NULL); /*FIXME 
TRY_CONNECT change */
     op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT,
                                                &operation_timeout, NULL);
 
@@ -776,7 +776,7 @@
         ret = 1;
         return;
     }
-    GNUNET_TRANSPORT_try_connect (handle, &pid);
+    GNUNET_TRANSPORT_try_connect (handle, &pid, NULL, NULL); /*FIXME 
TRY_CONNECT change */
     start_time = GNUNET_TIME_absolute_get ();
     op_timeout = GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT,
                                                &operation_timeout, NULL);

Modified: gnunet/src/transport/test_transport_api_restart_1peer.c
===================================================================
--- gnunet/src/transport/test_transport_api_restart_1peer.c     2012-11-09 
12:34:17 UTC (rev 24861)
+++ gnunet/src/transport/test_transport_api_restart_1peer.c     2012-11-09 
13:33:40 UTC (rev 24862)
@@ -146,7 +146,7 @@
 
   reconnect_task = GNUNET_SCHEDULER_NO_TASK;
 
-  GNUNET_TRANSPORT_try_connect (p->th, &p2->id);
+  GNUNET_TRANSPORT_try_connect (p->th, &p2->id, NULL, NULL); /*FIXME 
TRY_CONNECT change */
   reconnect_task =
       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &reconnect, p);
 }

Modified: gnunet/src/transport/test_transport_api_restart_2peers.c
===================================================================
--- gnunet/src/transport/test_transport_api_restart_2peers.c    2012-11-09 
12:34:17 UTC (rev 24861)
+++ gnunet/src/transport/test_transport_api_restart_2peers.c    2012-11-09 
13:33:40 UTC (rev 24862)
@@ -138,7 +138,7 @@
   struct PeerContext *p = cls;
 
   reconnect_task = GNUNET_SCHEDULER_NO_TASK;
-  GNUNET_TRANSPORT_try_connect (p1->th, &p2->id);
+  GNUNET_TRANSPORT_try_connect (p1->th, &p2->id, NULL, NULL); /*FIXME 
TRY_CONNECT change */
   reconnect_task =
       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &reconnect, p);
 }

Modified: gnunet/src/transport/transport-testing.c
===================================================================
--- gnunet/src/transport/transport-testing.c    2012-11-09 12:34:17 UTC (rev 
24861)
+++ gnunet/src/transport/transport-testing.c    2012-11-09 13:33:40 UTC (rev 
24862)
@@ -208,7 +208,7 @@
   GNUNET_TRANSPORT_offer_hello (cc->th_p1,
                                 (const struct GNUNET_MessageHeader *) cc->
                                 p2->hello, NULL, NULL);
-  GNUNET_TRANSPORT_try_connect (cc->th_p1, &p2->id);
+  GNUNET_TRANSPORT_try_connect (cc->th_p1, &p2->id, NULL, NULL); /*FIXME 
TRY_CONNECT change */
 
   cc->tct =
       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &try_connect, 
cc);

Modified: gnunet/src/transport/transport_api.c
===================================================================
--- gnunet/src/transport/transport_api.c        2012-11-09 12:34:17 UTC (rev 
24861)
+++ gnunet/src/transport/transport_api.c        2012-11-09 13:33:40 UTC (rev 
24862)
@@ -187,8 +187,43 @@
 
 };
 
+/**
+ * Linked list for all try-connect requests
+ */
+struct GNUNET_TRANSPORT_TryConnectHandle
+{
+  struct GNUNET_TRANSPORT_TryConnectHandle *prev;
+  struct GNUNET_TRANSPORT_TryConnectHandle *next;
 
+  struct GNUNET_PeerIdentity pid;
+
+  struct GNUNET_TRANSPORT_Handle *th;
+  struct GNUNET_TRANSPORT_TransmitHandle *tth;
+  GNUNET_TRANSPORT_TryConnectCallback cb;
+  void *cb_cls;
+};
+
+
 /**
+ * Linked list for all try-connect requests
+ */
+struct GNUNET_TRANSPORT_OfferHelloHandle
+{
+  struct GNUNET_TRANSPORT_OfferHelloHandle *prev;
+  struct GNUNET_TRANSPORT_OfferHelloHandle *next;
+
+  struct GNUNET_TRANSPORT_Handle *th;
+
+  struct GNUNET_TRANSPORT_TransmitHandle *tth;
+  GNUNET_SCHEDULER_Task cont;
+
+  void *cls;
+
+  struct GNUNET_MessageHeader *msg;
+};
+
+
+/**
  * Handle for the transport service (includes all of the
  * state for the transport service).
  */
@@ -252,6 +287,26 @@
   struct GNUNET_TRANSPORT_GetHelloHandle *hwl_tail;
 
   /**
+   * Linked list of pending try connect requests head
+   */
+  struct GNUNET_TRANSPORT_TryConnectHandle *tc_head;
+
+  /**
+   * Linked list of pending try connect requests tail
+   */
+  struct GNUNET_TRANSPORT_TryConnectHandle *tc_tail;
+
+  /**
+   * Linked list of pending offer HELLO requests head
+   */
+  struct GNUNET_TRANSPORT_OfferHelloHandle *oh_head;
+
+  /**
+   * Linked list of pending offer HELLO requests tail
+   */
+  struct GNUNET_TRANSPORT_OfferHelloHandle *oh_tail;
+
+  /**
    * My configuration.
    */
   const struct GNUNET_CONFIGURATION_Handle *cfg;
@@ -306,6 +361,7 @@
 };
 
 
+
 /**
  * Schedule the task to send one message, either from the control
  * list or the peer message queues  to the service.
@@ -830,8 +886,9 @@
  * @param size number of bytes to be transmitted
  * @param notify function to call to get the content
  * @param notify_cls closure for notify
+ * @return a GNUNET_TRANSPORT_TransmitHandle
  */
-static void
+static struct GNUNET_TRANSPORT_TransmitHandle *
 schedule_control_transmit (struct GNUNET_TRANSPORT_Handle *h, size_t size,
                            GNUNET_CONNECTION_TransmitReadyNotify notify,
                            void *notify_cls)
@@ -846,6 +903,7 @@
   th->notify_size = size;
   GNUNET_CONTAINER_DLL_insert_tail (h->control_head, h->control_tail, th);
   schedule_transmission (h);
+  return th;
 }
 
 
@@ -961,6 +1019,26 @@
 
 
 /**
+ * Cancel control request for transmission to the transport service.
+ *
+ * @param th handle to the transport service
+ * @param tth transmit handle to cancel
+ */
+static void
+cancel_control_transmit (struct GNUNET_TRANSPORT_Handle *th, struct 
GNUNET_TRANSPORT_TransmitHandle *tth)
+{
+  GNUNET_assert (NULL != th);
+  GNUNET_assert (NULL != tth);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Canceling transmit of contral transmission 
requested\n");
+
+  GNUNET_CONTAINER_DLL_remove (th->control_head, th->control_tail, tth);
+  GNUNET_free (tth);
+}
+
+
+
+/**
  * Send REQUEST_CONNECT message to the service.
  *
  * @param cls the 'struct GNUNET_PeerIdentity'
@@ -971,24 +1049,30 @@
 static size_t
 send_try_connect (void *cls, size_t size, void *buf)
 {
-  struct GNUNET_PeerIdentity *pid = cls;
+  struct GNUNET_TRANSPORT_TryConnectHandle *tch = cls;
   struct TransportRequestConnectMessage msg;
 
   if (buf == NULL)
   {
-    GNUNET_free (pid);
+    if (NULL != tch->cb)
+      tch->cb (tch->cb_cls, GNUNET_SYSERR);
+    GNUNET_CONTAINER_DLL_remove (tch->th->tc_head, tch->th->tc_tail, tch);
+    GNUNET_free (tch);
     return 0;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Transmitting `%s' request with respect to `%4s'.\n", "REQUEST_CONNECT",
-       GNUNET_i2s (pid));
+       GNUNET_i2s (&tch->pid));
   GNUNET_assert (size >= sizeof (struct TransportRequestConnectMessage));
   msg.header.size = htons (sizeof (struct TransportRequestConnectMessage));
   msg.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_CONNECT);
   msg.reserved = htonl (0);
-  msg.peer = *pid;
+  msg.peer = tch->pid;
   memcpy (buf, &msg, sizeof (msg));
-  GNUNET_free (pid);
+  if (NULL != tch->cb)
+    tch->cb (tch->cb_cls, GNUNET_OK);
+  GNUNET_CONTAINER_DLL_remove (tch->th->tc_head, tch->th->tc_tail, tch);
+  GNUNET_free (tch);
   return sizeof (struct TransportRequestConnectMessage);
 }
 
@@ -998,41 +1082,53 @@
  *
  * @param handle connection to transport service
  * @param target who we should try to connect to
- * @return GNUNET_OK if request can be scheduled
- *         GNUNET_NO please retry later because we are reconnecting
- *         GNUNET_SYSERR on failure
+ * @param cb callback to be called when request was transmitted to transport
+ *         service
+ * @return a GNUNET_TRANSPORT_TryConnectHandle handle or
+ *         NULL on failure (cb will not be called)
  */
-int
+struct GNUNET_TRANSPORT_TryConnectHandle *
 GNUNET_TRANSPORT_try_connect (struct GNUNET_TRANSPORT_Handle *handle,
-                              const struct GNUNET_PeerIdentity *target)
+                              const struct GNUNET_PeerIdentity *target,
+                              GNUNET_TRANSPORT_TryConnectCallback cb,
+                              void *cb_cls)
 {
-  struct GNUNET_PeerIdentity *pid;
+  struct GNUNET_TRANSPORT_TryConnectHandle *tch = NULL;
+
   if (NULL == handle->client)
-  {
-    if (GNUNET_SCHEDULER_NO_TASK == handle->reconnect_task)
-      return GNUNET_SYSERR; /* this should never happen */
-    else
-      return GNUNET_NO; /* please retry */
-  }
+      return NULL;
 
-  pid = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
-  *pid = *target;
-  schedule_control_transmit (handle,
+  tch = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_TryConnectHandle));
+  tch->th = handle;
+  tch->pid = *(target);
+  tch->cb = cb;
+  tch->cb_cls = cb_cls;
+  tch->tth = schedule_control_transmit (handle,
                              sizeof (struct TransportRequestConnectMessage),
-                             &send_try_connect, pid);
-  return GNUNET_OK;
+                             &send_try_connect, tch);
+  GNUNET_CONTAINER_DLL_insert(handle->tc_head, handle->tc_tail, tch);
+  return tch;
 }
 
 
-struct SendHelloContext
+/**
+ * Cancel the request to transport to try a connect
+ * Callback will not be called
+ *
+ * @param tch GNUNET_TRANSPORT_TryConnectHandle handle to cancel
+ */
+void
+GNUNET_TRANSPORT_try_connect_cancel (struct GNUNET_TRANSPORT_TryConnectHandle 
*tch)
 {
-       GNUNET_SCHEDULER_Task cont;
+  struct GNUNET_TRANSPORT_Handle *th;
+  GNUNET_assert (NULL != tch);
 
-       void *cls;
+  th = tch->th;
+  cancel_control_transmit (th, tch->tth);
+  GNUNET_CONTAINER_DLL_remove (th->tc_head, th->tc_tail, tch);
+  GNUNET_free (tch);
+}
 
-       struct GNUNET_MessageHeader *msg;
-};
-
 /**
  * Send HELLO message to the service.
  *
@@ -1044,8 +1140,8 @@
 static size_t
 send_hello (void *cls, size_t size, void *buf)
 {
-  struct SendHelloContext *shc = cls;
-  struct GNUNET_MessageHeader *msg = shc->msg;
+  struct GNUNET_TRANSPORT_OfferHelloHandle *ohh = cls;
+  struct GNUNET_MessageHeader *msg = ohh->msg;
   uint16_t ssize;
   struct GNUNET_SCHEDULER_TaskContext tc;
   tc.read_ready = NULL;
@@ -1056,10 +1152,11 @@
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Timeout while trying to transmit `%s' request.\n", "HELLO");
-    if (NULL != shc->cont)
-      shc->cont (shc->cls, &tc);
+    if (NULL != ohh->cont)
+      ohh->cont (ohh->cls, &tc);
     GNUNET_free (msg);
-    GNUNET_free (shc);
+    GNUNET_CONTAINER_DLL_remove (ohh->th->oh_head, ohh->th->oh_tail, ohh);
+    GNUNET_free (ohh);
     return 0;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Transmitting `%s' request.\n", "HELLO");
@@ -1068,9 +1165,10 @@
   memcpy (buf, msg, ssize);
   GNUNET_free (msg);
   tc.reason = GNUNET_SCHEDULER_REASON_READ_READY;
-  if (NULL != shc->cont)
-    shc->cont (shc->cls, &tc);
-  GNUNET_free (shc);
+  if (NULL != ohh->cont)
+    ohh->cont (ohh->cls, &tc);
+  GNUNET_CONTAINER_DLL_remove (ohh->th->oh_head, ohh->th->oh_tail, ohh);
+  GNUNET_free (ohh);
   return ssize;
 }
 
@@ -1086,29 +1184,26 @@
  *     tc reason GNUNET_SCHEDULER_REASON_TIMEOUT for fail
  *     tc reasong GNUNET_SCHEDULER_REASON_READ_READY for success
  * @param cls closure for continuation
+ * @return a GNUNET_TRANSPORT_OfferHelloHandle handle or NULL on failure,
+ *      in case of failure cont will not be called
  *
  */
-void
+struct GNUNET_TRANSPORT_OfferHelloHandle *
 GNUNET_TRANSPORT_offer_hello (struct GNUNET_TRANSPORT_Handle *handle,
                               const struct GNUNET_MessageHeader *hello,
                               GNUNET_SCHEDULER_Task cont, void *cls)
 {
+  struct GNUNET_TRANSPORT_OfferHelloHandle *ohh;
+  struct GNUNET_MessageHeader *msg;
+  struct GNUNET_PeerIdentity peer;
   uint16_t size;
-  struct GNUNET_PeerIdentity peer;
-  struct GNUNET_MessageHeader *msg;
-  struct SendHelloContext * shc;
-  struct GNUNET_SCHEDULER_TaskContext tc;
 
-  tc.read_ready = NULL;
-  tc.write_ready = NULL;
-  tc.reason = GNUNET_SCHEDULER_REASON_TIMEOUT;
+  GNUNET_assert (NULL != handle);
+  GNUNET_assert (NULL != hello);
 
   if (NULL == handle->client)
-  {
-    if (NULL != cont)
-      cont (cls, &tc);
-    return;
-  }
+    return NULL;
+
   GNUNET_break (ntohs (hello->type) == GNUNET_MESSAGE_TYPE_HELLO);
   size = ntohs (hello->size);
   GNUNET_break (size >= sizeof (struct GNUNET_MessageHeader));
@@ -1116,25 +1211,46 @@
       GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) hello, &peer))
   {
     GNUNET_break (0);
-    if (NULL != cont)
-      if (NULL != cont)
-        cont (cls, &tc);
-    return;
+    return NULL;
   }
+
   msg = GNUNET_malloc (size);
   memcpy (msg, hello, size);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Offering `%s' message of `%4s' to transport for validation.\n", 
"HELLO",
        GNUNET_i2s (&peer));
-  shc = GNUNET_malloc (sizeof (struct SendHelloContext));
-  shc->msg = msg;
-  shc->cont = cont;
-  shc->cls = cls;
-  schedule_control_transmit (handle, size, &send_hello, shc);
+
+  ohh = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_OfferHelloHandle));
+  ohh->th = handle;
+  ohh->cont = cont;
+  ohh->cls = cls;
+  ohh->msg = msg;
+  ohh->tth = schedule_control_transmit (handle, size, &send_hello, ohh);
+  GNUNET_CONTAINER_DLL_insert (handle->oh_head, handle->oh_tail, ohh);
+  return ohh;
 }
 
 
 /**
+ * Cancel the request to transport to offer the HELLO message
+ *
+ * @param ohh the GNUNET_TRANSPORT_OfferHelloHandle to cancel
+ */
+void
+GNUNET_TRANSPORT_offer_hello_cancel (struct GNUNET_TRANSPORT_OfferHelloHandle 
*ohh)
+{
+  struct GNUNET_TRANSPORT_Handle *th = ohh->th;
+  GNUNET_assert (NULL != ohh);
+
+  cancel_control_transmit (ohh->th, ohh->tth);
+  GNUNET_CONTAINER_DLL_remove (th->oh_head, th->oh_tail, ohh);
+  GNUNET_free (ohh->msg);
+  GNUNET_free (ohh);
+}
+
+
+
+/**
  * Obtain the HELLO message for this peer.
  *
  * @param handle connection to transport service
@@ -1254,6 +1370,8 @@
   }
   GNUNET_free_non_null (handle->my_hello);
   handle->my_hello = NULL;
+  GNUNET_assert (handle->tc_head == NULL);
+  GNUNET_assert (handle->tc_tail == NULL);
   GNUNET_assert (handle->hwl_head == NULL);
   GNUNET_assert (handle->hwl_tail == NULL);
   GNUNET_CONTAINER_heap_destroy (handle->ready_heap);