extern struct GNUNET_PeerIdentity my_full_id;
+/**
+ * Don't try to recover tunnels if shutting down.
+ */
+extern int shutting_down;
+
+
/**
* Set of all tunnels, in order to trigger a new exchange on rekey.
* Indexed by peer's ID.
static int
is_ready (struct MeshTunnel3 *t)
{
- return (MESH_TUNNEL3_READY == t->cstate
- && MESH_TUNNEL3_KEY_OK == t->estate)
- || GMT_is_loopback (t);
+ int ready;
+
+ GMT_debug (t);
+ ready = (MESH_TUNNEL3_READY == t->cstate && MESH_TUNNEL3_KEY_OK == t->estate);
+ ready = ready || GMT_is_loopback (t);
+ return ready;
}
size_t size, uint32_t iv)
{
struct GNUNET_CRYPTO_SymmetricInitializationVector siv;
+ struct GNUNET_CRYPTO_SymmetricSessionKey *key;
- GNUNET_CRYPTO_symmetric_derive_iv (&siv, &t->d_key, &iv, sizeof (uint32_t), NULL);
- return GNUNET_CRYPTO_symmetric_decrypt (src, size, &t->d_key, &siv, dst);
+ if (t->estate == MESH_TUNNEL3_KEY_OK || t->estate == MESH_TUNNEL3_KEY_PING)
+ {
+ key = &t->d_key;
+ }
+ else if (NULL != t->kx_ctx)
+ {
+ key = &t->kx_ctx->d_key_old;
+ }
+ else
+ {
+ GNUNET_STATISTICS_update (stats, "# non decryptable data", 1, GNUNET_NO);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "WARNING got data on %s without a valid key\n",
+ GMT_2s (t));
+ GMT_debug (t);
+ return 0;
+ }
+
+ GNUNET_CRYPTO_symmetric_derive_iv (&siv, key, &iv, sizeof (uint32_t), NULL);
+ return GNUNET_CRYPTO_symmetric_decrypt (src, size, key, &siv, dst);
}
* Delete a queued message: either was sent or the channel was destroyed
* before the tunnel's key exchange had a chance to finish.
*
- * @param tq Queue handle.
+ * @param tqd Delayed queue handle.
*/
static void
-unqueue_data (struct MeshTunnelDelayed *tq)
+unqueue_data (struct MeshTunnelDelayed *tqd)
{
- GNUNET_CONTAINER_DLL_remove (tq->t->tq_head, tq->t->tq_tail, tq);
- GNUNET_free (tq);
+ GNUNET_CONTAINER_DLL_remove (tqd->t->tq_head, tqd->t->tq_tail, tqd);
+ GNUNET_free (tqd);
}
static struct MeshTunnelDelayed *
queue_data (struct MeshTunnel3 *t, const struct GNUNET_MessageHeader *msg)
{
- struct MeshTunnelDelayed *tq;
+ struct MeshTunnelDelayed *tqd;
uint16_t size = ntohs (msg->size);
LOG (GNUNET_ERROR_TYPE_DEBUG, "queue data on Tunnel %s\n", GMT_2s (t));
return NULL;
}
- tq = GNUNET_malloc (sizeof (struct MeshTunnelDelayed) + size);
+ tqd = GNUNET_malloc (sizeof (struct MeshTunnelDelayed) + size);
- tq->t = t;
- memcpy (&tq[1], msg, size);
- GNUNET_CONTAINER_DLL_insert_tail (t->tq_head, t->tq_tail, tq);
- return tq;
+ tqd->t = t;
+ memcpy (&tqd[1], msg, size);
+ GNUNET_CONTAINER_DLL_insert_tail (t->tq_head, t->tq_tail, tqd);
+ return tqd;
}
if (GNUNET_NO == is_ready (t))
{
+ struct MeshTunnelDelayed *tqd;
+ /* A non null existing_q indicates sending of queued data.
+ * Should only happen after tunnel becomes ready.
+ */
GNUNET_assert (NULL == existing_q);
+ tqd = queue_data (t, message);
+ if (NULL == cont)
+ return NULL;
tq = GNUNET_new (struct MeshTunnel3Queue);
- tq->tqd = queue_data (t, message);
- tq->tqd->tq = tq;
+ tq->tqd = tqd;
+ tqd->tq = tq;
tq->cont = cont;
tq->cont_cls = cont_cls;
return tq;
c = tunnel_get_connection (t);
if (NULL == c)
{
- GNUNET_break (GNUNET_YES == t->destroy);
+ if (GNUNET_YES == t->destroy || MESH_TUNNEL3_SEARCHING != t->cstate)
+ {
+ GNUNET_break (0);
+ GMT_debug (t);
+ }
return NULL;
}
type = ntohs (message->type);
case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_CREATE:
case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY:
case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_ACK:
+ case GNUNET_MESSAGE_TYPE_MESH_CHANNEL_NACK:
msg->cid = *GMC_get_id (c);
msg->ttl = htonl (default_ttl);
break;
next = tqd->next;
room--;
send_prebuilt_message ((struct GNUNET_MessageHeader *) &tqd[1],
- tqd->t, GNUNET_YES,
- tqd->tq->cont, tqd->tq->cont_cls, tqd->tq);
+ tqd->t, GNUNET_YES,
+ NULL != tqd->tq ? tqd->tq->cont : NULL,
+ NULL != tqd->tq ? tqd->tq->cont_cls : NULL,
+ tqd->tq);
unqueue_data (tqd);
}
LOG (GNUNET_ERROR_TYPE_DEBUG, "GMT_send_queued_data end\n", GMP_2s (t->peer));
return;
}
+ if (GNUNET_NO != t->destroy)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " being destroyed, why bother\n");
+ return;
+ }
+
/* Must have a connection. */
if (NULL == t->connection_head)
{
- GNUNET_break (0);
+ GNUNET_break (MESH_TUNNEL3_SEARCHING == t->cstate);
+ GMT_debug (t);
return;
}
c = tunnel_get_connection (t);
if (NULL == c)
{
- GNUNET_break (GNUNET_YES == t->destroy);
+ GNUNET_break (GNUNET_YES == t->destroy || MESH_TUNNEL3_READY != t->cstate);
+ GMT_debug (t);
return;
}
type = ntohs (message->type);
t->rekey_task = GNUNET_SCHEDULER_NO_TASK;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Re-key Tunnel\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Re-key Tunnel %s\n", GMT_2s (t));
if (NULL != tc && 0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
return;
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " new kx ctx\n");
t->kx_ctx = GNUNET_new (struct MeshTunnelKXCtx);
- t->kx_ctx->challenge = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
- UINT32_MAX);
+ t->kx_ctx->challenge =
+ GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
t->kx_ctx->d_key_old = t->d_key;
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " new challenge for %s: %u\n",
+ GMT_2s (t), t->kx_ctx->challenge);
}
send_ephemeral (t);
switch (t->estate)
}
+/**
+ * Notify remote peer that we don't know a channel he is talking about,
+ * probably CHANNEL_DESTROY was missed.
+ *
+ * @param t Tunnel on which to notify.
+ * @param gid ID of the channel.
+ */
+static void
+send_channel_destroy (struct MeshTunnel3 *t, unsigned int gid)
+{
+ struct GNUNET_MESH_ChannelManage msg;
+
+ msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CHANNEL_DESTROY);
+ msg.header.size = htons (sizeof (msg));
+ msg.chid = htonl (gid);
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "WARNING destroying unknown channel %u on tunnel %s\n",
+ gid, GMT_2s (t));
+ send_prebuilt_message (&msg.header, t, GNUNET_YES, NULL, NULL, NULL);
+}
+
+
/**
* Demultiplex data per channel and call appropriate channel handler.
*
{
GNUNET_STATISTICS_update (stats, "# data on unknown channel",
1, GNUNET_NO);
- LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel %u unknown\n",
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "WARNING channel 0x%X unknown\n",
ntohl (msg->chid));
+ send_channel_destroy (t, ntohl (msg->chid));
return;
}
t_decrypt (t, &res.target, &msg->target, ping_encryption_size (), msg->iv);
if (0 != memcmp (&my_full_id, &res.target, sizeof (my_full_id)))
{
- GNUNET_break_op (0);
+ GNUNET_STATISTICS_update (stats, "# malformed PINGs", 1, GNUNET_NO);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " WARNING malformed PING\n");
LOG (GNUNET_ERROR_TYPE_DEBUG, " e got %u\n", msg->nonce);
LOG (GNUNET_ERROR_TYPE_DEBUG, " e towards %s\n", GNUNET_i2s (&msg->target));
LOG (GNUNET_ERROR_TYPE_DEBUG, " got %u\n", res.nonce);
LOG (GNUNET_ERROR_TYPE_DEBUG, "PONG received\n");
if (GNUNET_SCHEDULER_NO_TASK == t->rekey_task)
{
- GNUNET_break_op (0);
+ GNUNET_STATISTICS_update (stats, "# duplicate PONG messages", 1, GNUNET_NO);
return;
}
t_decrypt (t, &challenge, &msg->nonce, sizeof (uint32_t), msg->iv);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"end-to-end message not known (%u)\n",
ntohs (msgh->type));
+ GMT_debug (t);
}
}
}
+/**
+ * Mark a path as no longer valid for this tunnel: has been tried and failed.
+ *
+ * @param t Tunnel to update.
+ * @param path Invalid path to remove. Is destroyed after removal.
+ */
+void
+GMT_remove_path (struct MeshTunnel3 *t, struct MeshPeerPath *path)
+{
+ GMP_remove_path (t->peer, path);
+}
+
+
/**
* Remove a connection from a tunnel.
*
* @param c Connection.
*/
void
-GMT_remove_connection (struct MeshTunnel3 *t, struct MeshConnection *c)
+GMT_remove_connection (struct MeshTunnel3 *t,
+ struct MeshConnection *c)
{
struct MeshTConnection *aux;
+ struct MeshTConnection *next;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Removing connection %s from tunnel %s\n",
GMC_2s (c), GMT_2s (t));
- for (aux = t->connection_head; aux != NULL; aux = aux->next)
+ for (aux = t->connection_head; aux != NULL; aux = next)
+ {
+ next = aux->next;
if (aux->c == c)
{
GNUNET_CONTAINER_DLL_remove (t->connection_head, t->connection_tail, aux);
GNUNET_free (aux);
- return;
}
+ }
/* Start new connections if needed */
- if (NULL == t->connection_head)
+ if (NULL == t->connection_head
+ && GNUNET_NO == t->destroy
+ && GNUNET_NO == shutting_down)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG, " no more connections\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " no more connections, getting new ones\n");
GMP_connect (t->peer);
t->cstate = MESH_TUNNEL3_SEARCHING;
return;
{
struct MeshTConnection *iter;
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Tunnel empty: destroying scheduled\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Tunnel %s empty: destroying scheduled\n",
+ GMT_2s (t));
for (iter = t->connection_head; NULL != iter; iter = iter->next)
{
GMC_send_destroy (iter->c);
}
+ if (GNUNET_SCHEDULER_NO_TASK != t->rekey_task)
+ {
+ t->estate = MESH_TUNNEL3_KEY_UNINITIALIZED;
+ GNUNET_SCHEDULER_cancel (t->rekey_task);
+ t->rekey_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_free (t->kx_ctx);
+ t->kx_ctx = NULL;
+ }
t->cstate = MESH_TUNNEL3_NEW;
t->destroy = GNUNET_YES;
}
if (NULL == t)
return;
+ t->destroy = 2;
+
LOG (GNUNET_ERROR_TYPE_DEBUG, "destroying tunnel %s\n", GMP_2s (t->peer));
GNUNET_break (GNUNET_YES ==
}
if (own_pos > p->length - 1)
{
- GNUNET_break (0);
+ GNUNET_break_op (0);
return NULL;
}
struct MeshTConnection *iter;
unsigned int count;
- for (count = 0, iter = t->connection_head;
- NULL != iter;
- iter = iter->next, count++);
+ for (count = 0, iter = t->connection_head; NULL != iter; iter = iter->next)
+ if (MESH_CONNECTION_DESTROYED != GMC_get_state (iter->c))
+ count++;
return count;
}
{
if (NULL == t)
{
- GNUNET_break (0);
+ GNUNET_assert (0);
return (enum MeshTunnel3CState) -1;
}
return t->cstate;
unsigned int cs;
unsigned int buffer;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Tunnel send connection ACKs on %s\n",
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Tunnel send connection ACKs on %s\n",
GMT_2s (t));
if (NULL == t)
}
buffer = GMT_get_channels_buffer (t);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " buffer %u\n", buffer);
/* Count connections, how many messages are already allowed */
cs = GMT_count_connections (t);
{
allowed += get_connection_allowed (iter);
}
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " allowed %u\n", allowed);
/* Make sure there is no overflow */
if (allowed > buffer)
{
continue;
}
- GMC_allow (iter->c, buffer, GMC_is_origin (iter->c, GNUNET_YES));
+ GMC_allow (iter->c, allow_per_connection,
+ GMC_is_origin (iter->c, GNUNET_NO));
}
GNUNET_break (to_allow == 0);
else if (NULL != q->tqd)
{
unqueue_data (q->tqd);
+ q->tqd = NULL;
+ if (NULL != q->cont)
+ q->cont (q->cont_cls, NULL, q, 0, 0);
+ GNUNET_free (q);
}
else
{
return GMP_2s (t->peer);
}
+
+
+/**
+ * Log all possible info about the tunnel state.
+ *
+ * @param t Tunnel to debug.
+ */
+void
+GMT_debug (const struct MeshTunnel3 *t)
+{
+ struct MeshTChannel *iterch;
+ struct MeshTConnection *iterc;
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "DEBUG TUNNEL TOWARDS %s\n", GMT_2s (t));
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " cstate %s, estate %s\n",
+ cstate2s (t->cstate), estate2s (t->estate));
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " kx_ctx %p, rekey_task %u\n",
+ t->kx_ctx, t->rekey_task);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " tq_head %p, tq_tail %p\n",
+ t->tq_head, t->tq_tail);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " destroy %u\n", t->destroy);
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " channels:\n");
+ for (iterch = t->channel_head; NULL != iterch; iterch = iterch->next)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " - %s\n", GMCH_2s (iterch->ch));
+ }
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " connections:\n");
+ for (iterc = t->connection_head; NULL != iterc; iterc = iterc->next)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " - %s [%u] buf: %u/%u (qn %u/%u)\n",
+ GMC_2s (iterc->c), GMC_get_state (iterc->c),
+ GMC_get_buffer (iterc->c, GNUNET_YES),
+ GMC_get_buffer (iterc->c, GNUNET_NO),
+ GMC_get_qn (iterc->c, GNUNET_YES),
+ GMC_get_qn (iterc->c, GNUNET_NO));
+ }
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "DEBUG TUNNEL END\n");
+}