*/
struct MeshTunnel3 *t;
- struct MeshTunnel3Queue *q;
- GMT_sent cont;
- void *cont_cls;
+ /**
+ * Tunnel queue given to the channel to cancel request. Update on send_queued.
+ */
+ struct MeshTunnel3Queue *tq;
/**
* Message to send.
/**
* Connection queue handle, to cancel if necessary.
*/
- struct MeshConnectionQueue *q;
+ struct MeshConnectionQueue *cq;
/**
* Handle in case message hasn't been given to a connection yet.
*/
- struct MeshTunnelDelayed *tq;
+ struct MeshTunnelDelayed *tqd;
/**
* Continuation to call once sent.
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.
* @param msg Message itself (copy will be made).
*/
static struct MeshTunnelDelayed *
-queue_data (struct MeshTunnel3 *t, const struct GNUNET_MessageHeader *msg,
- GMT_sent cont, void *cont_cls)
+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;
- tq->cont = cont;
- tq->cont_cls = cont_cls;
- 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;
}
GMT_sent cont, void *cont_cls,
struct MeshTunnel3Queue *existing_q)
{
- struct MeshTunnel3Queue *q;
+ struct MeshTunnel3Queue *tq;
struct MeshConnection *c;
struct GNUNET_MESH_Encrypted *msg;
size_t size = ntohs (message->size);
- size_t encrypted_size;
char cbuf[sizeof (struct GNUNET_MESH_Encrypted) + size];
uint32_t iv;
uint16_t type;
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);
- q = GNUNET_new (struct MeshTunnel3Queue);
- q->tq = queue_data (t, message, cont, cont_cls);
- q->tq->q = q;
- return q;
+ tqd = queue_data (t, message);
+ if (NULL == cont)
+ return NULL;
+ tq = GNUNET_new (struct MeshTunnel3Queue);
+ tq->tqd = tqd;
+ tqd->tq = tq;
+ tq->cont = cont;
+ tq->cont_cls = cont_cls;
+ return tq;
}
GNUNET_assert (GNUNET_NO == GMT_is_loopback (t));
msg = (struct GNUNET_MESH_Encrypted *) cbuf;
msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED);
msg->iv = iv;
- encrypted_size = t_encrypt (t, &msg[1], message, size, iv);
- msg->header.size = htons (sizeof (struct GNUNET_MESH_Encrypted)
- + encrypted_size);
+ GNUNET_assert (t_encrypt (t, &msg[1], message, size, iv) == size);
+ msg->header.size = htons (sizeof (struct GNUNET_MESH_Encrypted) + size);
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);
}
if (NULL == existing_q)
{
- q = GNUNET_new (struct MeshTunnel3Queue); /* FIXME valgrind: leak*/
+ tq = GNUNET_new (struct MeshTunnel3Queue); /* FIXME valgrind: leak*/
}
else
{
- q = existing_q;
- q->tq = NULL;
+ tq = existing_q;
+ tq->tqd = NULL;
}
- q->q = GMC_send_prebuilt_message (&msg->header, c, fwd, force,
- &message_sent, q);
- q->cont = cont;
- q->cont_cls = cont_cls;
+ tq->cq = GMC_send_prebuilt_message (&msg->header, c, fwd, force,
+ &message_sent, tq);
+ tq->cont = cont;
+ tq->cont_cls = cont_cls;
- return q;
+ return tq;
}
static void
send_queued_data (struct MeshTunnel3 *t)
{
- struct MeshTunnelDelayed *tq;
+ struct MeshTunnelDelayed *tqd;
struct MeshTunnelDelayed *next;
unsigned int room;
room = GMT_get_connections_buffer (t);
LOG (GNUNET_ERROR_TYPE_DEBUG, " buffer space: %u\n", room);
LOG (GNUNET_ERROR_TYPE_DEBUG, " tq head: %p\n", t->tq_head);
- for (tq = t->tq_head; NULL != tq && room > 0; tq = next)
+ for (tqd = t->tq_head; NULL != tqd && room > 0; tqd = next)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " sending queued data\n");
- next = tq->next;
+ next = tqd->next;
room--;
- send_prebuilt_message ((struct GNUNET_MessageHeader *)&tq[1],
- tq->t, GNUNET_YES, tq->cont, tq->cont_cls, tq->q);
- unqueue_data (tq);
+ send_prebuilt_message ((struct GNUNET_MessageHeader *) &tqd[1],
+ 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));
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "GMT_send_queued_data end\n", GMP_2s (t->peer));
}
/* 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;
}
+/**
+ * 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;
- for (aux = t->connection_head; aux != NULL; aux = aux->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 = 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
+ && GNUNET_NO == t->destroy
+ && GNUNET_NO == shutting_down)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG, " no more connections\n");
+ GMP_connect (t->peer);
+ t->cstate = MESH_TUNNEL3_SEARCHING;
+ return;
+ }
+
+ /* If not marked as ready, no change is needed */
+ if (MESH_TUNNEL3_READY != t->cstate)
+ return;
+
+ /* Check if any connection is ready to maintaing cstate */
+ for (aux = t->connection_head; aux != NULL; aux = aux->next)
+ if (MESH_CONNECTION_READY == GMC_get_state (aux->c))
+ return;
+
+ t->cstate = MESH_TUNNEL3_WAITING;
}
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;
+ }
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;
}
void
GMT_cancel (struct MeshTunnel3Queue *q)
{
- if (NULL != q->q)
+ if (NULL != q->cq)
{
- GMC_cancel (q->q);
+ GMC_cancel (q->cq);
/* message_sent() will be called and free q */
}
- else if (NULL != q->tq)
+ else if (NULL != q->tqd)
{
- unqueue_data (q->tq);
+ unqueue_data (q->tqd);
}
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 %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, " 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\n", GMC_2s (iterc->c));
+ }
+
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "DEBUG END\n");
+}
projects / oweals / gnunet.git / blobdiff