This file is part of GNUnet.
Copyright (C) 2009-2013, 2016 GNUnet e.V.
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software: you can redistribute it and/or modify it
+ under the terms of the GNU Affero General Public License as published
+ by the Free Software Foundation, either version 3 of the License,
+ or (at your option) any later version.
GNUnet is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ Affero General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA.
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ SPDX-License-Identifier: AGPL3.0-or-later
*/
/**
#include "gnunet_arm_service.h"
#include "gnunet_hello_lib.h"
#include "gnunet_protocols.h"
-#include "gnunet_transport_core_service.h"
+#include "gnunet_transport_service.h"
#include "transport.h"
-#define LOG(kind,...) GNUNET_log_from (kind, "transport-api-core",__VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "transport-api-core", __VA_ARGS__)
/**
* If we could not send any payload to a peer for this amount of
* Size of the message in @e env.
*/
uint16_t env_size;
-
};
-
/**
* Handle for the transport service (includes all of the
* state for the transport service).
*/
-struct GNUNET_TRANSPORT_Handle
+struct GNUNET_TRANSPORT_CoreHandle
{
/**
/**
* function to call on connect events
*/
- GNUNET_TRANSPORT_NotifyConnecT nc_cb;
+ GNUNET_TRANSPORT_NotifyConnect nc_cb;
/**
* function to call on disconnect events
*/
- GNUNET_TRANSPORT_NotifyDisconnecT nd_cb;
+ GNUNET_TRANSPORT_NotifyDisconnect nd_cb;
/**
* function to call on excess bandwidth events
*/
- GNUNET_TRANSPORT_NotifyExcessBandwidtH neb_cb;
+ GNUNET_TRANSPORT_NotifyExcessBandwidth neb_cb;
/**
* My client connection to the transport service.
* (if #GNUNET_NO, then @e self is all zeros!).
*/
int check_self;
-
};
-/**
- * Schedule the task to send one message, either from the control
- * list or the peer message queues to the service.
- *
- * @param h transport service to schedule a transmission for
- */
-static void
-schedule_transmission (struct GNUNET_TRANSPORT_Handle *h);
-
-
/**
* Function that will schedule the job that will try
* to connect us again to the client.
* @param h transport service to reconnect
*/
static void
-disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_Handle *h);
+disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_CoreHandle *h);
/**
* @return NULL if no such peer entry exists
*/
static struct Neighbour *
-neighbour_find (struct GNUNET_TRANSPORT_Handle *h,
+neighbour_find (struct GNUNET_TRANSPORT_CoreHandle *h,
const struct GNUNET_PeerIdentity *peer)
{
- return GNUNET_CONTAINER_multipeermap_get (h->neighbours,
- peer);
+ return GNUNET_CONTAINER_multipeermap_get (h->neighbours, peer);
}
notify_excess_cb (void *cls)
{
struct Neighbour *n = cls;
- struct GNUNET_TRANSPORT_Handle *h = n->h;
+ struct GNUNET_TRANSPORT_CoreHandle *h = n->h;
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Notifying CORE that more bandwidth is available for %s\n",
+ GNUNET_i2s (&n->id));
if (NULL != h->neb_cb)
- h->neb_cb (h->cls,
- &n->id);
+ h->neb_cb (h->cls, &n->id, n->handlers_cls);
}
/**
* Iterator over hash map entries, for deleting state of a neighbour.
*
- * @param cls the `struct GNUNET_TRANSPORT_Handle *`
+ * @param cls the `struct GNUNET_TRANSPORT_CoreHandle *`
* @param key peer identity
* @param value value in the hash map, the neighbour entry to delete
* @return #GNUNET_YES if we should continue to
* #GNUNET_NO if not.
*/
static int
-neighbour_delete (void *cls,
- const struct GNUNET_PeerIdentity *key,
- void *value)
+neighbour_delete (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
{
- struct GNUNET_TRANSPORT_Handle *handle = cls;
+ struct GNUNET_TRANSPORT_CoreHandle *handle = cls;
struct Neighbour *n = value;
LOG (GNUNET_ERROR_TYPE_DEBUG,
GNUNET_i2s (key));
GNUNET_BANDWIDTH_tracker_notification_stop (&n->out_tracker);
if (NULL != handle->nd_cb)
- handle->nd_cb (handle->cls,
- &n->id,
- n->handlers_cls);
+ handle->nd_cb (handle->cls, &n->id, n->handlers_cls);
if (NULL != n->timeout_task)
{
GNUNET_SCHEDULER_cancel (n->timeout_task);
n->timeout_task = NULL;
}
- GNUNET_MQ_destroy (n->mq);
if (NULL != n->env)
{
GNUNET_MQ_send_cancel (n->env);
n->env = NULL;
}
+ GNUNET_MQ_destroy (n->mq);
GNUNET_assert (NULL == n->mq);
- GNUNET_assert (GNUNET_YES ==
- GNUNET_CONTAINER_multipeermap_remove (handle->neighbours,
- key,
- n));
+ GNUNET_assert (
+ GNUNET_YES ==
+ GNUNET_CONTAINER_multipeermap_remove (handle->neighbours, key, n));
GNUNET_free (n);
return GNUNET_YES;
}
* the message queue.
* Not every message queue implementation supports an error handler.
*
- * @param cls closure with the `struct GNUNET_TRANSPORT_Handle *`
+ * @param cls closure with the `struct GNUNET_TRANSPORT_CoreHandle *`
* @param error error code
*/
static void
-mq_error_handler (void *cls,
- enum GNUNET_MQ_Error error)
+mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
{
- struct GNUNET_TRANSPORT_Handle *h = cls;
+ struct GNUNET_TRANSPORT_CoreHandle *h = cls;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Error receiving from transport service, disconnecting temporarily.\n");
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Error receiving from transport service (%d), disconnecting temporarily.\n",
+ error);
disconnect_and_schedule_reconnect (h);
}
/**
* Function we use for checking incoming HELLO messages.
*
- * @param cls closure, a `struct GNUNET_TRANSPORT_Handle *`
+ * @param cls closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
* @param msg message received
* @return #GNUNET_OK if message is well-formed
*/
static int
-check_hello (void *cls,
- const struct GNUNET_MessageHeader *msg)
+check_hello (void *cls, const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_PeerIdentity me;
if (GNUNET_OK !=
- GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) msg,
- &me))
+ GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) msg, &me))
{
GNUNET_break (0);
return GNUNET_SYSERR;
/**
* Function we use for handling incoming HELLO messages.
*
- * @param cls closure, a `struct GNUNET_TRANSPORT_Handle *`
+ * @param cls closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
* @param msg message received
*/
static void
-handle_hello (void *cls,
- const struct GNUNET_MessageHeader *msg)
+handle_hello (void *cls, const struct GNUNET_MessageHeader *msg)
{
/* we do not care => FIXME: signal in options to NEVER send HELLOs! */
}
+/**
+ * A message from the handler's message queue to a neighbour was
+ * transmitted. Now trigger (possibly delayed) notification of the
+ * neighbour's message queue that we are done and thus ready for
+ * the next message.
+ *
+ * @param cls the `struct Neighbour` where the message was sent
+ */
+static void
+notify_send_done_fin (void *cls)
+{
+ struct Neighbour *n = cls;
+
+ n->timeout_task = NULL;
+ n->is_ready = GNUNET_YES;
+ GNUNET_MQ_impl_send_continue (n->mq);
+}
+
+
/**
* A message from the handler's message queue to a neighbour was
* transmitted. Now trigger (possibly delayed) notification of the
struct GNUNET_TIME_Relative delay;
n->timeout_task = NULL;
- if (NULL != env)
+ if (NULL != n->env)
{
GNUNET_BANDWIDTH_tracker_consume (&n->out_tracker,
n->env_size + n->traffic_overhead);
- n->traffic_overhead = 0;
n->env = NULL;
+ n->traffic_overhead = 0;
}
- delay = GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker,
- 128);
+ delay = GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker, 128);
if (0 == delay.rel_value_us)
{
n->is_ready = GNUNET_YES;
- GNUNET_MQ_impl_send_continue (mq);
+ GNUNET_MQ_impl_send_continue (n->mq);
return;
}
+ GNUNET_MQ_impl_send_in_flight (n->mq);
/* cannot send even a small message without violating
- quota, wait a before notifying MQ */
- n->timeout_task = GNUNET_SCHEDULER_add_delayed (¬ify_send_done,
- n);
+ quota, wait a before allowing MQ to send next message */
+ n->timeout_task =
+ GNUNET_SCHEDULER_add_delayed (delay, ¬ify_send_done_fin, n);
}
struct Neighbour *n = impl_state;
struct GNUNET_TRANSPORT_CoreHandle *h = n->h;
struct OutboundMessage *obm;
- struct GNUNET_MQ_Envelope *env;
uint16_t msize;
GNUNET_assert (GNUNET_YES == n->is_ready);
msize = ntohs (msg->size);
- if (msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE - sizeof (*obm))
+ if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof (*obm))
{
GNUNET_break (0);
GNUNET_MQ_impl_send_continue (mq);
return;
}
- n->env = GNUNET_MQ_msg_nested_mh (obm,
- GNUNET_MESSAGE_TYPE_TRANSPORT_SEND,
- msg);
+ GNUNET_assert (NULL == n->env);
+ n->env =
+ GNUNET_MQ_msg_nested_mh (obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg);
obm->reserved = htonl (0);
- obm->timeout =
- GNUNET_TIME_relative_hton (GNUNET_TIME_absolute_get_remaining
- (th->timeout));
+ obm->timeout = GNUNET_TIME_relative_hton (
+ GNUNET_TIME_UNIT_MINUTES); /* FIXME: to be removed */
obm->peer = n->id;
GNUNET_assert (NULL == n->timeout_task);
n->is_ready = GNUNET_NO;
n->env_size = ntohs (msg->size);
- GNUNET_MQ_notify_sent (env,
- ¬ify_send_done,
- n);
- GNUNET_MQ_send (h->mq,
- env);
+ GNUNET_MQ_notify_sent (n->env, ¬ify_send_done, n);
+ GNUNET_MQ_send (h->mq, n->env);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Queued message of type %u for neighbour `%s'.\n",
+ ntohs (msg->type),
+ GNUNET_i2s (&n->id));
}
* @param impl_state state of the implementation
*/
static void
-mq_destroy_impl (struct GNUNET_MQ_Handle *mq,
- void *impl_state)
+mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
{
struct Neighbour *n = impl_state;
* @param impl_state state specific to the implementation
*/
static void
-mq_cancel_impl (struct GNUNET_MQ_Handle *mq,
- void *impl_state)
+mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
{
struct Neighbour *n = impl_state;
* @param error error code
*/
static void
-peer_mq_error_handler (void *cls,
- enum GNUNET_MQ_Error error)
+peer_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
{
- struct Neighbour *n = cls;
+ /* struct Neighbour *n = cls; */
GNUNET_break_op (0);
}
+/**
+ * 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->timeout_task)
+ return;
+ delay = GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker, 128);
+ GNUNET_SCHEDULER_cancel (n->timeout_task);
+ n->timeout_task = GNUNET_SCHEDULER_add_delayed (delay, ¬ify_send_done, n);
+}
+
+
/**
* Function we use for handling incoming connect messages.
*
* @param cim message received
*/
static void
-handle_connect (void *cls,
- const struct ConnectInfoMessage *cim)
+handle_connect (void *cls, const struct ConnectInfoMessage *cim)
{
- struct GNUNET_TRANSPORT_Handle *h = cls;
+ struct GNUNET_TRANSPORT_CoreHandle *h = cls;
struct Neighbour *n;
LOG (GNUNET_ERROR_TYPE_DEBUG,
n = neighbour_find (h, &cim->id);
if (NULL != n)
{
- GNUNET_break (0);
+ GNUNET_break (0); /* FIXME: this assertion seems to fail sometimes!? */
disconnect_and_schedule_reconnect (h);
return;
}
¬ify_excess_cb,
n);
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONTAINER_multipeermap_put (h->neighbours,
- &n->id,
- n,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+ GNUNET_CONTAINER_multipeermap_put (
+ h->neighbours,
+ &n->id,
+ n,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
- GNUNET_BANDWIDTH_tracker_update_quota (&n->out_tracker,
- cim->quota_out);
+ GNUNET_BANDWIDTH_tracker_update_quota (&n->out_tracker, cim->quota_out);
n->mq = GNUNET_MQ_queue_for_callbacks (&mq_send_impl,
&mq_destroy_impl,
&mq_cancel_impl,
n);
if (NULL != h->nc_cb)
{
- n->handlers_cls = h->nc_cb (h->cls,
- &n->id,
- n->mq);
- GNUNET_MQ_set_handlers_closure (n->mq,
- n->handlers_cls);
+ n->handlers_cls = h->nc_cb (h->cls, &n->id, n->mq);
+ GNUNET_MQ_set_handlers_closure (n->mq, n->handlers_cls);
}
}
/**
* Function we use for handling incoming disconnect messages.
*
- * @param cls closure, a `struct GNUNET_TRANSPORT_Handle *`
+ * @param cls closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
* @param dim message received
*/
static void
-handle_disconnect (void *cls,
- const struct DisconnectInfoMessage *dim)
+handle_disconnect (void *cls, const struct DisconnectInfoMessage *dim)
{
- struct GNUNET_TRANSPORT_Handle *h = cls;
+ struct GNUNET_TRANSPORT_CoreHandle *h = cls;
struct Neighbour *n;
GNUNET_break (ntohl (dim->reserved) == 0);
disconnect_and_schedule_reconnect (h);
return;
}
- GNUNET_assert (GNUNET_YES ==
- neighbour_delete (h,
- &dim->peer,
- n));
+ GNUNET_assert (GNUNET_YES == neighbour_delete (h, &dim->peer, n));
}
/**
* Function we use for handling incoming send-ok messages.
*
- * @param cls closure, a `struct GNUNET_TRANSPORT_Handle *`
+ * @param cls closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
* @param okm message received
*/
static void
-handle_send_ok (void *cls,
- const struct SendOkMessage *okm)
+handle_send_ok (void *cls, const struct SendOkMessage *okm)
{
- struct GNUNET_TRANSPORT_Handle *h = cls;
+ struct GNUNET_TRANSPORT_CoreHandle *h = cls;
struct Neighbour *n;
uint32_t bytes_msg;
uint32_t bytes_physical;
"Receiving SEND_OK message, transmission to %s %s.\n",
GNUNET_i2s (&okm->peer),
ntohl (okm->success) == GNUNET_OK ? "succeeded" : "failed");
- n = neighbour_find (h,
- &okm->peer);
+ n = neighbour_find (h, &okm->peer);
if (NULL == n)
{
/* We should never get a 'SEND_OK' for a peer that we are not
/**
* Function we use for checking incoming "inbound" messages.
*
- * @param cls closure, a `struct GNUNET_TRANSPORT_Handle *`
+ * @param cls closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
* @param im message received
*/
static int
-check_recv (void *cls,
- const struct InboundMessage *im)
+check_recv (void *cls, const struct InboundMessage *im)
{
const struct GNUNET_MessageHeader *imm;
uint16_t size;
- size = ntohs (im->header.size);
- if (size <
- sizeof (struct InboundMessage) + sizeof (struct GNUNET_MessageHeader))
+ size = ntohs (im->header.size) - sizeof (*im);
+ if (size < sizeof (struct GNUNET_MessageHeader))
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
imm = (const struct GNUNET_MessageHeader *) &im[1];
- if (ntohs (imm->size) + sizeof (struct InboundMessage) != size)
+ if (ntohs (imm->size) != size)
{
GNUNET_break (0);
return GNUNET_SYSERR;
/**
* Function we use for handling incoming messages.
*
- * @param cls closure, a `struct GNUNET_TRANSPORT_Handle *`
+ * @param cls closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
* @param im message received
*/
static void
-handle_recv (void *cls,
- const struct InboundMessage *im)
+handle_recv (void *cls, const struct InboundMessage *im)
{
- struct GNUNET_TRANSPORT_Handle *h = cls;
- const struct GNUNET_MessageHeader *imm
- = (const struct GNUNET_MessageHeader *) &im[1];
+ struct GNUNET_TRANSPORT_CoreHandle *h = cls;
+ const struct GNUNET_MessageHeader *imm =
+ (const struct GNUNET_MessageHeader *) &im[1];
struct Neighbour *n;
LOG (GNUNET_ERROR_TYPE_DEBUG,
disconnect_and_schedule_reconnect (h);
return;
}
- GNUNET_MQ_inject_message (n->mq,
- imm);
+ GNUNET_MQ_inject_message (n->mq, imm);
}
/**
* Function we use for handling incoming set quota messages.
*
- * @param cls closure, a `struct GNUNET_TRANSPORT_Handle *`
+ * @param cls closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
* @param msg message received
*/
static void
-handle_set_quota (void *cls,
- const struct QuotaSetMessage *qm)
+handle_set_quota (void *cls, const struct QuotaSetMessage *qm)
{
- struct GNUNET_TRANSPORT_Handle *h = cls;
+ struct GNUNET_TRANSPORT_CoreHandle *h = cls;
struct Neighbour *n;
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Receiving SET_QUOTA message for `%s' with quota %u\n",
+ GNUNET_i2s (&qm->peer),
+ ntohl (qm->quota.value__));
n = neighbour_find (h, &qm->peer);
if (NULL == n)
{
- GNUNET_break (0);
+ GNUNET_break (
+ 0); /* FIXME: julius reports this assertion fails sometimes? */
disconnect_and_schedule_reconnect (h);
return;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Receiving SET_QUOTA message for `%s' with quota %u\n",
- GNUNET_i2s (&qm->peer),
- ntohl (qm->quota.value__));
- GNUNET_BANDWIDTH_tracker_update_quota (&n->out_tracker,
- qm->quota);
+ GNUNET_BANDWIDTH_tracker_update_quota (&n->out_tracker, qm->quota);
}
static void
reconnect (void *cls)
{
- GNUNET_MQ_hd_var_size (hello,
- GNUNET_MESSAGE_TYPE_HELLO,
- struct GNUNET_MessageHeader);
- GNUNET_MQ_hd_fixed_size (connect,
- GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT,
- struct ConnectInfoMessage);
- GNUNET_MQ_hd_fixed_size (disconnect,
- GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT,
- struct DisconnectInfoMessage);
- GNUNET_MQ_hd_fixed_size (send_ok,
- GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK,
- struct SendOkMessage);
- GNUNET_MQ_hd_var_size (recv,
- GNUNET_MESSAGE_TYPE_TRANSPORT_RECV,
- struct InboundMessage);
- GNUNET_MQ_hd_fixed_size (set_quota,
- GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA,
- struct QuotaSetMessage);
- struct GNUNET_TRANSPORT_Handle *h = cls;
- struct GNUNET_MQ_MessageHandler handlers[] = {
- make_hello_handler (h),
- make_connect_handler (h),
- make_disconnect_handler (h),
- make_send_ok_handler (h),
- make_recv_handler (h),
- make_set_quota_handler (h),
- GNUNET_MQ_handler_end ()
- };
+ struct GNUNET_TRANSPORT_CoreHandle *h = cls;
+ struct GNUNET_MQ_MessageHandler handlers[] =
+ {GNUNET_MQ_hd_var_size (hello,
+ GNUNET_MESSAGE_TYPE_HELLO,
+ struct GNUNET_MessageHeader,
+ h),
+ GNUNET_MQ_hd_fixed_size (connect,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT,
+ struct ConnectInfoMessage,
+ h),
+ GNUNET_MQ_hd_fixed_size (disconnect,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT,
+ struct DisconnectInfoMessage,
+ h),
+ GNUNET_MQ_hd_fixed_size (send_ok,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK,
+ struct SendOkMessage,
+ h),
+ GNUNET_MQ_hd_var_size (recv,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_RECV,
+ struct InboundMessage,
+ h),
+ GNUNET_MQ_hd_fixed_size (set_quota,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA,
+ struct QuotaSetMessage,
+ h),
+ GNUNET_MQ_handler_end ()};
struct GNUNET_MQ_Envelope *env;
struct StartMessage *s;
uint32_t options;
h->reconnect_task = NULL;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Connecting to transport service.\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
GNUNET_assert (NULL == h->mq);
- h->mq = GNUNET_CLIENT_connecT (h->cfg,
- "transport",
- handlers,
- &mq_error_handler,
- h);
+ h->mq =
+ GNUNET_CLIENT_connect (h->cfg, "transport", handlers, &mq_error_handler, h);
if (NULL == h->mq)
return;
- env = GNUNET_MQ_msg (s,
- GNUNET_MESSAGE_TYPE_TRANSPORT_START);
+ env = GNUNET_MQ_msg (s, GNUNET_MESSAGE_TYPE_TRANSPORT_START);
options = 0;
if (h->check_self)
options |= 1;
- if (NULL != h->rec)
+ if (NULL != h->handlers)
options |= 2;
s->options = htonl (options);
s->self = h->self;
- GNUNET_MQ_send (h->mq,
- env);
+ GNUNET_MQ_send (h->mq, env);
}
* @param h transport service to reconnect
*/
static void
-disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_Handle *h)
+disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_CoreHandle *h)
{
GNUNET_assert (NULL == h->reconnect_task);
+ /* Forget about all neighbours that we used to be connected to */
+ GNUNET_CONTAINER_multipeermap_iterate (h->neighbours, &neighbour_delete, h);
if (NULL != h->mq)
{
GNUNET_MQ_destroy (h->mq);
h->mq = NULL;
}
- /* Forget about all neighbours that we used to be connected to */
- GNUNET_CONTAINER_multipeermap_iterate (h->neighbours,
- &neighbour_delete,
- h);
- if (NULL != h->quota_task)
- {
- GNUNET_SCHEDULER_cancel (h->quota_task);
- h->quota_task = NULL;
- }
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Scheduling task to reconnect to transport service in %s.\n",
- GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay,
- GNUNET_YES));
+ GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay, GNUNET_YES));
h->reconnect_task =
- GNUNET_SCHEDULER_add_delayed (h->reconnect_delay,
- &reconnect,
- h);
+ GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
}
* @return NULL if disconnected, otherwise message queue for @a peer
*/
struct GNUNET_MQ_Handle *
-GNUNET_TRANSPORT_core_get_mq (struct GNUNET_TRANSPORT_Handle *handle,
+GNUNET_TRANSPORT_core_get_mq (struct GNUNET_TRANSPORT_CoreHandle *handle,
const struct GNUNET_PeerIdentity *peer)
{
struct Neighbour *n;
- n = neighbour_find (handle,
- peer);
+ n = neighbour_find (handle, peer);
if (NULL == n)
return NULL;
return n->mq;
* @return NULL on error
*/
struct GNUNET_TRANSPORT_CoreHandle *
-GNUNET_TRANSPORT_connecT (const struct GNUNET_CONFIGURATION_Handle *cfg,
- const struct GNUNET_PeerIdentity *self,
- const struct GNUNET_MQ_MessageHandler *handlers,
- void *cls,
- GNUNET_TRANSPORT_NotifyConnect nc,
- GNUNET_TRANSPORT_NotifyDisconnect nd,
- GNUNET_TRANSPORT_NotifyExcessBandwidth neb)
+GNUNET_TRANSPORT_core_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+ const struct GNUNET_PeerIdentity *self,
+ const struct GNUNET_MQ_MessageHandler *handlers,
+ void *cls,
+ GNUNET_TRANSPORT_NotifyConnect nc,
+ GNUNET_TRANSPORT_NotifyDisconnect nd,
+ GNUNET_TRANSPORT_NotifyExcessBandwidth neb)
{
struct GNUNET_TRANSPORT_CoreHandle *h;
unsigned int i;
h->nd_cb = nd;
h->neb_cb = neb;
h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Connecting to transport service.\n");
+ if (NULL != handlers)
+ {
+ for (i = 0; NULL != handlers[i].cb; i++)
+ ;
+ h->handlers = GNUNET_new_array (i + 1, struct GNUNET_MQ_MessageHandler);
+ GNUNET_memcpy (h->handlers,
+ handlers,
+ i * sizeof (struct GNUNET_MQ_MessageHandler));
+ }
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service\n");
reconnect (h);
if (NULL == h->mq)
{
+ GNUNET_free_non_null (h->handlers);
GNUNET_free (h);
return NULL;
}
- if (NULL != handlers)
- {
- for (i=0;NULL != handlers[i].cb; i++) ;
- h->handlers = GNUNET_new_array (i + 1,
- struct GNUNET_MQ_MessageHandler);
- GNUNET_memcpy (h->handlers,
- handlers,
- i * sizeof (struct GNUNET_MQ_MessageHandler));
- }
h->neighbours =
- GNUNET_CONTAINER_multipeermap_create (STARTING_NEIGHBOURS_SIZE,
- GNUNET_YES);
+ GNUNET_CONTAINER_multipeermap_create (STARTING_NEIGHBOURS_SIZE, GNUNET_YES);
return h;
}
/**
* Disconnect from the transport service.
*
- * @param handle handle to the service as returned from #GNUNET_TRANSPORT_connect()
+ * @param handle handle to the service as returned from
+ * #GNUNET_TRANSPORT_core_connect()
*/
void
GNUNET_TRANSPORT_core_disconnect (struct GNUNET_TRANSPORT_CoreHandle *handle)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Transport disconnect called!\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Transport disconnect called!\n");
/* this disconnects all neighbours... */
if (NULL == handle->reconnect_task)
disconnect_and_schedule_reconnect (handle);
}
GNUNET_CONTAINER_multipeermap_destroy (handle->neighbours);
handle->neighbours = NULL;
- if (NULL != handle->quota_task)
- {
- GNUNET_SCHEDULER_cancel (handle->quota_task);
- handle->quota_task = NULL;
- }
GNUNET_free_non_null (handle->handlers);
handle->handlers = NULL;
GNUNET_free (handle);
projects / oweals / gnunet.git / blobdiff