sizeof (struct GNUNET_CADET_ConnectionACK),
connection, fwd, &conn_message_sent, NULL);
connection->pending_messages++;
- if (CADET_TUNNEL3_NEW == GCT_get_cstate (t))
- GCT_change_cstate (t, CADET_TUNNEL3_WAITING);
+ if (CADET_TUNNEL_NEW == GCT_get_cstate (t))
+ GCT_change_cstate (t, CADET_TUNNEL_WAITING);
if (CADET_CONNECTION_READY != connection->state)
connection_change_state (connection, CADET_CONNECTION_SENT);
}
if (GNUNET_NO != c->destroy)
return;
- if (CADET_TUNNEL3_SEARCHING == GCT_get_cstate (c->t))
+ if (CADET_TUNNEL_SEARCHING == GCT_get_cstate (c->t))
{
/* TODO DHT GET with RO_BART */
return;
GCP_add_path_to_origin (orig_peer, path_duplicate (path), GNUNET_YES);
add_to_peer (c, orig_peer);
- if (CADET_TUNNEL3_NEW == GCT_get_cstate (c->t))
- GCT_change_cstate (c->t, CADET_TUNNEL3_WAITING);
+ if (CADET_TUNNEL_NEW == GCT_get_cstate (c->t))
+ GCT_change_cstate (c->t, CADET_TUNNEL_WAITING);
send_connection_ack (c, GNUNET_NO);
if (CADET_CONNECTION_SENT == c->state)
send_connection_ack (c, GNUNET_YES);
/* Change tunnel state, trigger KX */
- if (CADET_TUNNEL3_WAITING == GCT_get_cstate (c->t))
- GCT_change_cstate (c->t, CADET_TUNNEL3_READY);
+ if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t))
+ GCT_change_cstate (c->t, CADET_TUNNEL_READY);
return GNUNET_OK;
}
connection_reset_timeout (c, GNUNET_NO);
/* Change tunnel state */
- if (CADET_TUNNEL3_WAITING == GCT_get_cstate (c->t))
- GCT_change_cstate (c->t, CADET_TUNNEL3_READY);
+ if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t))
+ GCT_change_cstate (c->t, CADET_TUNNEL_READY);
return GNUNET_OK;
}
connection_change_state (c, CADET_CONNECTION_READY);
if (NULL != c->t)
{
- if (CADET_TUNNEL3_WAITING == GCT_get_cstate (c->t))
- GCT_change_cstate (c->t, CADET_TUNNEL3_READY);
+ if (CADET_TUNNEL_WAITING == GCT_get_cstate (c->t))
+ GCT_change_cstate (c->t, CADET_TUNNEL_READY);
}
}
connection_reset_timeout (c, fwd);
size, connection, GNUNET_YES, &conn_message_sent, NULL);
state = GCT_get_cstate (connection->t);
- if (CADET_TUNNEL3_SEARCHING == state || CADET_TUNNEL3_NEW == state)
- GCT_change_cstate (connection->t, CADET_TUNNEL3_WAITING);
+ if (CADET_TUNNEL_SEARCHING == state || CADET_TUNNEL_NEW == state)
+ GCT_change_cstate (connection->t, CADET_TUNNEL_WAITING);
if (CADET_CONNECTION_NEW == connection->state)
connection_change_state (connection, CADET_CONNECTION_SENT);
}
switch (cs)
{
- case CADET_TUNNEL3_NEW:
- return "CADET_TUNNEL3_NEW";
- case CADET_TUNNEL3_SEARCHING:
- return "CADET_TUNNEL3_SEARCHING";
- case CADET_TUNNEL3_WAITING:
- return "CADET_TUNNEL3_WAITING";
- case CADET_TUNNEL3_READY:
- return "CADET_TUNNEL3_READY";
+ case CADET_TUNNEL_NEW:
+ return "CADET_TUNNEL_NEW";
+ case CADET_TUNNEL_SEARCHING:
+ return "CADET_TUNNEL_SEARCHING";
+ case CADET_TUNNEL_WAITING:
+ return "CADET_TUNNEL_WAITING";
+ case CADET_TUNNEL_READY:
+ return "CADET_TUNNEL_READY";
default:
sprintf (buf, "%u (UNKNOWN STATE)", cs);
switch (es)
{
- case CADET_TUNNEL3_KEY_UNINITIALIZED:
- return "CADET_TUNNEL3_KEY_UNINITIALIZED";
- case CADET_TUNNEL3_KEY_SENT:
- return "CADET_TUNNEL3_KEY_SENT";
- case CADET_TUNNEL3_KEY_PING:
- return "CADET_TUNNEL3_KEY_PING";
- case CADET_TUNNEL3_KEY_OK:
- return "CADET_TUNNEL3_KEY_OK";
- case CADET_TUNNEL3_KEY_REKEY:
- return "CADET_TUNNEL3_KEY_REKEY";
+ case CADET_TUNNEL_KEY_UNINITIALIZED:
+ return "CADET_TUNNEL_KEY_UNINITIALIZED";
+ case CADET_TUNNEL_KEY_SENT:
+ return "CADET_TUNNEL_KEY_SENT";
+ case CADET_TUNNEL_KEY_PING:
+ return "CADET_TUNNEL_KEY_PING";
+ case CADET_TUNNEL_KEY_OK:
+ return "CADET_TUNNEL_KEY_OK";
+ case CADET_TUNNEL_KEY_REKEY:
+ return "CADET_TUNNEL_KEY_REKEY";
default:
sprintf (buf, "%u (UNKNOWN STATE)", es);
return buf;
int ready;
GCT_debug (t, GNUNET_ERROR_TYPE_DEBUG);
- ready = CADET_TUNNEL3_READY == t->cstate
- && (CADET_TUNNEL3_KEY_OK == t->estate
- || CADET_TUNNEL3_KEY_REKEY == t->estate);
+ ready = CADET_TUNNEL_READY == t->cstate
+ && (CADET_TUNNEL_KEY_OK == t->estate
+ || CADET_TUNNEL_KEY_REKEY == t->estate);
ready = ready || GCT_is_loopback (t);
return ready;
}
LOG (GNUNET_ERROR_TYPE_DEBUG, " t_decrypt with %s\n",
GNUNET_h2s ((struct GNUNET_HashCode *) &t->d_key));
#endif
- if (t->estate == CADET_TUNNEL3_KEY_UNINITIALIZED)
+ if (t->estate == CADET_TUNNEL_KEY_UNINITIALIZED)
{
GNUNET_STATISTICS_update (stats, "# non decryptable data", 1, GNUNET_NO);
LOG (GNUNET_ERROR_TYPE_WARNING,
if (NULL == c)
{
if (GNUNET_SCHEDULER_NO_TASK != t->destroy_task
- || CADET_TUNNEL3_SEARCHING != t->cstate)
+ || CADET_TUNNEL_SEARCHING != t->cstate)
{
GNUNET_break (0);
GCT_debug (t, GNUNET_ERROR_TYPE_WARNING);
/* Must have a connection. */
if (NULL == t->connection_head)
{
- GNUNET_break (CADET_TUNNEL3_SEARCHING == t->cstate);
+ GNUNET_break (CADET_TUNNEL_SEARCHING == t->cstate);
GCT_debug (t, GNUNET_ERROR_TYPE_WARNING);
return;
}
if (NULL == c)
{
GNUNET_break (GNUNET_SCHEDULER_NO_TASK != t->destroy_task
- || CADET_TUNNEL3_READY != t->cstate);
+ || CADET_TUNNEL_READY != t->cstate);
GCT_debug (t, GNUNET_ERROR_TYPE_WARNING);
return;
}
switch (t->estate)
{
- case CADET_TUNNEL3_KEY_UNINITIALIZED:
- t->estate = CADET_TUNNEL3_KEY_SENT;
+ case CADET_TUNNEL_KEY_UNINITIALIZED:
+ t->estate = CADET_TUNNEL_KEY_SENT;
break;
- case CADET_TUNNEL3_KEY_SENT:
+ case CADET_TUNNEL_KEY_SENT:
break;
- case CADET_TUNNEL3_KEY_OK:
- t->estate = CADET_TUNNEL3_KEY_REKEY;
+ case CADET_TUNNEL_KEY_OK:
+ t->estate = CADET_TUNNEL_KEY_REKEY;
/* fall-thru */
- case CADET_TUNNEL3_KEY_PING:
- case CADET_TUNNEL3_KEY_REKEY:
+ case CADET_TUNNEL_KEY_PING:
+ case CADET_TUNNEL_KEY_REKEY:
send_ping (t);
break;
default:
{
t->peers_ephemeral_key = msg->ephemeral_key;
create_keys (t);
- if (CADET_TUNNEL3_KEY_OK == t->estate)
+ if (CADET_TUNNEL_KEY_OK == t->estate)
{
- t->estate = CADET_TUNNEL3_KEY_REKEY;
+ t->estate = CADET_TUNNEL_KEY_REKEY;
}
}
- if (CADET_TUNNEL3_KEY_SENT == t->estate)
+ if (CADET_TUNNEL_KEY_SENT == t->estate)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " our key was sent, sending ping\n");
send_ping (t);
- t->estate = CADET_TUNNEL3_KEY_PING;
+ t->estate = CADET_TUNNEL_KEY_PING;
}
}
delay = GNUNET_TIME_relative_min (delay, GNUNET_TIME_UNIT_MINUTES);
t->kx_ctx->finish_task = GNUNET_SCHEDULER_add_delayed (delay, finish_kx, t);
}
- GCT_change_estate (t, CADET_TUNNEL3_KEY_OK);
+ GCT_change_estate (t, CADET_TUNNEL_KEY_OK);
}
LOG (GNUNET_ERROR_TYPE_DEBUG, "Tunnel %s cstate %s => %s\n",
GCP_2s (t->peer), cstate2s (t->cstate), cstate2s (cstate));
if (myid != GCP_get_short_id (t->peer) &&
- CADET_TUNNEL3_READY != t->cstate &&
- CADET_TUNNEL3_READY == cstate)
+ CADET_TUNNEL_READY != t->cstate &&
+ CADET_TUNNEL_READY == cstate)
{
t->cstate = cstate;
- if (CADET_TUNNEL3_KEY_OK == t->estate)
+ if (CADET_TUNNEL_KEY_OK == t->estate)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " cstate triggered send queued data\n");
send_queued_data (t);
}
- else if (CADET_TUNNEL3_KEY_UNINITIALIZED == t->estate)
+ else if (CADET_TUNNEL_KEY_UNINITIALIZED == t->estate)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " cstate triggered rekey\n");
rekey_tunnel (t, NULL);
}
t->cstate = cstate;
- if (CADET_TUNNEL3_READY == cstate
+ if (CADET_TUNNEL_READY == cstate
&& CONNECTIONS_PER_TUNNEL <= GCT_count_connections (t))
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " cstate triggered stop dht\n");
"Tunnel %s estate is now %s\n",
GCP_2s (t->peer), estate2s (state));
if (myid != GCP_get_short_id (t->peer) &&
- CADET_TUNNEL3_KEY_OK != t->estate && CADET_TUNNEL3_KEY_OK == state)
+ CADET_TUNNEL_KEY_OK != t->estate && CADET_TUNNEL_KEY_OK == state)
{
t->estate = state;
send_queued_data (t);
/* Start new connections if needed */
if (CONNECTIONS_PER_TUNNEL < GCT_count_connections (t)
&& GNUNET_SCHEDULER_NO_TASK == t->destroy_task
- && CADET_TUNNEL3_SHUTDOWN != t->cstate
+ && CADET_TUNNEL_SHUTDOWN != t->cstate
&& GNUNET_NO == shutting_down)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, " no more connections, getting new ones\n");
- t->cstate = CADET_TUNNEL3_SEARCHING;
+ t->cstate = CADET_TUNNEL_SEARCHING;
GCP_connect (t->peer);
return;
}
/* If not marked as ready, no change is needed */
- if (CADET_TUNNEL3_READY != t->cstate)
+ if (CADET_TUNNEL_READY != t->cstate)
return;
/* Check if any connection is ready to maintaing cstate */
if (CADET_CONNECTION_READY == GCC_get_state (aux->c))
return;
- t->cstate = CADET_TUNNEL3_WAITING;
+ t->cstate = CADET_TUNNEL_WAITING;
}
return;
}
t->destroy_task = GNUNET_SCHEDULER_NO_TASK;
- t->cstate = CADET_TUNNEL3_SHUTDOWN;
+ t->cstate = CADET_TUNNEL_SHUTDOWN;
for (iter = t->connection_head; NULL != iter; iter = iter->next)
{
return NULL;
}
- if (CADET_TUNNEL3_SHUTDOWN == t->cstate)
+ if (CADET_TUNNEL_SHUTDOWN == t->cstate)
{
GNUNET_break (0);
return NULL;