*/
struct GNUNET_TRANSPORT_TryConnectHandle *next;
+ /**
+ *
+ */
struct GNUNET_PeerIdentity pid;
+ /**
+ *
+ */
struct GNUNET_TRANSPORT_Handle *th;
+ /**
+ *
+ */
struct GNUNET_TRANSPORT_TransmitHandle *tth;
+ /**
+ *
+ */
GNUNET_TRANSPORT_TryConnectCallback cb;
/**
* Closure for @e cb.
*/
void *cb_cls;
+
+ /**
+ *
+ */
+ int connect;
+
};
*/
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;
};
*/
GNUNET_TRANSPORT_NotifyDisconnect nd_cb;
+ /**
+ * function to call on excess bandwidth events
+ */
+ GNUNET_TRANSPORT_NotifyExcessBandwidth neb_cb;
+
/**
* Head of DLL of control messages.
*/
};
-
/**
* Schedule the task to send one message, either from the control
* list or the peer message queues to the service.
}
-
+/**
+ * The outbound quota has changed in a way that may require
+ * us to reset the timeout. Update the timeout.
+ *
+ * @param cls the `struct Neighbour` for which the timeout changed
+ */
static void
outbound_bw_tracker_update (void *cls)
{
struct Neighbour *n = cls;
struct GNUNET_TIME_Relative delay;
+
if (NULL == n->hn)
return;
-
delay = GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker,
n->th->notify_size + n->traffic_overhead);
- LOG(GNUNET_ERROR_TYPE_DEBUG,
- "New outbound delay %llu us\n",delay.rel_value_us);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "New outbound delay %llu us\n",
+ GNUNET_STRINGS_relative_time_to_string (delay,
+ GNUNET_NO));
GNUNET_CONTAINER_heap_update_cost (n->h->ready_heap,
n->hn, delay.rel_value_us);
schedule_transmission (n->h);
}
+/**
+ * Function called by the bandwidth tracker if we have excess
+ * bandwidth.
+ *
+ * @param cls the `struct Neighbour` that has excess bandwidth
+ */
+static void
+notify_excess_cb (void *cls)
+{
+ struct Neighbour *n = cls;
+ struct GNUNET_TRANSPORT_Handle *h = n->h;
+
+ if (NULL != h->neb_cb)
+ h->neb_cb (h->cls,
+ &n->id);
+}
+
+
/**
* Add neighbour to our list
*
n->h = h;
n->is_ready = GNUNET_YES;
n->traffic_overhead = 0;
- GNUNET_BANDWIDTH_tracker_init (&n->out_tracker,
- outbound_bw_tracker_update, n,
- GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
- MAX_BANDWIDTH_CARRY_S);
+ GNUNET_BANDWIDTH_tracker_init2 (&n->out_tracker,
+ &outbound_bw_tracker_update, n,
+ GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
+ MAX_BANDWIDTH_CARRY_S,
+ ¬ify_excess_cb,
+ n);
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multipeermap_put (h->neighbours,
&n->id, n,
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_multipeermap_remove (handle->neighbours, key,
n));
+ GNUNET_BANDWIDTH_tracker_notification_stop (&n->out_tracker);
GNUNET_free (n);
return GNUNET_YES;
}
-static int reconnecting;
/**
* Function we use for handling incoming messages.
* @param msg message received, NULL on timeout or fatal error
*/
static void
-demultiplexer (void *cls, const struct GNUNET_MessageHeader *msg)
+demultiplexer (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_TRANSPORT_Handle *h = cls;
const struct DisconnectInfoMessage *dim;
uint32_t bytes_physical;
GNUNET_assert (NULL != h->client);
- if (GNUNET_YES == reconnecting)
+ if (GNUNET_YES == h->reconnecting)
{
return;
}
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Error receiving from transport service, disconnecting temporarily.\n");
- reconnecting = GNUNET_YES;
+ h->reconnecting = GNUNET_YES;
disconnect_and_schedule_reconnect (h);
return;
}
GNUNET_assert (NULL == h->client);
GNUNET_assert (NULL == h->control_head);
GNUNET_assert (NULL == h->control_tail);
- reconnecting = GNUNET_NO;
+ h->reconnecting = GNUNET_NO;
h->client = GNUNET_CLIENT_connect ("transport", h->cfg);
GNUNET_assert (NULL != h->client);
}
-
/**
* Send REQUEST_CONNECT message to the service.
*
struct GNUNET_TRANSPORT_TryConnectHandle *tch = cls;
struct TransportRequestConnectMessage msg;
- if (buf == NULL)
+ if (NULL == buf)
{
if (NULL != tch->cb)
tch->cb (tch->cb_cls, GNUNET_SYSERR);
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.connect = htonl (tch->connect);
msg.peer = tch->pid;
memcpy (buf, &msg, sizeof (msg));
if (NULL != tch->cb)
return sizeof (struct TransportRequestConnectMessage);
}
+
/**
* Ask the transport service to establish a connection to
* the given peer.
GNUNET_TRANSPORT_TryConnectCallback cb,
void *cb_cls)
{
- struct GNUNET_TRANSPORT_TryConnectHandle *tch = NULL;
+ struct GNUNET_TRANSPORT_TryConnectHandle *tch;
if (NULL == handle->client)
- return NULL;
+ return NULL;
tch = GNUNET_new (struct GNUNET_TRANSPORT_TryConnectHandle);
tch->th = handle;
tch->pid = *(target);
tch->cb = cb;
tch->cb_cls = cb_cls;
+ tch->connect = GNUNET_YES;
tch->tth = schedule_control_transmit (handle,
sizeof (struct TransportRequestConnectMessage),
&send_try_connect, tch);
- GNUNET_CONTAINER_DLL_insert(handle->tc_head, handle->tc_tail, tch);
+ GNUNET_CONTAINER_DLL_insert (handle->tc_head,
+ handle->tc_tail,
+ tch);
return tch;
}
GNUNET_TRANSPORT_try_connect_cancel (struct GNUNET_TRANSPORT_TryConnectHandle *tch)
{
struct GNUNET_TRANSPORT_Handle *th;
+ GNUNET_assert (GNUNET_YES == tch->connect);
th = tch->th;
cancel_control_transmit (th, tch->tth);
GNUNET_free (tch);
}
+
+/**
+ * Ask the transport service to shutdown a connection to
+ * the given peer.
+ *
+ * @param handle connection to transport service
+ * @param target who we should try to connect to
+ * @param cb callback to be called when request was transmitted to transport
+ * service
+ * @param cb_cls closure for the callback @a cb
+ * @return a `struct GNUNET_TRANSPORT_TryConnectHandle` handle or
+ * NULL on failure (cb will not be called)
+ */
+struct GNUNET_TRANSPORT_TryConnectHandle *
+GNUNET_TRANSPORT_try_disconnect (struct GNUNET_TRANSPORT_Handle *handle,
+ const struct GNUNET_PeerIdentity *target,
+ GNUNET_TRANSPORT_TryConnectCallback cb,
+ void *cb_cls)
+{
+ struct GNUNET_TRANSPORT_TryConnectHandle *tch;
+
+ if (NULL == handle->client)
+ return NULL;
+ tch = GNUNET_new (struct GNUNET_TRANSPORT_TryConnectHandle);
+ tch->th = handle;
+ tch->pid = *(target);
+ tch->cb = cb;
+ tch->cb_cls = cb_cls;
+ tch->connect = GNUNET_NO;
+ tch->tth = schedule_control_transmit (handle,
+ sizeof (struct TransportRequestConnectMessage),
+ &send_try_connect, tch);
+ GNUNET_CONTAINER_DLL_insert (handle->tc_head,
+ handle->tc_tail,
+ tch);
+ return tch;
+}
+
+
+/**
+ * Cancel the request to transport to try a disconnect
+ * Callback will not be called
+ *
+ * @param tch the handle to cancel
+ */
+void
+GNUNET_TRANSPORT_try_disconnect_cancel (struct GNUNET_TRANSPORT_TryConnectHandle *tch)
+{
+ struct GNUNET_TRANSPORT_Handle *th;
+
+ GNUNET_assert (GNUNET_NO == tch->connect);
+ th = tch->th;
+ cancel_control_transmit (th, tch->tth);
+ GNUNET_CONTAINER_DLL_remove (th->tc_head, th->tc_tail, tch);
+ GNUNET_free (tch);
+}
+
+
/**
* Send HELLO message to the service.
*
}
-
/**
* Offer the transport service the HELLO of another peer. Note that
* the transport service may just ignore this message if the HELLO is
* @param rec receive function to call
* @param nc function to call on connect events
* @param nd function to call on disconnect events
+ * @return NULL on error
*/
struct GNUNET_TRANSPORT_Handle *
GNUNET_TRANSPORT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_TRANSPORT_ReceiveCallback rec,
GNUNET_TRANSPORT_NotifyConnect nc,
GNUNET_TRANSPORT_NotifyDisconnect nd)
+{
+ return GNUNET_TRANSPORT_connect2 (cfg, self, cls,
+ rec, nc, nd, NULL);
+}
+
+
+/**
+ * Connect to the transport service. Note that the connection may
+ * complete (or fail) asynchronously.
+ *
+ * @param cfg configuration to use
+ * @param self our own identity (API should check that it matches
+ * the identity found by transport), or NULL (no check)
+ * @param cls closure for the callbacks
+ * @param rec receive function to call
+ * @param nc function to call on connect events
+ * @param nd function to call on disconnect events
+ * @param neb function to call if we have excess bandwidth to a peer
+ * @return NULL on error
+ */
+struct GNUNET_TRANSPORT_Handle *
+GNUNET_TRANSPORT_connect2 (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ const struct GNUNET_PeerIdentity *self, void *cls,
+ GNUNET_TRANSPORT_ReceiveCallback rec,
+ GNUNET_TRANSPORT_NotifyConnect nc,
+ GNUNET_TRANSPORT_NotifyDisconnect nd,
+ GNUNET_TRANSPORT_NotifyExcessBandwidth neb)
{
struct GNUNET_TRANSPORT_Handle *ret;
ret->rec = rec;
ret->nc_cb = nc;
ret->nd_cb = nd;
+ ret->neb_cb = neb;
ret->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Connecting to transport service.\n");
}
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_assert (NULL == handle->tc_head);
+ GNUNET_assert (NULL == handle->tc_tail);
+ GNUNET_assert (NULL == handle->hwl_head);
+ GNUNET_assert (NULL == handle->hwl_tail);
GNUNET_CONTAINER_heap_destroy (handle->ready_heap);
handle->ready_heap = NULL;
GNUNET_free (handle);
projects / oweals / gnunet.git / blobdiff