*/
static struct GNUNET_CORE_Handle *core_handle;
+/**
+ * Handle to try to start new connections.
+ */
static struct GNUNET_TRANSPORT_Handle *transport_handle;
-
/******************************************************************************/
/***************************** CORE CALLBACKS *********************************/
/******************************************************************************/
}
else
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, "CONNECTED %s <= %s\n",
+ LOG (GNUNET_ERROR_TYPE_INFO, "CONNECTED %s <= %s\n",
own_id, GNUNET_i2s (peer));
path = path_new (2);
path->peers[1] = mp->id;
GNUNET_break (0);
}
- if (GMC_is_sendable (q->c, q->fwd))
- return GNUNET_YES;
+ if (GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN != q->type)
+ return GMC_is_sendable (q->c, q->fwd);
return GNUNET_NO;
}
queue = peer_get_first_message (peer);
if (NULL == queue)
{
- GNUNET_break (0); /* Core tmt_rdy should've been canceled */
+ GNUNET_assert (0); /* Core tmt_rdy should've been canceled */
return 0;
}
c = queue->c;
{
case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY:
case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN:
- case GNUNET_MESSAGE_TYPE_MESH_KEEPALIVE:
case GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED:
case GNUNET_MESSAGE_TYPE_MESH_KX:
case GNUNET_MESSAGE_TYPE_MESH_ACK:
}
+/**
+ * Get the first message for a connection and unqueue it.
+ *
+ * @param peer Neighboring peer.
+ * @param c Connection.
+ *
+ * @return First message for this connection.
+ */
+struct GNUNET_MessageHeader *
+GMP_connection_pop (struct MeshPeer *peer, struct MeshConnection *c)
+{
+ struct MeshPeerQueue *q;
+ struct GNUNET_MessageHeader *msg;
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Connection pop on %s\n", GMC_2s (c));
+ for (q = peer->queue_head; NULL != q; q = q->next)
+ {
+ if (q->c != c)
+ continue;
+ switch (q->type)
+ {
+ case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE:
+ case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK:
+ case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY:
+ case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN:
+ case GNUNET_MESSAGE_TYPE_MESH_ACK:
+ case GNUNET_MESSAGE_TYPE_MESH_POLL:
+ GMP_queue_destroy (q, GNUNET_YES);
+ continue;
+
+ case GNUNET_MESSAGE_TYPE_MESH_KX:
+ case GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED:
+ msg = (struct GNUNET_MessageHeader *) q->cls;
+ GMP_queue_destroy (q, GNUNET_NO);
+ return msg;
+
+ default:
+ GNUNET_break (0);
+ }
+ }
+
+ return NULL;
+}
+
+
void
GMP_queue_unlock (struct MeshPeer *peer, struct MeshConnection *c)
{
}
else
{
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "\n***************************************\n"
- "Mesh is running with drop mode enabled.\n"
- "This is NOT a good idea!\n"
- "Remove the DROP_PERCENT option from your configuration.\n"
- "***************************************\n");
+ LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
+ LOG (GNUNET_ERROR_TYPE_WARNING, "Mesh is running with DROP enabled.\n");
+ LOG (GNUNET_ERROR_TYPE_WARNING, "This is NOT a good idea!\n");
+ LOG (GNUNET_ERROR_TYPE_WARNING, "Remove DROP_PERCENT from config file.\n");
+ LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
}
core_handle = GNUNET_CORE_connect (c, /* Main configuration */
NULL, /* Don't notify about all outbound messages */
GNUNET_NO, /* For header-only out notification */
core_handlers); /* Register these handlers */
- transport_handle = GNUNET_TRANSPORT_connect (c, &my_full_id,
- NULL, /* cls */
- NULL, NULL, NULL); /* Notify callbacks */
+ if (GNUNET_YES !=
+ GNUNET_CONFIGURATION_get_value_yesno (c, "MESH", "DISABLE_TRY_CONNECT"))
+ {
+ transport_handle = GNUNET_TRANSPORT_connect (c, &my_full_id, NULL, /* cls */
+ /* Notify callbacks */
+ NULL, NULL, NULL);
+ }
+ else
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
+ LOG (GNUNET_ERROR_TYPE_WARNING, "* DISABLE TRYING CONNECT in config *\n");
+ LOG (GNUNET_ERROR_TYPE_WARNING, "* Use this only for test purposes. *\n");
+ LOG (GNUNET_ERROR_TYPE_WARNING, "**************************************\n");
+ }
+
+
- if (NULL == core_handle || NULL == transport_handle)
+ if (NULL == core_handle)
{
GNUNET_break (0);
GNUNET_SCHEDULER_shutdown ();
p = peer_get_best_path (peer);
if (NULL != p)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, " %u hops\n", p->length);
+ char *s;
+
+ s = path_2s (p);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " path to use: %s\n", s);
+ GNUNET_free (s);
+
c = GMT_use_path (t, p);
if (NULL == c)
{
path_destroy (path);
return NULL;
}
- if (2 >= path->length && GNUNET_NO == trusted)
- {
- /* Only allow CORE to tell us about direct paths */
- path_destroy (path);
- return NULL;
- }
+
for (l = 1; l < path->length; l++)
{
if (path->peers[l] == myid)
LOG (GNUNET_ERROR_TYPE_DEBUG, " final length: %u\n", path->length);
+ if (2 >= path->length && GNUNET_NO == trusted)
+ {
+ /* Only allow CORE to tell us about direct paths */
+ path_destroy (path);
+ return NULL;
+ }
+
l = path_get_length (path);
if (0 == l)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " added\n");
GNUNET_CONTAINER_DLL_insert_before (peer->path_head,
peer->path_tail, aux, path);
+ if (NULL != peer->tunnel && 3 < GMT_count_connections (peer->tunnel))
+ {
+ GMP_connect (peer);
+ }
return path;
}
else
GNUNET_CONTAINER_DLL_insert_tail (peer->path_head, peer->path_tail,
path);
LOG (GNUNET_ERROR_TYPE_DEBUG, " added last\n");
+ if (NULL != peer->tunnel && 3 < GMT_count_connections (peer->tunnel))
+ {
+ GMP_connect (peer);
+ }
return path;
}
sizeof (GNUNET_PEER_Id) * path->length))
{
GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, iter);
- path_destroy (iter);
- if (path == iter)
- return;
+ if (iter != path)
+ path_destroy (iter);
}
}
path_destroy (path);
struct GNUNET_HELLO_Message *hello;
struct GNUNET_MessageHeader *mh;
+ if (NULL == transport_handle)
+ return;
+
hello = GMP_get_hello (peer);
if (NULL == hello)
return;
}
+/**
+ * Notify a peer that a link between two other peers is broken. If any path
+ * used that link, eliminate it.
+ *
+ * @param peer Peer affected by the change.
+ * @param peer1 Peer whose link is broken.
+ * @param peer2 Peer whose link is broken.
+ */
+void
+GMP_notify_broken_link (struct MeshPeer *peer,
+ struct GNUNET_PeerIdentity *peer1,
+ struct GNUNET_PeerIdentity *peer2)
+{
+ struct MeshPeerPath *iter;
+ struct MeshPeerPath *next;
+ unsigned int i;
+ GNUNET_PEER_Id p1;
+ GNUNET_PEER_Id p2;
+
+ p1 = GNUNET_PEER_search (peer1);
+ p2 = GNUNET_PEER_search (peer2);
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Link %u-%u broken\n", p1, p2);
+ if (0 == p1 || 0 == p2)
+ {
+ /* We don't even know them */
+ return;
+ }
+
+ for (iter = peer->path_head; NULL != iter; iter = next)
+ {
+ next = iter->next;
+ for (i = 0; i < iter->length - 1; i++)
+ {
+ if ((iter->peers[i] == p1 && iter->peers[i + 1] == p2)
+ || (iter->peers[i] == p2 && iter->peers[i + 1] == p1))
+ {
+ char *s;
+
+ s = path_2s (iter);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " - invalidating %s\n", s);
+ GNUNET_free (s);
+
+ path_invalidate (iter);
+ }
+ }
+ }
+}
+
+
/**
* Count the number of known paths toward the peer.
*
projects / oweals / gnunet.git / blobdiff