*/
#define OFFER_HELLO_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+/**
+ * After how long do we give automatically retry an unsuccessful
+ * CONNECT request?
+ */
+#define CONNECT_RETRY_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 750)
+
/**
* How long should ARM wait when starting up the
* transport service before reporting back?
*/
struct GNUNET_TRANSPORT_TransmitHandle *transmit_handle;
-
/**
* Identity of this neighbour.
*/
uint64_t last_sent;
/**
- * Global quota for outbound traffic to the neighbour in bytes/ms.
+ * Quota for outbound traffic to the neighbour in bytes/ms.
*/
uint32_t quota_out;
* Function to call when notify_size bytes are available
* for transmission.
*/
- GNUNET_NETWORK_TransmitReadyNotify notify;
+ GNUNET_CONNECTION_TransmitReadyNotify notify;
/**
* Closure for notify.
*/
size_t notify_size;
+ /**
+ * How important is this message?
+ */
+ unsigned int priority;
+
};
/**
* Handle to our registration with the client for notification.
*/
- struct GNUNET_NETWORK_TransmitHandle *network_handle;
+ struct GNUNET_CONNECTION_TransmitHandle *network_handle;
/**
* Linked list of transmit handles that are waiting for the
/**
* My configuration.
*/
- struct GNUNET_CONFIGURATION_Handle *cfg;
+ const struct GNUNET_CONFIGURATION_Handle *cfg;
/**
* Linked list of the current neighbours of this peer.
if (buf == NULL)
{
#if DEBUG_TRANSPORT
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Could not transmit to transport service, cancelling pending requests\n");
#endif
th = h->connect_ready_head;
GNUNET_assert (n->transmit_handle == th);
n->transmit_handle = NULL;
}
+ if (th->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
+ {
+ GNUNET_SCHEDULER_cancel (h->sched,
+ th->notify_delay_task);
+ th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
+ }
GNUNET_assert (0 == th->notify (th->notify_cls, 0, NULL));
GNUNET_free (th);
+ if (h->connect_ready_head != NULL) schedule_transmission (h); /* FIXME: is this ok? */
return 0;
}
#if DEBUG_TRANSPORT
do
{
th = h->connect_ready_head;
- if (th->notify_delay_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+ if (th->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
- /* remove existing time out task (only applies if
- this is not the first iteration of the loop) */
GNUNET_SCHEDULER_cancel (h->sched,
th->notify_delay_task);
- th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+ th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_assert (th->notify_size <= size);
if (th->next != NULL)
th = h->connect_ready_head;
if (th == NULL)
return; /* no request pending */
- if (th->notify_delay_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+ if (th->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
/* remove existing time out task, will be integrated
with transmit_ready notification! */
GNUNET_SCHEDULER_cancel (h->sched,
th->notify_delay_task);
- th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+ th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
h->transmission_scheduled = GNUNET_YES;
h->network_handle = GNUNET_CLIENT_notify_transmit_ready (h->client,
struct GNUNET_TRANSPORT_Handle *h;
h = th->handle;
- if (th->notify_delay_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+ if (th->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (h->sched, th->notify_delay_task);
- th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+ th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
if (th->prev == NULL)
{
}
+/**
+ * Schedule a request to connect to the given
+ * neighbour (and if successful, add the specified
+ * handle to the wait list).
+ *
+ * @param th handle for a request to transmit once we
+ * have connected
+ */
+static void
+try_connect (struct GNUNET_TRANSPORT_TransmitHandle *th);
+
+
/**
* Called when our transmit request timed out before any transport
* reported success connecting to the desired peer or before the
* TransmitHandle.
*/
static void
-transmit_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+peer_transmit_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_TRANSPORT_TransmitHandle *th = cls;
- th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+ th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
if (th->neighbour != NULL)
th->neighbour->transmit_handle = NULL;
#if DEBUG_TRANSPORT
size_t size,
int at_head,
struct GNUNET_TIME_Relative timeout,
- GNUNET_NETWORK_TransmitReadyNotify notify,
+ GNUNET_CONNECTION_TransmitReadyNotify notify,
void *notify_cls)
{
struct GNUNET_TRANSPORT_TransmitHandle *th;
= GNUNET_SCHEDULER_add_delayed (h->sched,
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+ GNUNET_SCHEDULER_NO_TASK,
timeout,
- &transmit_timeout, th);
+ &peer_transmit_timeout, th);
if (at_head)
{
th->next = h->connect_ready_head;
struct HelloWaitList *pos;
struct HelloWaitList *prev;
+ hwl->task = GNUNET_SCHEDULER_NO_TASK;
+ if (GNUNET_TIME_absolute_get_remaining (hwl->timeout).value > 0)
+ {
+#if DEBUG_TRANSPORT
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ _("First attempt to obtain `%s' from transport service failed, will try again for %llums.\n"),
+ "HELLO",
+ GNUNET_TIME_absolute_get_remaining (hwl->timeout).value);
+#endif
+ hwl->task = GNUNET_SCHEDULER_add_delayed (hwl->handle->sched,
+ GNUNET_YES,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_absolute_get_remaining (hwl->timeout),
+ &hello_wait_timeout, hwl);
+ return;
+ }
+ /* signal timeout */
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Timeout trying to obtain `%s' from transport service.\n"),
+ "HELLO");
prev = NULL;
pos = hwl->handle->hwl_head;
while (pos != hwl)
hwl->handle->hwl_head = hwl->next;
else
prev->next = hwl->next;
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Timeout trying to obtain `%s' from transport service.\n"),
- "HELLO");
- /* signal timeout */
if (hwl->rec != NULL)
hwl->rec (hwl->rec_cls, GNUNET_TIME_UNIT_ZERO, NULL, NULL);
GNUNET_free (hwl);
hwl->task = GNUNET_SCHEDULER_add_delayed (handle->sched,
GNUNET_YES,
GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+ GNUNET_SCHEDULER_NO_TASK,
timeout,
&hello_wait_timeout, hwl);
return;
if (buf == NULL)
{
#if DEBUG_TRANSPORT
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Timeout while trying to transmit `%s' request.\n",
"START");
#endif
struct TryConnectMessage *tcm;
struct GNUNET_TRANSPORT_Handle *h;
- GNUNET_assert (th->notify_delay_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+ GNUNET_assert (th->notify_delay_task == GNUNET_SCHEDULER_NO_TASK);
h = th->handle;
if (buf == NULL)
{
"TRY_CONNECT",
GNUNET_i2s(&th->target));
#endif
+ if (th->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
+ {
+ GNUNET_SCHEDULER_cancel (h->sched, th->notify_delay_task);
+ th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
+ }
th->notify (th->notify_cls, 0, NULL);
GNUNET_free (th);
return 0;
= GNUNET_SCHEDULER_add_delayed (h->sched,
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
- GNUNET_TIME_absolute_get_remaining
- (th->timeout), &transmit_timeout, th);
+ GNUNET_SCHEDULER_NO_TASK,
+ GNUNET_TIME_absolute_get_remaining
+ (th->timeout),
+ &peer_transmit_timeout, th);
insert_transmit_handle (&h->connect_wait_head, th);
return sizeof (struct TryConnectMessage);
}
static void
try_connect (struct GNUNET_TRANSPORT_TransmitHandle *th)
{
- GNUNET_assert (th->notify_delay_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+ GNUNET_assert (th->notify_delay_task == GNUNET_SCHEDULER_NO_TASK);
schedule_control_transmit (th->handle,
sizeof (struct TryConnectMessage),
GNUNET_NO,
/**
- * Remove neighbour from our list
+ * Task for delayed attempts to reconnect to a peer.
+ *
+ * @param cls must be a transmit handle that determines the peer
+ * to which we will try to connect
+ * @param tc scheduler information about why we were triggered (not used)
+ */
+static void
+try_connect_task (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct GNUNET_TRANSPORT_TransmitHandle *th = cls;
+
+ th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
+ try_connect (th);
+}
+
+
+/**
+ * Remove neighbour from our list. Will automatically
+ * trigger a re-connect attempt if we have messages pending
+ * for this peer.
+ *
+ * @param h our state
+ * @param peer the peer to remove
*/
static void
remove_neighbour (struct GNUNET_TRANSPORT_Handle *h,
struct NeighbourList *pos;
struct GNUNET_TRANSPORT_TransmitHandle *th;
+#if DEBUG_TRANSPORT
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Removing neighbour `%s' from list of connected peers.\n",
+ GNUNET_i2s (peer));
+#endif
prev = NULL;
pos = h->neighbours;
while ((pos != NULL) &&
- (0 != memcmp (peer, &pos->id, sizeof (struct GNUNET_PeerIdentity))))
+ (0 != memcmp (peer,
+ &pos->id,
+ sizeof (struct GNUNET_PeerIdentity))))
{
prev = pos;
pos = pos->next;
pos->transmit_handle = NULL;
th->neighbour = NULL;
remove_from_any_list (th);
- try_connect (th);
+ if (GNUNET_TIME_absolute_get_remaining (th->timeout).value <= CONNECT_RETRY_TIMEOUT.value)
+ {
+ /* signal error */
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == th->notify_delay_task);
+ peer_transmit_timeout (th, NULL);
+ }
+ else
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ _("Connection with `%4s' failed, will keep trying for %llu ms to deliver message\n"),
+ GNUNET_i2s (peer),
+ GNUNET_TIME_absolute_get_remaining (th->timeout).value);
+ /* try again in a bit */
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == th->notify_delay_task);
+ th->notify_delay_task
+ = GNUNET_SCHEDULER_add_delayed (h->sched,
+ GNUNET_NO,
+ GNUNET_SCHEDULER_PRIORITY_KEEP,
+ GNUNET_SCHEDULER_NO_TASK,
+ CONNECT_RETRY_TIMEOUT,
+ &try_connect_task,
+ th);
+ }
}
if (h->nc_cb != NULL)
h->nd_cb (h->cls, peer);
struct GNUNET_TRANSPORT_TransmitHandle *pos;
struct NeighbourList *n;
+ fprintf (stderr,
+ "Trying to reconnect to transport!\n");
+
/* Forget about all neighbours that we used to be connected
to */
while (NULL != (n = h->neighbours))
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
#endif
GNUNET_assert (h->client == NULL);
- h->reconnect_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+ h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
h->client = GNUNET_CLIENT_connect (h->sched, "transport", h->cfg);
GNUNET_assert (h->client != NULL);
/* make sure we don't send "START" twice,
schedule_control_transmit (h,
sizeof (struct GNUNET_MessageHeader),
GNUNET_YES,
- GNUNET_TIME_UNIT_FOREVER_REL, &send_start, NULL);
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ &send_start, NULL);
GNUNET_CLIENT_receive (h->client,
&demultiplexer, h, GNUNET_TIME_UNIT_FOREVER_REL);
}
h->reconnect_delay.value);
#endif
GNUNET_assert (h->client == NULL);
- GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+ GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
h->reconnect_task
= GNUNET_SCHEDULER_add_delayed (h->sched,
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+ GNUNET_SCHEDULER_NO_TASK,
h->reconnect_delay, &reconnect, h);
h->reconnect_delay = GNUNET_TIME_UNIT_SECONDS;
}
{
struct GNUNET_TRANSPORT_TransmitHandle *th = cls;
- th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+ th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
schedule_request (th);
}
h = th->handle;
n = th->neighbour;
- if (th->notify_delay_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+ if (th->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (h->sched, th->notify_delay_task);
- th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+ th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
/* check outgoing quota */
duration = GNUNET_TIME_absolute_get_duration (n->last_quota_update);
= GNUNET_SCHEDULER_add_delayed (h->sched,
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+ GNUNET_SCHEDULER_NO_TASK,
duration, &transmit_ready, th);
return;
}
= GNUNET_SCHEDULER_add_delayed (h->sched,
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+ GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_absolute_get_remaining
- (th->timeout), &transmit_timeout, th);
+ (th->timeout), &peer_transmit_timeout, th);
return;
}
n->transmit_ok = GNUNET_NO;
"Found pending request for `%4s' will trigger it now.\n",
GNUNET_i2s (&pos->target));
#endif
- if (pos->notify_delay_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+ if (pos->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (h->sched, pos->notify_delay_task);
- pos->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+ pos->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
schedule_request (pos);
}
*/
struct GNUNET_TRANSPORT_Handle *
GNUNET_TRANSPORT_connect (struct GNUNET_SCHEDULER_Handle *sched,
- struct GNUNET_CONFIGURATION_Handle *cfg,
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
void *cls,
GNUNET_TRANSPORT_ReceiveCallback rec,
GNUNET_TRANSPORT_NotifyConnect nc,
struct GNUNET_CLIENT_Connection *client;
#if DEBUG_TRANSPORT
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transport disconnect called!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Transport disconnect called!\n");
#endif
while (NULL != (th = handle->connect_ready_head))
{
handle->connect_ready_head = th->next;
+ GNUNET_assert (th->notify_delay_task == GNUNET_SCHEDULER_NO_TASK);
th->notify (th->notify_cls, 0, NULL);
GNUNET_free (th);
}
while (NULL != (th = handle->connect_wait_head))
{
handle->connect_wait_head = th->next;
- if (th->notify_delay_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+ if (th->notify_delay_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (handle->sched, th->notify_delay_task);
- th->notify_delay_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+ th->notify_delay_task = GNUNET_SCHEDULER_NO_TASK;
}
th->notify (th->notify_cls, 0, NULL);
GNUNET_free (th);
hwl->rec (hwl->rec_cls, GNUNET_TIME_UNIT_ZERO, NULL, NULL);
GNUNET_free (hwl);
}
- if (handle->reconnect_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+ if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (handle->sched, handle->reconnect_task);
- handle->reconnect_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+ handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_free_non_null (handle->my_hello);
handle->my_hello = NULL;
const struct SendOkMessage *okm;
struct HelloWaitList *hwl;
struct NeighbourList *n;
- struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
struct GNUNET_PeerIdentity me;
struct GNUNET_TRANSPORT_TransmitHandle *th;
uint16_t size;
#endif
if (h->network_handle != NULL)
{
- GNUNET_NETWORK_notify_transmit_ready_cancel (h->network_handle);
+ GNUNET_CONNECTION_notify_transmit_ready_cancel (h->network_handle);
h->network_handle = NULL;
h->transmission_scheduled = GNUNET_NO;
th = h->connect_ready_head;
/* add timeout again, we cancelled the transmit_ready task! */
- GNUNET_assert (th->notify_delay_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+ GNUNET_assert (th->notify_delay_task == GNUNET_SCHEDULER_NO_TASK);
th->notify_delay_task
= GNUNET_SCHEDULER_add_delayed (h->sched,
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+ GNUNET_SCHEDULER_NO_TASK,
GNUNET_TIME_absolute_get_remaining(th->timeout),
- &transmit_timeout,
+ &peer_transmit_timeout,
th);
}
GNUNET_CLIENT_disconnect (h->client);
{
case GNUNET_MESSAGE_TYPE_HELLO:
if (GNUNET_OK !=
- GNUNET_HELLO_get_key ((const struct GNUNET_HELLO_Message *) msg,
- &pkey))
+ GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) msg,
+ &me))
{
GNUNET_break (0);
break;
}
- GNUNET_CRYPTO_hash (&pkey,
- sizeof (struct
- GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
- &me.hashPubKey);
#if DEBUG_TRANSPORT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Receiving (my own) `%s' message, I am `%4s'.\n",
{
#if DEBUG_TRANSPORT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Processing pending message\n");
+ "Processing pending message for `%4s'\n",
+ GNUNET_i2s(&n->id));
#endif
GNUNET_SCHEDULER_cancel (h->sched,
n->transmit_handle->notify_delay_task);
n->transmit_handle->notify_delay_task =
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+ GNUNET_SCHEDULER_NO_TASK;
GNUNET_assert (GNUNET_YES == n->received_ack);
schedule_request (n->transmit_handle);
}
struct ClientTransmitWrapper
{
- GNUNET_NETWORK_TransmitReadyNotify notify;
+ GNUNET_CONNECTION_TransmitReadyNotify notify;
void *notify_cls;
struct GNUNET_TRANSPORT_TransmitHandle *th;
};
ret += sizeof (struct OutboundMessage);
obm->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_SEND);
obm->header.size = htons (ret);
- obm->reserved = htonl (0);
+ obm->priority = htonl (ctw->th->priority);
obm->peer = ctw->th->target;
GNUNET_free (ctw);
return ret;
* @param handle connection to transport service
* @param target who should receive the message
* @param size how big is the message we want to transmit?
+ * @param priority how important is the message?
* @param timeout after how long should we give up (and call
* notify with buf NULL and size 0)?
* @param notify function to call when we are ready to
*handle,
const struct GNUNET_PeerIdentity
*target, size_t size,
+ unsigned int priority,
struct GNUNET_TIME_Relative timeout,
- GNUNET_NETWORK_TransmitReadyNotify
+ GNUNET_CONNECTION_TransmitReadyNotify
notify, void *notify_cls)
{
struct GNUNET_TRANSPORT_TransmitHandle *pos;
ctw->notify_cls = notify_cls;
ctw->th = th;
th->handle = handle;
+ th->neighbour = n;
th->target = *target;
th->notify = &client_notify_wrapper;
th->notify_cls = ctw;
- th->notify_size = size + sizeof (struct OutboundMessage);
th->timeout = GNUNET_TIME_relative_to_absolute (timeout);
- th->neighbour = n;
+ th->notify_size = size + sizeof (struct OutboundMessage);
+ th->priority = priority;
if (NULL == n)
{
pos = handle->connect_wait_head;
= GNUNET_SCHEDULER_add_delayed (handle->sched,
GNUNET_NO,
GNUNET_SCHEDULER_PRIORITY_KEEP,
- GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
- timeout, &transmit_timeout, th);
+ GNUNET_SCHEDULER_NO_TASK,
+ timeout, &peer_transmit_timeout, th);
return th;
}
/**
- * Cancel the specified transmission-ready
- * notification.
+ * Cancel the specified transmission-ready notification.
*/
void
GNUNET_TRANSPORT_notify_transmit_ready_cancel (struct
h = th->handle;
if ((h->connect_ready_head == NULL) && (h->network_handle != NULL))
{
- GNUNET_NETWORK_notify_transmit_ready_cancel (h->network_handle);
+ GNUNET_CONNECTION_notify_transmit_ready_cancel (h->network_handle);
h->network_handle = NULL;
h->transmission_scheduled = GNUNET_NO;
}
GNUNET_free (th->notify_cls);
+ GNUNET_assert (th->notify_delay_task == GNUNET_SCHEDULER_NO_TASK);
GNUNET_free (th);
}
projects / oweals / gnunet.git / blobdiff