/*
This file is part of GNUnet.
- Copyright (C) 2013, 2015 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2013, 2015 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
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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
* @file cadet/gnunet-service-cadet_peer.c
#include "gnunet_util_lib.h"
#include "gnunet_signatures.h"
#include "gnunet_transport_service.h"
+#include "gnunet_ats_service.h"
#include "gnunet_core_service.h"
#include "gnunet_statistics_service.h"
#include "cadet_protocol.h"
* Hello message.
*/
struct GNUNET_HELLO_Message* hello;
+
+ /**
+ * Handle to us offering the HELLO to the transport.
+ */
+ struct GNUNET_TRANSPORT_OfferHelloHandle *hello_offer;
+
+ /**
+ * Handle to our ATS request asking ATS to suggest an address
+ * to TRANSPORT for this peer (to establish a direct link).
+ */
+ struct GNUNET_ATS_ConnectivitySuggestHandle *connectivity_suggestion;
+
};
static unsigned long long drop_percent;
/**
- * Handle to communicate with core.
+ * Handle to communicate with CORE.
*/
static struct GNUNET_CORE_Handle *core_handle;
+/**
+ * Handle to communicate with ATS.
+ */
+static struct GNUNET_ATS_ConnectivityHandle *ats_ch;
+
/**
* Handle to try to start new connections.
*/
static struct GNUNET_TRANSPORT_Handle *transport_handle;
+/**
+ * Shutdown falg.
+ */
+static int in_shutdown;
+
/******************************************************************************/
/***************************** DEBUG *********************************/
* Iterator to notify all connections of a broken link. Mark connections
* to destroy after all traffic has been sent.
*
- * @param cls Closure (peer disconnected).
+ * @param cls Closure (disconnected peer).
* @param key Current key code (peer id).
* @param value Value in the hash map (connection).
*
struct CadetConnection *c = value;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Notifying %s due to %s\n",
- GCC_2s (c),
- GCP_2s (peer));
- GCC_notify_broken (c,
- peer);
+ "Notifying %s due to %s disconnect\n",
+ GCC_2s (c), GCP_2s (peer));
+ GCC_neighbor_disconnected (c, peer);
return GNUNET_YES;
}
* Remove the direct path to the peer.
*
* @param peer Peer to remove the direct path from.
- *
*/
static struct CadetPeerPath *
pop_direct_path (struct CadetPeer *peer)
{
if (2 >= iter->length)
{
- GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, iter);
+ GNUNET_CONTAINER_DLL_remove (peer->path_head,
+ peer->path_tail,
+ iter);
return iter;
}
}
core_connect (void *cls,
const struct GNUNET_PeerIdentity *peer)
{
- struct CadetPeer *mp;
+ struct CadetPeer *neighbor;
struct CadetPeerPath *path;
char own_id[16];
+ GCC_check_connections ();
GNUNET_snprintf (own_id,
sizeof (own_id),
"%s",
GNUNET_i2s (&my_full_id));
- mp = GCP_get (peer);
- if (myid == mp->id)
+ neighbor = GCP_get (peer, GNUNET_YES);
+ if (myid == neighbor->id)
{
LOG (GNUNET_ERROR_TYPE_INFO,
"CONNECTED %s (self)\n",
own_id,
GNUNET_i2s (peer));
path = path_new (2);
- path->peers[1] = mp->id;
- GNUNET_PEER_change_rc (mp->id, 1);
+ path->peers[1] = neighbor->id;
+ GNUNET_PEER_change_rc (neighbor->id, 1);
}
path->peers[0] = myid;
GNUNET_PEER_change_rc (myid, 1);
- GCP_add_path (mp, path, GNUNET_YES);
+ GCP_add_path (neighbor, path, GNUNET_YES);
+
+ GNUNET_assert (NULL == neighbor->connections);
+ neighbor->connections = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
GNUNET_STATISTICS_update (stats,
"# peers",
1,
GNUNET_NO);
- GNUNET_assert (NULL == mp->connections);
- mp->connections = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
- if ( (NULL != GCP_get_tunnel (mp)) &&
+ if ( (NULL != GCP_get_tunnel (neighbor)) &&
(0 > GNUNET_CRYPTO_cmp_peer_identity (&my_full_id, peer)) )
- GCP_connect (mp);
+ GCP_connect (neighbor);
+ GCC_check_connections ();
}
struct CadetPeerPath *direct_path;
char own_id[16];
- strncpy (own_id, GNUNET_i2s (&my_full_id), 15);
+ GCC_check_connections ();
+ strncpy (own_id, GNUNET_i2s (&my_full_id), 16);
+ own_id[15] = '\0';
p = GNUNET_CONTAINER_multipeermap_get (peers, peer);
if (NULL == p)
{
- GNUNET_break (0);
+ GNUNET_break (GNUNET_YES == in_shutdown);
return;
}
if (myid == p->id)
"DISCONNECTED %s <= %s\n",
own_id, GNUNET_i2s (peer));
direct_path = pop_direct_path (p);
- GNUNET_CONTAINER_multihashmap_iterate (p->connections,
- ¬ify_broken,
- p);
- GNUNET_CONTAINER_multihashmap_destroy (p->connections);
- p->connections = NULL;
+ if (NULL != p->connections)
+ {
+ GNUNET_CONTAINER_multihashmap_iterate (p->connections,
+ ¬ify_broken,
+ p);
+ GNUNET_CONTAINER_multihashmap_destroy (p->connections);
+ p->connections = NULL;
+ }
if (NULL != p->core_transmit)
{
GNUNET_CORE_notify_transmit_ready_cancel (p->core_transmit);
-1,
GNUNET_NO);
path_destroy (direct_path);
+ GCC_check_connections ();
}
"destroying peer %s\n",
GNUNET_i2s (&id));
- if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove (peers, &id, peer))
+ if (GNUNET_YES !=
+ GNUNET_CONTAINER_multipeermap_remove (peers, &id, peer))
{
GNUNET_break (0);
LOG (GNUNET_ERROR_TYPE_WARNING, " peer not in peermap!!\n");
while (NULL != p)
{
nextp = p->next;
- GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, p);
+ GNUNET_CONTAINER_DLL_remove (peer->path_head,
+ peer->path_tail,
+ p);
path_destroy (p);
p = nextp;
}
{
GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (peer->connections));
GNUNET_CONTAINER_multihashmap_destroy (peer->connections);
+ peer->connections = NULL;
+ }
+ if (NULL != peer->hello_offer)
+ {
+ GNUNET_TRANSPORT_offer_hello_cancel (peer->hello_offer);
+ peer->hello_offer = NULL;
+ }
+ if (NULL != peer->connectivity_suggestion)
+ {
+ GNUNET_ATS_connectivity_suggest_cancel (peer->connectivity_suggestion);
+ peer->connectivity_suggestion = NULL;
+ }
+ while (NULL != peer->queue_head)
+ {
+ GCP_queue_destroy (peer->queue_head, GNUNET_YES, GNUNET_NO, 0);
}
+ if (NULL != peer->core_transmit)
+ {
+ GNUNET_break (0); /* GCP_queue_destroy should've cancelled it! */
+ GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit);
+ peer->core_transmit = NULL;
+ }
+
GNUNET_free_non_null (peer->hello);
GNUNET_free (peer);
return GNUNET_OK;
/**
- * Iterator over peer hash map entries to destroy the peer during shutdown.
+ * Iterator over peer hash map entries to destroy the peer during in_shutdown.
*
* @param cls closure
* @param key current key code
struct CadetPeer *p = value;
struct CadetTunnel *t = p->tunnel;
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " shutting down %s\n", GCP_2s (p));
if (NULL != t)
GCT_destroy (t);
p->tunnel = NULL;
static int
is_searching (const struct CadetPeer *peer)
{
- return (NULL == peer->search_h && NULL == peer->search_delayed) ?
- GNUNET_NO : GNUNET_YES;
+ return ( (NULL == peer->search_h) &&
+ (NULL == peer->search_delayed) ) ?
+ GNUNET_NO : GNUNET_YES;
}
* @brief Start a search for a peer.
*
* @param cls Closure (Peer to search for).
- * @param tc Task context.
*/
static void
-delayed_search (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+delayed_search (void *cls)
{
struct CadetPeer *peer = cls;
peer->search_delayed = NULL;
-
- if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
- return;
-
+ GCC_check_connections ();
GCP_start_search (peer);
+ GCC_check_connections ();
}
* paths form the initial tunnel, which can be optimized later.
* Called on each result obtained for the DHT search.
*
- * @param cls closure
- * @param path
+ * @param cls Closure (peer towards a path has been found).
+ * @param path Path created from the DHT query. Will be freed afterwards.
*/
static void
search_handler (void *cls, const struct CadetPeerPath *path)
struct CadetPeer *peer = cls;
unsigned int connection_count;
+ GCC_check_connections ();
GCP_add_path_to_all (path, GNUNET_NO);
/* Count connections */
/* If we already have our minimum (or more) connections, it's enough */
if (CONNECTIONS_PER_TUNNEL <= connection_count)
+ {
+ GCC_check_connections ();
return;
+ }
if (CADET_TUNNEL_SEARCHING == GCT_get_cstate (peer->tunnel))
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " ... connect!\n");
GCP_connect (peer);
}
+ GCC_check_connections ();
}
return message_size + sizeof (struct GNUNET_CADET_ACK);
}
+/**
+ * Test if a message type is connection management traffic
+ * or regular payload traffic.
+ *
+ * @param type Message type.
+ *
+ * @return #GNUNET_YES if connection management, #GNUNET_NO otherwise.
+ */
+static int
+is_connection_management (uint16_t type)
+{
+ return type == GNUNET_MESSAGE_TYPE_CADET_ACK ||
+ type == GNUNET_MESSAGE_TYPE_CADET_POLL;
+}
+
/**
* Fill a core buffer with the appropriate data for the queued message.
}
+/**
+ * Debug function should NEVER return true in production code, useful to
+ * simulate losses for testcases.
+ *
+ * @param q Queue handle with info about the message.
+ *
+ * @return #GNUNET_YES or #GNUNET_NO with the decision to drop.
+ */
+static int
+should_I_drop (struct CadetPeerQueue *q)
+{
+ if (0 == drop_percent)
+ return GNUNET_NO;
+
+ if (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 101) < drop_percent)
+ return GNUNET_YES;
+
+ return GNUNET_NO;
+}
+
+
/**
* Core callback to write a queued packet to core buffer
*
struct CadetConnection *c;
struct CadetPeerQueue *queue;
struct GNUNET_TIME_Relative core_wait_time;
+ const char *wait_s;
const struct GNUNET_PeerIdentity *dst_id;
size_t msg_size;
size_t total_size;
char *dst;
uint32_t pid;
+ GCC_check_connections ();
LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
LOG (GNUNET_ERROR_TYPE_DEBUG, "\n");
LOG (GNUNET_ERROR_TYPE_DEBUG, "Queue send towards %s (max %u)\n",
/* Sanity checking */
if (NULL == buf || 0 == size)
{
- GNUNET_break (0);
- LOG (GNUNET_ERROR_TYPE_WARNING, "CORE gave buffer size 0.\n");
- peer->tmt_time.abs_value_us = 0;
- peer->core_transmit = NULL;
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " not allowed/\n");
+ if (GNUNET_NO == in_shutdown)
+ {
+ queue = peer_get_first_message (peer);
+ if (NULL == queue)
+ {
+ peer->core_transmit = NULL;
+ peer->tmt_time.abs_value_us = 0;
+ GCC_check_connections ();
+ return 0;
+ }
+ dst_id = GNUNET_PEER_resolve2 (peer->id);
+ peer->core_transmit =
+ GNUNET_CORE_notify_transmit_ready (core_handle,
+ GNUNET_NO, get_priority (queue),
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ dst_id,
+ get_core_size (queue->size),
+ &queue_send,
+ peer);
+ peer->tmt_time = GNUNET_TIME_absolute_get ();
+ }
+ else
+ {
+ peer->core_transmit = NULL;
+ peer->tmt_time.abs_value_us = 0;
+ }
+ GCC_check_connections ();
return 0;
}
return 0;
}
core_wait_time = GNUNET_TIME_absolute_get_duration (peer->tmt_time);
+ wait_s = GNUNET_STRINGS_relative_time_to_string (core_wait_time, GNUNET_YES);
if (core_wait_time.rel_value_us >= 1000000)
{
- LOG (GNUNET_ERROR_TYPE_ERROR, " core wait time %s > 1 second\n",
- GNUNET_STRINGS_relative_time_to_string (core_wait_time, GNUNET_NO));
- }
- else
- {
- LOG (GNUNET_ERROR_TYPE_DEBUG, " core wait time %s\n",
- GNUNET_STRINGS_relative_time_to_string (core_wait_time, GNUNET_NO));
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ " %s: core wait time %s (> 1 second) for %u bytes\n",
+ GCP_2s (peer), wait_s, queue->size);
}
peer->tmt_time.abs_value_us = 0;
{
c = queue->c;
- LOG (GNUNET_ERROR_TYPE_DEBUG, " on connection %s %s\n",
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " on conn %s %s\n",
GCC_2s (c), GC_f2s(queue->fwd));
LOG (GNUNET_ERROR_TYPE_DEBUG, " size %u ok (%u/%u)\n",
queue->size, total_size, size);
msg_size = fill_buf (queue, (void *) dst, size, &pid);
- if (0 < drop_percent &&
- GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 101) < drop_percent)
+ if (should_I_drop (queue))
{
- LOG (GNUNET_ERROR_TYPE_WARNING, "DD %s (%s %u) on connection %s %s\n",
+ LOG (GNUNET_ERROR_TYPE_WARNING, "DD %s (%s %u) on conn %s %s\n",
GC_m2s (queue->type), GC_m2s (queue->payload_type),
queue->payload_id, GCC_2s (c), GC_f2s (queue->fwd));
msg_size = 0;
else
{
LOG (GNUNET_ERROR_TYPE_INFO,
- "snd %s (%s %4u) on connection %s (%p) %s (size %u)\n",
+ ">>> %s (%s %4u) on conn %s (%p) %s [%5u], after %s\n",
GC_m2s (queue->type), GC_m2s (queue->payload_type),
- queue->payload_id, GCC_2s (c), c, GC_f2s (queue->fwd), msg_size);
+ queue->payload_id, GCC_2s (c), c,
+ GC_f2s (queue->fwd), msg_size, wait_s);
}
total_size += msg_size;
rest -= msg_size;
LOG (GNUNET_ERROR_TYPE_DEBUG, " return %d\n", total_size);
queue_debug (peer, GNUNET_ERROR_TYPE_DEBUG);
-
+ GCC_check_connections ();
return total_size;
}
* #GNUNET_NO otherwise.
*/
int
-GCP_queue_destroy (struct CadetPeerQueue *queue, int clear_cls,
- int sent, uint32_t pid)
+GCP_queue_destroy (struct CadetPeerQueue *queue,
+ int clear_cls,
+ int sent,
+ uint32_t pid)
{
struct CadetPeer *peer;
int connection_destroyed;
+ GCC_check_connections ();
peer = queue->peer;
LOG (GNUNET_ERROR_TYPE_DEBUG, "queue destroy %s\n", GC_m2s (queue->type));
if (GNUNET_YES == clear_cls)
}
GNUNET_CONTAINER_DLL_remove (peer->queue_head, peer->queue_tail, queue);
- if (queue->type != GNUNET_MESSAGE_TYPE_CADET_ACK &&
- queue->type != GNUNET_MESSAGE_TYPE_CADET_POLL)
+ if (!is_connection_management (queue->type))
{
peer->queue_n--;
}
}
GNUNET_free (queue);
+ GCC_check_connections ();
return connection_destroyed;
}
* @param peer Peer towards which to queue the message.
* @param cls Closure (@c type dependant). It will be used by queue_send to
* build the message to be sent if not already prebuilt.
- * @param type Type of the message, 0 for a raw message.
+ * @param type Type of the message.
+ * @param payload_type Type of the message's payload
+ * 0 if the message is a retransmission (unknown payload).
+ * UINT16_MAX if the message does not have payload.
+ * @param payload_id ID of the payload (MID, ACK #, etc)
* @param size Size of the message.
* @param c Connection this message belongs to (can be NULL).
* @param fwd Is this a message going root->dest? (FWD ACK are NOT FWD!)
* message has been sent and therefore the handle is no longer valid.
*/
struct CadetPeerQueue *
-GCP_queue_add (struct CadetPeer *peer, void *cls, uint16_t type,
- uint16_t payload_type, uint32_t payload_id, size_t size,
- struct CadetConnection *c, int fwd,
- GCP_sent cont, void *cont_cls)
+GCP_queue_add (struct CadetPeer *peer,
+ void *cls,
+ uint16_t type,
+ uint16_t payload_type,
+ uint32_t payload_id,
+ size_t size,
+ struct CadetConnection *c,
+ int fwd,
+ GCP_sent cont,
+ void *cont_cls)
{
struct CadetPeerQueue *q;
- int error_level;
int priority;
int call_core;
- if (NULL == c && GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN != type)
- error_level = GNUNET_ERROR_TYPE_ERROR;
- else
- error_level = GNUNET_ERROR_TYPE_INFO;
- LOG (error_level,
- "que %s (%s %4u) on connection %s (%p) %s towards %s (size %u)\n",
+ GCC_check_connections ();
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "que %s (%s %4u) on conn %s (%p) %s towards %s (size %u)\n",
GC_m2s (type), GC_m2s (payload_type), payload_id,
GCC_2s (c), c, GC_f2s (fwd), GCP_2s (peer), size);
- if (error_level == GNUNET_ERROR_TYPE_ERROR)
- GNUNET_assert (0);
if (NULL == peer->connections)
{
/* We are not connected to this peer, ignore request. */
}
priority = 0;
-
- if (GNUNET_MESSAGE_TYPE_CADET_POLL == type ||
- GNUNET_MESSAGE_TYPE_CADET_ACK == type)
+ if (is_connection_management (type))
{
priority = 100;
}
-
LOG (GNUNET_ERROR_TYPE_DEBUG, "priority %d\n", priority);
- call_core = (NULL == c || type == GNUNET_MESSAGE_TYPE_CADET_KX) ?
+ call_core = (NULL == c || GNUNET_MESSAGE_TYPE_CADET_KX == type) ?
GNUNET_YES : GCC_is_sendable (c, fwd);
q = GNUNET_new (struct CadetPeerQueue);
q->cls = cls;
}
queue_debug (peer, GNUNET_ERROR_TYPE_DEBUG);
+ GCC_check_connections ();
return q;
}
* the sent continuation call.
*/
void
-GCP_queue_cancel (struct CadetPeer *peer, struct CadetConnection *c)
+GCP_queue_cancel (struct CadetPeer *peer,
+ struct CadetConnection *c)
{
struct CadetPeerQueue *q;
struct CadetPeerQueue *next;
struct CadetPeerQueue *prev;
int connection_destroyed;
+ GCC_check_connections ();
connection_destroyed = GNUNET_NO;
for (q = peer->queue_head; NULL != q; q = next)
{
prev = q->prev;
if (q->c == c)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, "GMP queue cancel %s\n", GC_m2s (q->type));
- GNUNET_break (GNUNET_NO == connection_destroyed);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "GMP queue cancel %s\n",
+ GC_m2s (q->type));
+ GNUNET_assert (GNUNET_NO == connection_destroyed);
if (GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY == q->type)
{
q->c = NULL;
}
}
- if (NULL == peer->queue_head && NULL != peer->core_transmit)
+ if ( (NULL == peer->queue_head) &&
+ (NULL != peer->core_transmit) )
{
GNUNET_CORE_notify_transmit_ready_cancel (peer->core_transmit);
peer->core_transmit = NULL;
peer->tmt_time.abs_value_us = 0;
}
+ GCC_check_connections ();
}
struct GNUNET_MessageHeader *msg;
int dest;
+ GCC_check_connections ();
GNUNET_assert (NULL != destroyed);
- LOG (GNUNET_ERROR_TYPE_DEBUG, "connection_pop on connection %p\n", c);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "connection_pop on conn %p\n", c);
for (q = peer->queue_head; NULL != q; q = next)
{
next = q->next;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Unknown message %s\n", GC_m2s (q->type));
}
}
-
+ GCC_check_connections ();
return NULL;
}
+
/**
* Unlock a possibly locked queue for a connection.
*
struct CadetPeerQueue *q;
size_t size;
+ GCC_check_connections ();
if (NULL != peer->core_transmit)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " already unlocked!\n");
&queue_send,
peer);
peer->tmt_time = GNUNET_TIME_absolute_get ();
+ GCC_check_connections ();
}
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"GCP_init\n");
+ in_shutdown = GNUNET_NO;
peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (c, "CADET", "MAX_PEERS",
LOG (GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n");
LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
}
-
+ ats_ch = GNUNET_ATS_connectivity_init (c);
core_handle = GNUNET_CORE_connect (c, /* Main configuration */
NULL, /* Closure passed to CADET functions */
&core_init, /* Call core_init once connected */
void
GCP_shutdown (void)
{
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Shutting down peer subsystem\n");
+ in_shutdown = GNUNET_YES;
GNUNET_CONTAINER_multipeermap_iterate (peers,
&shutdown_peer,
NULL);
GNUNET_TRANSPORT_disconnect (transport_handle);
transport_handle = NULL;
}
+ if (NULL != ats_ch)
+ {
+ GNUNET_ATS_connectivity_done (ats_ch);
+ ats_ch = NULL;
+ }
GNUNET_PEER_change_rc (myid, -1);
GNUNET_CONTAINER_multipeermap_destroy (peers);
peers = NULL;
/**
- * Retrieve the CadetPeer stucture associated with the peer, create one
- * and insert it in the appropriate structures if the peer is not known yet.
+ * Retrieve the CadetPeer stucture associated with the peer. Optionally create
+ * one and insert it in the appropriate structures if the peer is not known yet.
*
* @param peer_id Full identity of the peer.
+ * @param create #GNUNET_YES if a new peer should be created if unknown.
+ * #GNUNET_NO otherwise.
*
* @return Existing or newly created peer structure.
+ * NULL if unknown and not requested @a create
*/
struct CadetPeer *
-GCP_get (const struct GNUNET_PeerIdentity *peer_id)
+GCP_get (const struct GNUNET_PeerIdentity *peer_id, int create)
{
struct CadetPeer *peer;
/**
- * Retrieve the CadetPeer stucture associated with the peer, create one
- * and insert it in the appropriate structures if the peer is not known yet.
+ * Retrieve the CadetPeer stucture associated with the
+ * peer. Optionally create one and insert it in the appropriate
+ * structures if the peer is not known yet.
*
* @param peer Short identity of the peer.
+ * @param create #GNUNET_YES if a new peer should be created if unknown.
+ * #GNUNET_NO otherwise.
*
* @return Existing or newly created peer structure.
+ * NULL if unknown and not requested @a create
*/
struct CadetPeer *
-GCP_get_short (const GNUNET_PEER_Id peer)
+GCP_get_short (const GNUNET_PEER_Id peer, int create)
{
- return GCP_get (GNUNET_PEER_resolve2 (peer));
+ return GCP_get (GNUNET_PEER_resolve2 (peer), create);
}
/**
- * Try to connect to a peer on transport level.
+ * Function called once #GNUNET_TRANSPORT_offer_hello() is done.
+ * Marks the operation as finished.
*
- * @param cls Closure (peer).
- * @param tc TaskContext.
+ * @param cls Closure (our `struct CadetPeer`).
*/
static void
-try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+hello_offer_done (void *cls)
{
struct CadetPeer *peer = cls;
- if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
- return;
-
- GNUNET_TRANSPORT_try_connect (transport_handle,
- GNUNET_PEER_resolve2 (peer->id), NULL, NULL);
+ peer->hello_offer = NULL;
}
GCP_connect (struct CadetPeer *peer)
{
struct CadetTunnel *t;
- struct CadetPeerPath *p;
+ struct CadetPeerPath *path;
struct CadetConnection *c;
int rerun_search;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "peer_connect towards %s\n", GCP_2s (peer));
-
+ GCC_check_connections ();
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "peer_connect towards %s\n",
+ GCP_2s (peer));
/* If we have a current hello, try to connect using it. */
GCP_try_connect (peer);
if (NULL != peer->path_head)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " some path exists\n");
- p = peer_get_best_path (peer);
- if (NULL != p)
+ path = peer_get_best_path (peer);
+ if (NULL != path)
{
char *s;
- s = path_2s (p);
+ s = path_2s (path);
LOG (GNUNET_ERROR_TYPE_DEBUG, " path to use: %s\n", s);
GNUNET_free (s);
- c = GCT_use_path (t, p);
+ c = GCT_use_path (t, path);
if (NULL == c)
{
/* This case can happen when the path includes a first hop that is
* This happens quite often during testing when running cadet
* under valgrind: core connect notifications come very late
* and the DHT result has already come and created a valid
- * path. In this case, the peer->connections_{pred,succ}
+ * path. In this case, the peer->connections
* hashmaps will be NULL and tunnel_use_path will not be able
* to create a connection from that path.
*
GCP_stop_search (peer);
delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100);
- peer->search_delayed = GNUNET_SCHEDULER_add_delayed (delay, &delayed_search,
+ peer->search_delayed = GNUNET_SCHEDULER_add_delayed (delay,
+ &delayed_search,
peer);
+ GCC_check_connections ();
return;
}
if (GNUNET_NO == is_searching (peer))
GCP_start_search (peer);
+ GCC_check_connections ();
}
}
/* Is not a neighbor but connections is not NULL, probably disconnecting */
+ GNUNET_break (0);
return GNUNET_NO;
}
void
GCP_add_tunnel (struct CadetPeer *peer)
{
+ GCC_check_connections ();
if (NULL != peer->tunnel)
return;
peer->tunnel = GCT_new (peer);
+ GCC_check_connections ();
}
* is the shortest.
*
* @param peer Destination peer to add the path to.
- * @param path New path to add. Last peer must be the peer in arg 1.
+ * @param path New path to add. Last peer must be @c peer.
* Path will be either used of freed if already known.
* @param trusted Do we trust that this path is real?
*
* NULL on error.
*/
struct CadetPeerPath *
-GCP_add_path (struct CadetPeer *peer, struct CadetPeerPath *path,
+GCP_add_path (struct CadetPeer *peer,
+ struct CadetPeerPath *path,
int trusted)
{
struct CadetPeerPath *aux;
unsigned int l;
unsigned int l2;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "adding path [%u] to peer %s\n",
+ GCC_check_connections ();
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "adding path [%u] to peer %s\n",
path->length, GCP_2s (peer));
if (NULL == peer || NULL == path
}
}
}
- GNUNET_CONTAINER_DLL_insert_tail (peer->path_head, peer->path_tail,
+ GNUNET_CONTAINER_DLL_insert_tail (peer->path_head,
+ peer->path_tail,
path);
LOG (GNUNET_ERROR_TYPE_DEBUG, " added last\n");
finish:
if (NULL != peer->tunnel
- && CONNECTIONS_PER_TUNNEL < GCT_count_connections (peer->tunnel))
+ && CONNECTIONS_PER_TUNNEL > GCT_count_connections (peer->tunnel)
+ && 2 < path->length) /* Direct paths are handled by core_connect */
{
GCP_connect (peer);
}
+ GCC_check_connections ();
return path;
}
unsigned int i;
/* TODO: invert and add */
+ GCC_check_connections ();
for (i = 0; i < p->length && p->peers[i] != myid; i++) /* skip'em */ ;
for (i++; i < p->length; i++)
{
- struct CadetPeer *aux;
+ struct CadetPeer *peer;
struct CadetPeerPath *copy;
- aux = GCP_get_short (p->peers[i]);
+ peer = GCP_get_short (p->peers[i], GNUNET_YES);
copy = path_duplicate (p);
copy->length = i + 1;
- GCP_add_path (aux, copy, p->length < 3 ? GNUNET_NO : confirmed);
+ GCP_add_path (peer, copy, 3 > p->length ? GNUNET_NO : confirmed);
}
+ GCC_check_connections ();
}
/**
- * Remove any path to the peer that has the extact same peers as the one given.
+ * Remove any path to the peer that has the exact same peers as the one given.
*
* @param peer Peer to remove the path from.
* @param path Path to remove. Is always destroyed .
*/
void
-GCP_remove_path (struct CadetPeer *peer, struct CadetPeerPath *path)
+GCP_remove_path (struct CadetPeer *peer,
+ struct CadetPeerPath *path)
{
struct CadetPeerPath *iter;
struct CadetPeerPath *next;
+ GCC_check_connections ();
GNUNET_assert (myid == path->peers[0]);
GNUNET_assert (peer->id == path->peers[path->length - 1]);
LOG (GNUNET_ERROR_TYPE_INFO,
"Removing path %p (%u) from %s\n",
- path,
- path->length,
- GCP_2s (peer));
+ path, path->length, GCP_2s (peer));
for (iter = peer->path_head; NULL != iter; iter = next)
{
next = iter->next;
if (0 == path_cmp (path, iter))
{
- GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, iter);
+ GNUNET_CONTAINER_DLL_remove (peer->path_head,
+ peer->path_tail,
+ iter);
if (iter != path)
path_destroy (iter);
}
}
path_destroy (path);
+ GCC_check_connections ();
+}
+
+
+/**
+ * Check that we are aware of a connection from a neighboring peer.
+ *
+ * @param peer Peer to the connection is with
+ * @param c Connection that should be in the map with this peer.
+ */
+void
+GCP_check_connection (const struct CadetPeer *peer,
+ const struct CadetConnection *c)
+{
+ GNUNET_assert (NULL != peer);
+ GNUNET_assert (NULL != peer->connections);
+ return;
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_CONTAINER_multihashmap_contains_value (peer->connections,
+ GCC_get_h (c),
+ c));
}
const struct GNUNET_PeerIdentity *id;
struct CadetTunnel *t = peer->tunnel;
- if (NULL != peer->search_h)
+ GCC_check_connections ();
+ if (NULL != peer->search_h)
{
GNUNET_break (0);
return;
{
GCT_change_cstate (t, CADET_TUNNEL_SEARCHING);
}
+ GCC_check_connections ();
}
void
GCP_stop_search (struct CadetPeer *peer)
{
+ GCC_check_connections ();
if (NULL != peer->search_h)
{
GCD_search_stop (peer->search_h);
GNUNET_SCHEDULER_cancel (peer->search_delayed);
peer->search_delayed = NULL;
}
+ GCC_check_connections ();
}
struct CadetTunnel *
GCP_get_tunnel (const struct CadetPeer *peer)
{
+ if (NULL == peer)
+ return NULL;
return peer->tunnel;
}
* @param hello Hello message.
*/
void
-GCP_set_hello (struct CadetPeer *peer, const struct GNUNET_HELLO_Message *hello)
+GCP_set_hello (struct CadetPeer *peer,
+ const struct GNUNET_HELLO_Message *hello)
{
struct GNUNET_HELLO_Message *old;
size_t size;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "set hello for %s\n", GCP_2s (peer));
+ GCC_check_connections ();
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "set hello for %s\n", GCP_2s (peer));
if (NULL == hello)
return;
if (NULL == old)
{
size = GNUNET_HELLO_size (hello);
- LOG (GNUNET_ERROR_TYPE_DEBUG, " new (%u bytes)\n", size);
peer->hello = GNUNET_malloc (size);
memcpy (peer->hello, hello, size);
}
else
{
peer->hello = GNUNET_HELLO_merge (old, hello);
- LOG (GNUNET_ERROR_TYPE_DEBUG, " merge into %p (%u bytes)\n",
- peer->hello, GNUNET_HELLO_size (hello));
GNUNET_free (old);
}
+ GCC_check_connections ();
}
if (NULL == transport_handle)
return;
-
+ GCC_check_connections ();
+ if (GNUNET_YES == GCP_is_neighbor (peer))
+ return;
hello = GCP_get_hello (peer);
if (NULL == hello)
return;
mh = GNUNET_HELLO_get_header (hello);
- GNUNET_TRANSPORT_offer_hello (transport_handle, mh, try_connect, peer);
+ if (NULL != peer->hello_offer)
+ {
+ GNUNET_TRANSPORT_offer_hello_cancel (peer->hello_offer);
+ peer->hello_offer = NULL;
+ }
+ peer->hello_offer = GNUNET_TRANSPORT_offer_hello (transport_handle,
+ mh,
+ &hello_offer_done,
+ peer);
+ if (NULL == peer->connectivity_suggestion)
+ peer->connectivity_suggestion
+ = GNUNET_ATS_connectivity_suggest (ats_ch,
+ GNUNET_PEER_resolve2 (peer->id),
+ 1 /* strength */);
+ GCC_check_connections ();
}
*/
void
GCP_notify_broken_link (struct CadetPeer *peer,
- struct GNUNET_PeerIdentity *peer1,
- struct GNUNET_PeerIdentity *peer2)
+ const struct GNUNET_PeerIdentity *peer1,
+ const struct GNUNET_PeerIdentity *peer2)
{
struct CadetPeerPath *iter;
struct CadetPeerPath *next;
GNUNET_PEER_Id p1;
GNUNET_PEER_Id p2;
+ GCC_check_connections ();
p1 = GNUNET_PEER_search (peer1);
p2 = GNUNET_PEER_search (peer2);
}
}
}
+ GCC_check_connections ();
}
}
+/**
+ * Iterate over the paths to a peer.
+ *
+ * @param peer Peer to get path info.
+ * @param callback Function to call for every path.
+ * @param cls Closure for @a callback.
+ *
+ * @return Number of iterated paths.
+ */
+unsigned int
+GCP_iterate_paths (struct CadetPeer *peer,
+ GCP_path_iterator callback,
+ void *cls)
+{
+ struct CadetPeerPath *iter;
+ unsigned int i;
+
+ for (iter = peer->path_head, i = 0; NULL != iter; iter = iter->next)
+ {
+ i++;
+ if (GNUNET_YES != callback (cls, peer, iter))
+ break;
+ }
+
+ return i;
+}
+
+
/**
* Iterate all known peers.
*
GCP_iterate_all (GNUNET_CONTAINER_PeerMapIterator iter,
void *cls)
{
+ GCC_check_connections ();
GNUNET_CONTAINER_multipeermap_iterate (peers,
iter,
cls);
+ GCC_check_connections ();
}
return "(NULL)";
return GNUNET_i2s (GNUNET_PEER_resolve2 (peer->id));
}
+
+
+/* end of gnunet-service-cadet_peer.c */