/*
This file is part of GNUnet.
- (C) 2001 - 2011 Christian Grothoff (and other contributing authors)
+ (C) 2001-2012 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
* TODO:
* - error reporting (CREATE/CHANGE/ADD/DEL?) -- new message!
* - partial disconnect reporting -- same as error reporting?
- * - add vs create? change vs. keep-alive? same msg or different ones? -- thinking...
* - add ping message
* - relay corking down to core
* - set ttl relative to tree depth
/** Tunnel it belongs to. */
struct MeshTunnel *t;
- /** In case of a multicast, task to allow a client to send more data if
- * some neighbor is too slow. */
- GNUNET_SCHEDULER_TaskIdentifier *task;
+ /** How many remaining neighbors still hav't got it. */
+ unsigned int reference_counter;
/** How many remaining neighbors we need to send this to. */
- unsigned int *reference_counter;
+ unsigned int total_out;
/** Size of the data. */
size_t data_len;
uint32_t bck_ack;
/**
- * Circular buffer pointing to MeshPeerQueue elements.
- * Size determined by the tunnel queue size.
+ * Circular buffer pointing to MeshPeerQueue elements for all
+ * payload traffic going to this child.
+ * Size determined by the tunnel queue size (@c t->fwd_queue_max).
*/
struct MeshPeerQueue **send_buffer;
*/
struct MeshRegexSearchInfo *info;
+ /**
+ * We just want to look for one edge, the longer the better.
+ * Keep its length.
+ */
+ unsigned int longest_match;
+
+ /**
+ * Destination hash of the longest match.
+ */
+ struct GNUNET_HashCode hash;
};
/******************************************************************************/
}
#endif
+unsigned int debug_fwd_ack;
+unsigned int debug_bck_ack;
+
#endif
/******************************************************************************/
static long long unsigned int max_tunnels;
static long long unsigned int max_msgs_queue;
+
+/**
+ * Hostkey generation context
+ */
+static struct GNUNET_CRYPTO_RsaKeyGenerationContext *keygen;
+
/**
* DLL with all the clients, head.
*/
/**
- * Iterator over edges in a regex block retrieved from the DHT.
+ * Jump to the next edge, with the longest matching token.
*
- * @param cls Closure.
- * @param token Token that follows to next state.
- * @param len Lenght of token.
- * @param key Hash of next state.
+ * @param block Block found in the DHT.
+ * @param size Size of the block.
+ * @param ctx Context of the search.
*
* @return GNUNET_YES if should keep iterating, GNUNET_NO otherwise.
*/
-static int
-regex_edge_iterator (void *cls,
- const char *token,
- size_t len,
- const struct GNUNET_HashCode *key);
+static void
+regex_next_edge (const struct MeshRegexBlock *block,
+ size_t size,
+ struct MeshRegexSearchContext *ctx);
/**
/**
- * Queue and pass message to core when possible.
+ * @brief Queue and pass message to core when possible.
+ *
+ * If type is payload (UNICAST, TO_ORIGIN, MULTICAST) checks for queue status
+ * and accounts for it. In case the queue is full, the message is dropped and
+ * a break issued.
+ *
+ * Otherwise, message is treated as internal and allowed to go regardless of
+ * queue status.
*
- * @param cls Closure (type dependant).
+ * @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 size Size of the message.
* @param dst Neighbor to send message to.
ntohl(block->accepting));
}
- (void) GNUNET_MESH_regex_block_iterate (block, SIZE_MAX,
- ®ex_edge_iterator, ctx);
+ regex_next_edge(block, SIZE_MAX, ctx);
return GNUNET_YES;
}
const struct GNUNET_HashCode *key)
{
struct MeshRegexSearchContext *ctx = cls;
- struct MeshRegexSearchContext *new_ctx;
struct MeshRegexSearchInfo *info = ctx->info;
- struct GNUNET_DHT_GetHandle *get_h;
char *current;
size_t current_len;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Token doesn't match, END\n");
return GNUNET_YES; // Token doesn't match
}
+
+ if (len > ctx->longest_match)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Token is longer, KEEP\n");
+ ctx->longest_match = len;
+ ctx->hash = *key;
+ }
+ else
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* Token is not longer, IGNORE\n");
+ }
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* End of regex edge iterator\n");
+ return GNUNET_YES;
+}
+
+
+/**
+ * Jump to the next edge, with the longest matching token.
+ *
+ * @param block Block found in the DHT.
+ * @param size Size of the block.
+ * @param ctx Context of the search.
+ *
+ * @return GNUNET_YES if should keep iterating, GNUNET_NO otherwise.
+ */
+static void
+regex_next_edge (const struct MeshRegexBlock *block,
+ size_t size,
+ struct MeshRegexSearchContext *ctx)
+{
+ struct MeshRegexSearchContext *new_ctx;
+ struct MeshRegexSearchInfo *info = ctx->info;
+ struct GNUNET_DHT_GetHandle *get_h;
+
+ int result;
+
+ /* Find the longest match for the current string position,
+ * among tokens in the given block */
+ ctx->longest_match = 0;
+ result = GNUNET_MESH_regex_block_iterate (block, size,
+ ®ex_edge_iterator, ctx);
+ GNUNET_break (GNUNET_OK == result || SIZE_MAX == size);
+
+ /* Did anything match? */
+ if (0 == ctx->longest_match)
+ return;
+
new_ctx = GNUNET_malloc (sizeof (struct MeshRegexSearchContext));
new_ctx->info = info;
- new_ctx->position = ctx->position + len;
+ new_ctx->position = ctx->position + ctx->longest_match;
GNUNET_array_append (info->contexts, info->n_contexts, new_ctx);
+
+ /* Check whether we already have a DHT GET running for it */
if (GNUNET_YES ==
- GNUNET_CONTAINER_multihashmap_contains(info->dht_get_handles, key))
+ GNUNET_CONTAINER_multihashmap_contains(info->dht_get_handles, &ctx->hash))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* GET running, END\n");
- GNUNET_CONTAINER_multihashmap_get_multiple (info->dht_get_results, key,
+ GNUNET_CONTAINER_multihashmap_get_multiple (info->dht_get_results,
+ &ctx->hash,
®ex_result_iterator,
new_ctx);
- return GNUNET_YES; // We are already looking for it
+ return; // We are already looking for it
}
+
/* Start search in DHT */
get_h =
GNUNET_DHT_get_start (dht_handle, /* handle */
GNUNET_BLOCK_TYPE_MESH_REGEX, /* type */
- key, /* key to search */
+ &ctx->hash, /* key to search */
dht_replication_level, /* replication level */
GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
NULL, /* xquery */ // FIXME BLOOMFILTER
0, /* xquery bits */ // FIXME BLOOMFILTER SIZE
&dht_get_string_handler, new_ctx);
if (GNUNET_OK !=
- GNUNET_CONTAINER_multihashmap_put(info->dht_get_handles, key, get_h,
+ GNUNET_CONTAINER_multihashmap_put(info->dht_get_handles,
+ &ctx->hash,
+ get_h,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
{
GNUNET_break (0);
- return GNUNET_YES;
+ return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "* End of regex edge iterator\n");
- return GNUNET_YES;
}
+
/**
* Iterator over hash map entries to cancel DHT GET requests after a
* successful connect_by_string.
* @param edges edges leaving current state.
*/
void
-regex_iterator (void *cls, const struct GNUNET_HashCode *key, const char *proof,
- int accepting, unsigned int num_edges,
+regex_iterator (void *cls,
+ const struct GNUNET_HashCode *key,
+ const char *proof,
+ int accepting,
+ unsigned int num_edges,
const struct GNUNET_REGEX_Edge *edges)
{
struct MeshRegexBlock *block;
block.id = my_full_id;
c = GNUNET_CONTAINER_multihashmap_get (applications, key);
+ GNUNET_assert(NULL != c);
block.type = (long) GNUNET_CONTAINER_multihashmap_get (c->apps, key);
if (0 == block.type)
{
static void
data_descriptor_decrement_rc (struct MeshData *mesh_data)
{
- /* Make sure it's a multicast packet */
- GNUNET_assert (NULL != mesh_data->reference_counter);
-
- if (0 == --(*(mesh_data->reference_counter)))
+ if (0 == --(mesh_data->reference_counter))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Last copy!\n");
- if (NULL != mesh_data->task)
- {
- if (GNUNET_SCHEDULER_NO_TASK != *(mesh_data->task))
- {
- GNUNET_SCHEDULER_cancel (*(mesh_data->task));
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " notifying client...\n");
- GNUNET_SERVER_receive_done (mesh_data->t->owner->handle, GNUNET_OK);
- }
- GNUNET_free (mesh_data->task);
- }
- GNUNET_free (mesh_data->reference_counter);
GNUNET_free (mesh_data->data);
GNUNET_free (mesh_data);
}
}
-/**
- * Allow a client to send more data after transmitting a multicast message
- * which some neighbor has not yet accepted altough a reasonable time has
- * passed.
- *
- * @param cls Closure (DataDescriptor containing the task identifier)
- * @param tc Task Context
- *
- * FIXME reference counter cshould be just int
- */
-static void
-client_allow_send (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct MeshData *mdata = cls;
-
- if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
- return;
- GNUNET_assert (NULL != mdata->reference_counter);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "CLIENT ALLOW SEND DESPITE %u COPIES PENDING\n",
- *(mdata->reference_counter));
- *(mdata->task) = GNUNET_SCHEDULER_NO_TASK;
- GNUNET_SERVER_receive_done (mdata->t->owner->handle, GNUNET_OK);
-}
-
-
/**
* Check whether client wants traffic from a tunnel.
*
* @param t Tunnel on which this message is transmitted.
*/
static void
-send_message (const struct GNUNET_MessageHeader *message,
- const struct GNUNET_PeerIdentity *peer,
- struct MeshTunnel *t)
+send_prebuilt_message (const struct GNUNET_MessageHeader *message,
+ const struct GNUNET_PeerIdentity *peer,
+ struct MeshTunnel *t)
{
struct MeshTransmissionDescriptor *info;
struct MeshPeerInfo *neighbor;
m->ttl = htonl (ntohl (m->ttl) - 1);
}
info->mesh_data->data_len = size;
- info->mesh_data->reference_counter = GNUNET_malloc (sizeof (unsigned int));
- *info->mesh_data->reference_counter = 1;
+ info->mesh_data->reference_counter = 1;
+ info->mesh_data->total_out = 1;
neighbor = peer_info_get (peer);
for (p = neighbor->path_head; NULL != p; p = p->next)
{
}
info->peer = neighbor;
if (GNUNET_MESSAGE_TYPE_MESH_PATH_ACK == type)
- {
- /*
- * TODO: in this case we only need the service to retransmit
- * the message down the path. If we pass the real type to queue_add,
- * queue_send will try to build the message from scratch. This can
- * probably be done by some other way instead of deleteing the type
- * info.
- */
type = 0;
- }
queue_add (info,
type,
size,
{
GNUNET_PEER_resolve (p->peers[i], &pi[i]);
}
- send_message (&msg->header, tree_get_first_hop (t->tree, destination), t);
+ send_prebuilt_message (&msg->header, tree_get_first_hop (t->tree, destination), t);
}
path_destroy (p);
}
+/**
+ * Sends a PATH ACK message in reponse to a received PATH_CREATE directed to us.
+ *
+ * @param t Tunnel which to confirm.
+ */
+static void
+send_path_ack (struct MeshTunnel *t)
+{
+ struct MeshTransmissionDescriptor *info;
+ struct GNUNET_PeerIdentity id;
+ GNUNET_PEER_Id peer;
+
+ peer = tree_get_predecessor (t->tree);
+ GNUNET_PEER_resolve (peer, &id);
+ info = GNUNET_malloc (sizeof (struct MeshTransmissionDescriptor));
+ info->origin = &t->id;
+ info->peer = GNUNET_CONTAINER_multihashmap_get (peers, &id.hashPubKey);
+ GNUNET_assert (NULL != info->peer);
+
+ queue_add (info,
+ GNUNET_MESSAGE_TYPE_MESH_PATH_ACK,
+ sizeof (struct GNUNET_MESH_PathACK),
+ info->peer,
+ t);
+}
+
+
/**
* Try to establish a new connection to this peer.
* Use the best path for the given tunnel.
/**
- * Iterator to free MeshTunnelChildInfo of tunnel children.
+ * @brief Iterator to destroy MeshTunnelChildInfo of tunnel children.
+ *
+ * Destroys queue elements of all waiting transmissions and frees all memory
+ * used by the struct and its elements.
*
* @param cls Closure (tunnel info).
* @param key Hash of GNUNET_PEER_Id (unused).
const struct GNUNET_HashCode * key,
void *value)
{
- GNUNET_free (value);
+ struct MeshTunnelChildInfo *cinfo = value;
+ struct MeshTunnel *t = cls;
+ unsigned int c;
+ unsigned int i;
+
+ for (c = 0; c < cinfo->send_buffer_n; c++)
+ {
+ i = (cinfo->send_buffer_start + c) % t->fwd_queue_max;
+ if (NULL != cinfo->send_buffer[i])
+ queue_destroy (cinfo->send_buffer[i], GNUNET_YES);
+ else
+ GNUNET_break (0);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%u %u\n", c, cinfo->send_buffer_n);
+ }
+ GNUNET_free_non_null (cinfo->send_buffer);
+ GNUNET_free (cinfo);
return GNUNET_YES;
}
msg.peer1 = my_full_id;
GNUNET_PEER_resolve (pid, &msg.peer2);
GNUNET_PEER_resolve (tree_get_predecessor (t->tree), &neighbor);
- send_message (&msg.header, &neighbor, t);
+ send_prebuilt_message (&msg.header, &neighbor, t);
}
}
return pid;
struct MeshData *mdata = cls;
struct MeshTransmissionDescriptor *info;
struct GNUNET_PeerIdentity neighbor;
+ struct GNUNET_MessageHeader *msg;
info = GNUNET_malloc (sizeof (struct MeshTransmissionDescriptor));
info->mesh_data = mdata;
- (*(mdata->reference_counter)) ++;
+ (mdata->reference_counter) ++;
info->destination = neighbor_id;
GNUNET_PEER_resolve (neighbor_id, &neighbor);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " sending to %s...\n",
GNUNET_i2s (&neighbor));
info->peer = peer_info_get (&neighbor);
GNUNET_assert (NULL != info->peer);
+ msg = (struct GNUNET_MessageHeader *) mdata->data;
queue_add(info,
- GNUNET_MESSAGE_TYPE_MESH_MULTICAST,
+ ntohs (msg->type),
info->mesh_data->data_len,
info->peer,
mdata->t);
*
* @param t Tunnel in which to send the data.
* @param msg Message to be sent.
- * @param internal Has the service generated this message?
*/
static void
tunnel_send_multicast (struct MeshTunnel *t,
- const struct GNUNET_MessageHeader *msg,
- int internal)
+ const struct GNUNET_MessageHeader *msg)
{
struct MeshData *mdata;
mdata = GNUNET_malloc (sizeof (struct MeshData));
mdata->data_len = ntohs (msg->size);
- mdata->reference_counter = GNUNET_malloc (sizeof (unsigned int));
mdata->t = t;
mdata->data = GNUNET_malloc (mdata->data_len);
memcpy (mdata->data, msg, mdata->data_len);
{
struct GNUNET_MESH_Multicast *mcast;
+ mcast = (struct GNUNET_MESH_Multicast *) mdata->data;
if (t->fwd_queue_n >= t->fwd_queue_max)
{
GNUNET_break (0);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " queue full!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, " queue full!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ " message from %s!\n",
+ GNUNET_i2s(&mcast->oid));
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ " message at %s!\n",
+ GNUNET_i2s(&my_full_id));
GNUNET_free (mdata->data);
- GNUNET_free (mdata->reference_counter);
GNUNET_free (mdata);
return;
}
t->fwd_queue_n++;
- mcast = (struct GNUNET_MESH_Multicast *) mdata->data;
mcast->ttl = htonl (ntohl (mcast->ttl) - 1);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " data packet, ttl: %u\n",
ntohl (mcast->ttl));
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " not a data packet, no ttl\n");
}
- if (NULL != t->owner &&
- GNUNET_YES != t->owner->shutting_down &&
- GNUNET_NO == internal)
- {
- mdata->task = GNUNET_malloc (sizeof (GNUNET_SCHEDULER_TaskIdentifier));
- (*(mdata->task)) =
- GNUNET_SCHEDULER_add_delayed (unacknowledged_wait_time, &client_allow_send,
- mdata);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "timeout task %u\n",
- *(mdata->task));
- }
tree_iterate_children (t->tree, &tunnel_send_multicast_iterator, mdata);
- if (*(mdata->reference_counter) == 0)
+ if (mdata->reference_counter == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
" no one to send data to\n");
GNUNET_free (mdata->data);
- GNUNET_free (mdata->reference_counter);
- if (NULL != mdata->task)
- {
- GNUNET_SCHEDULER_cancel(*(mdata->task));
- GNUNET_free (mdata->task);
- GNUNET_SERVER_receive_done (t->owner->handle, GNUNET_OK);
- }
GNUNET_free (mdata);
t->fwd_queue_n--;
}
+ else
+ {
+ mdata->total_out = mdata->reference_counter;
+ }
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
" sending a multicast packet done\n");
return;
*
* @param t Tunnel.
*
- * @return Maximum PID allowed (uint32 MAX), -1 if node has no children.
+ * @return Maximum PID allowed (uint32 MAX), -1LL if node has no children.
*/
static int64_t
tunnel_get_children_fwd_ack (struct MeshTunnel *t)
ctx.t = t;
ctx.max_child_ack = 0;
ctx.nchildren = 0;
+ ctx.init = GNUNET_NO;
tree_iterate_children (t->tree, tunnel_get_child_fwd_ack, &ctx);
if (0 == ctx.nchildren)
* @param t Tunnel on which to look.
*
* @return Corresponding ACK value (max uint32_t).
- * If no clients are suscribed, -1.
+ * If no clients are suscribed, -1LL.
*/
static int64_t
tunnel_get_clients_fwd_ack (struct MeshTunnel *t)
return -1LL;
}
- for (ack = -1, i = 0; i < t->nclients; i++)
+ for (ack = -1LL, i = 0; i < t->nclients; i++)
{
- if (-1 == ack ||
+ if (-1LL == ack ||
(GNUNET_YES == t->speed_min &&
GNUNET_YES == GMC_is_pid_bigger (ack, t->clients_fc[i].fwd_ack)) ||
(GNUNET_NO == t->speed_min &&
static uint32_t
tunnel_get_fwd_ack (struct MeshTunnel *t)
{
+ uint32_t ack;
uint32_t count;
uint32_t buffer_free;
int64_t child_ack;
int64_t client_ack;
- uint32_t ack;
count = t->fwd_pid - t->skip;
buffer_free = t->fwd_queue_max - t->fwd_queue_n;
- ack = count + buffer_free; // Might overflow 32 bits, it's ok!
+ ack = count;
child_ack = tunnel_get_children_fwd_ack (t);
client_ack = tunnel_get_clients_fwd_ack (t);
- if (-1 == child_ack)
+ if (-1LL == child_ack)
{
// Node has no children, child_ack AND core buffer are irrelevant.
- GNUNET_break (-1 != client_ack); // No children AND no clients? Not good!
+ GNUNET_break (-1LL != client_ack); // No children AND no clients? Not good!
return (uint32_t) client_ack;
}
-
+ if (-1LL == client_ack)
+ {
+ client_ack = ack + buffer_free; // Might overflow 32 bits, it's ok!
+ }
if (GNUNET_YES == t->speed_min)
{
- ack = GMC_min_pid ((uint32_t) child_ack, ack);
+ ack = GMC_min_pid ((uint32_t) child_ack, ack) + buffer_free; // Might overflow 32 bits, it's ok!;
ack = GMC_min_pid ((uint32_t) client_ack, ack);
}
else
{
- ack = GMC_max_pid ((uint32_t) child_ack, ack);
+ ack = GMC_max_pid ((uint32_t) child_ack, ack) + buffer_free; // Might overflow 32 bits, it's ok!;
ack = GMC_max_pid ((uint32_t) client_ack, ack);
}
if (GNUNET_YES == t->nobuffer && GMC_is_pid_bigger(ack, t->fwd_pid))
ack = t->fwd_pid + 1; // Might overflow 32 bits, it's ok!
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "c %u, bf %u, ch %u, cl %u, ACK: %u\n",
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "c %u, bf %u, ch %lld, cl %lld, ACK: %u\n",
count, buffer_free, child_ack, client_ack, ack);
return ack;
}
msg.pid = htonl (ack);
msg.tid = htonl (t->id.tid);
- send_message (&msg.header, peer, t);
+ send_prebuilt_message (&msg.header, peer, t);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Not sending ACK, nobuffer\n");
return;
}
- if (t->fwd_queue_max > t->fwd_queue_n * 2 &&
- GMC_is_pid_bigger(t->last_fwd_ack, t->fwd_pid))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Not sending ACK, buffer free\n");
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- " t->qmax: %u, t->qn: %u\n",
- t->fwd_queue_max, t->fwd_queue_n);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- " t->pid: %u, t->ack: %u\n",
- t->fwd_pid, t->last_fwd_ack);
- return;
- }
break;
case GNUNET_MESSAGE_TYPE_MESH_ACK:
case GNUNET_MESSAGE_TYPE_MESH_LOCAL_ACK:
GNUNET_break (0);
}
+ /* Check if we need no retransmit the ACK */
+ if (t->fwd_queue_max > t->fwd_queue_n * 4 &&
+ GMC_is_pid_bigger(t->last_fwd_ack, t->fwd_pid))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Not sending ACK, buffer free\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ " t->qmax: %u, t->qn: %u\n",
+ t->fwd_queue_max, t->fwd_queue_n);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ " t->pid: %u, t->ack: %u\n",
+ t->fwd_pid, t->last_fwd_ack);
+ return;
+ }
+
/* Ok, ACK might be necessary, what PID to ACK? */
ack = tunnel_get_fwd_ack (t);
t->last_fwd_ack = ack;
GNUNET_PEER_resolve (tree_get_predecessor (t->tree), &id);
send_ack (t, &id, ack);
+ debug_fwd_ack++;
}
msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY);
GNUNET_PEER_resolve (t->id.oid, &msg.oid);
msg.tid = htonl (t->id.tid);
- tunnel_send_multicast (t, &msg.header, GNUNET_NO);
+ tunnel_send_multicast (t, &msg.header);
}
next = pq->next;
if (pq->tunnel == t)
{
+ if (GNUNET_MESSAGE_TYPE_MESH_MULTICAST == pq->type ||
+ GNUNET_MESSAGE_TYPE_MESH_UNICAST == pq->type ||
+ GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN == pq->type)
+ {
+ // Should have been removed on destroy children
+ GNUNET_break (0);
+ }
queue_destroy (pq, GNUNET_YES);
}
}
if (NULL == t)
return GNUNET_OK;
- tree_iterate_children (t->tree, &tunnel_cancel_queues, t);
-
r = GNUNET_OK;
c = t->owner;
#if MESH_DEBUG
GNUNET_CRYPTO_hash (&t->id, sizeof (struct MESH_TunnelID), &hash);
if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (tunnels, &hash, t))
{
+ GNUNET_break (0);
r = GNUNET_SYSERR;
}
- GNUNET_CRYPTO_hash (&t->local_tid, sizeof (MESH_TunnelNumber), &hash);
- if (NULL != c &&
- GNUNET_YES !=
- GNUNET_CONTAINER_multihashmap_remove (c->own_tunnels, &hash, t))
+ if (NULL != c)
{
- r = GNUNET_SYSERR;
+ GNUNET_CRYPTO_hash (&t->local_tid, sizeof (MESH_TunnelNumber), &hash);
+ if (GNUNET_YES !=
+ GNUNET_CONTAINER_multihashmap_remove (c->own_tunnels, &hash, t))
+ {
+ GNUNET_break (0);
+ r = GNUNET_SYSERR;
+ }
}
+
GNUNET_CRYPTO_hash (&t->local_tid_dest, sizeof (MESH_TunnelNumber), &hash);
for (i = 0; i < t->nclients; i++)
{
if (GNUNET_YES !=
GNUNET_CONTAINER_multihashmap_remove (c->incoming_tunnels, &hash, t))
{
+ GNUNET_break (0);
r = GNUNET_SYSERR;
}
}
if (GNUNET_YES !=
GNUNET_CONTAINER_multihashmap_remove (c->ignore_tunnels, &hash, t))
{
+ GNUNET_break (0);
r = GNUNET_SYSERR;
}
}
+
if (t->nclients > 0)
{
if (GNUNET_YES !=
GNUNET_CONTAINER_multihashmap_remove (incoming_tunnels, &hash, t))
{
+ GNUNET_break (0);
r = GNUNET_SYSERR;
}
GNUNET_free (t->clients);
}
+
if (NULL != t->peers)
{
GNUNET_CONTAINER_multihashmap_iterate (t->peers, &peer_info_delete_tunnel,
t);
GNUNET_CONTAINER_multihashmap_destroy (t->children_fc);
+ tree_iterate_children (t->tree, &tunnel_cancel_queues, t);
+
tree_destroy (t->tree);
if (NULL != t->regex_ctx)
* @param key the hash of the local tunnel id (used to access the hashmap)
* @param value the value stored at the key (tunnel to destroy)
*
- * @return GNUNET_OK on success
+ * @return GNUNET_OK, keep iterating.
*/
static int
tunnel_destroy_iterator (void *cls, const struct GNUNET_HashCode * key, void *value)
{
struct MeshTunnel *t = value;
struct MeshClient *c = cls;
- int r;
send_client_tunnel_disconnect(t, c);
if (c != t->owner)
return GNUNET_OK;
}
tunnel_send_destroy(t);
- r = tunnel_destroy (t);
- return r;
+ t->owner = NULL;
+ t->destroy = GNUNET_YES;
+
+ return GNUNET_OK;
}
tunnel_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct MeshTunnel *t = cls;
+ struct GNUNET_PeerIdentity id;
+ t->timeout_task = GNUNET_SCHEDULER_NO_TASK;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
return;
- t->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_PEER_resolve(t->id.oid, &id);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Tunnel %s [%X] timed out. Destroying.\n",
+ GNUNET_i2s(&id), t->id.tid);
tunnel_destroy (t);
}
msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE);
msg->tid = ntohl (t->id.tid);
+ opt = 0;
if (GNUNET_YES == t->speed_min)
- opt = MESH_TUNNEL_OPT_SPEED_MIN;
+ opt |= MESH_TUNNEL_OPT_SPEED_MIN;
if (GNUNET_YES == t->nobuffer)
opt |= MESH_TUNNEL_OPT_NOBUFFER;
msg->opt = htonl(opt);
+ msg->reserved = 0;
peer_ptr = (struct GNUNET_PeerIdentity *) &msg[1];
for (i = 0; i < p->length; i++)
{
struct MeshTransmissionDescriptor *dd;
struct MeshPathInfo *path_info;
+ struct MeshTunnelChildInfo *cinfo;
+ struct GNUNET_PeerIdentity id;
+ unsigned int i;
+ unsigned int max;
if (GNUNET_YES == clear_cls)
{
switch (queue->type)
{
- case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
- case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
- case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " type payload\n");
+ case GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY:
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, " cancelling TUNNEL_DESTROY\n");
+ /* fall through */
+ case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
+ case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
+ case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ " type prebuilt (payload, tunnel destroy)\n");
dd = queue->cls;
data_descriptor_decrement_rc (dd->mesh_data);
break;
- case GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE:
+ case GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " type create path\n");
path_info = queue->cls;
path_destroy (path_info->path);
break;
- default:
+ default:
GNUNET_break (0);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " type unknown!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ " type %s unknown!\n",
+ GNUNET_MESH_DEBUG_M2S(queue->type));
}
GNUNET_free_non_null (queue->cls);
}
GNUNET_CONTAINER_DLL_remove (queue->peer->queue_head,
queue->peer->queue_tail,
queue);
+
+ /* Delete from child_fc in the appropiate tunnel */
+ max = queue->tunnel->fwd_queue_max;
+ GNUNET_PEER_resolve (queue->peer->id, &id);
+ cinfo = tunnel_get_neighbor_fc (queue->tunnel, &id);
+ for (i = 0; i < cinfo->send_buffer_n; i++)
+ {
+ unsigned int i2;
+ i2 = (cinfo->send_buffer_start + i) % max;
+ if (cinfo->send_buffer[i2] == queue)
+ {
+ /* Found corresponding entry in the send_buffer. Move all others back. */
+ unsigned int j;
+ unsigned int j2;
+ unsigned int j3;
+
+ for (j = i, j2 = 0, j3 = 0; j < cinfo->send_buffer_n - 1; j++)
+ {
+ j2 = (cinfo->send_buffer_start + j) % max;
+ j3 = (cinfo->send_buffer_start + j + 1) % max;
+ cinfo->send_buffer[j2] = cinfo->send_buffer[j3];
+ }
+
+ cinfo->send_buffer[j3] = NULL;
+
+ cinfo->send_buffer_n--;
+ }
+ }
+ //queue->
+
GNUNET_free (queue);
}
struct GNUNET_MessageHeader *msg;
struct MeshPeerQueue *queue;
struct MeshTunnel *t;
+ struct MeshTunnelChildInfo *cinfo;
+ struct GNUNET_PeerIdentity dst_id;
size_t data_size;
peer->core_transmit = NULL;
-
+
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "********* Queue send\n");
- queue = queue_get_next(peer);
+ queue = queue_get_next (peer);
- /* Queue has no internal mesh traffic not sendable payload */
+ /* Queue has no internal mesh traffic nor sendable payload */
if (NULL == queue)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "********* not ready, return\n");
if (NULL == peer->queue_head)
- GNUNET_break(0); // Should've been canceled
+ GNUNET_break (0); // Should've been canceled
return 0;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "********* not empty\n");
+ GNUNET_PEER_resolve (peer->id, &dst_id);
/* Check if buffer size is enough for the message */
if (queue->size > size)
{
- struct GNUNET_PeerIdentity id;
-
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"********* not enough room, reissue\n");
- GNUNET_PEER_resolve (peer->id, &id);
peer->core_transmit =
- GNUNET_CORE_notify_transmit_ready(core_handle,
- 0,
- 0,
- GNUNET_TIME_UNIT_FOREVER_REL,
- &id,
- queue->size,
- &queue_send,
- peer);
+ GNUNET_CORE_notify_transmit_ready (core_handle,
+ 0,
+ 0,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ &dst_id,
+ queue->size,
+ &queue_send,
+ peer);
return 0;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "********* size ok\n");
tunnel_send_fwd_ack (t, GNUNET_MESSAGE_TYPE_MESH_UNICAST);
break;
case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
- tunnel_send_bck_ack(t, GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN);
+ tunnel_send_bck_ack (t, GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN);
break;
default:
break;
break;
case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "********* multicast\n");
+ {
+ struct MeshTransmissionDescriptor *info = queue->cls;
+
+ if ((1 == info->mesh_data->reference_counter
+ && GNUNET_YES == t->speed_min)
+ ||
+ (info->mesh_data->total_out == info->mesh_data->reference_counter
+ && GNUNET_NO == t->speed_min))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "********* considered sent\n");
+ t->fwd_queue_n--;
+ }
+ }
data_size = send_core_data_multicast(queue->cls, size, buf);
- // FIXME fc substract when? depending on the tunnel conf.
- // t->fwd_queue_n--;
tunnel_send_fwd_ack (t, GNUNET_MESSAGE_TYPE_MESH_MULTICAST);
break;
case GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "********* path create\n");
- data_size = send_core_path_create(queue->cls, size, buf);
+ data_size = send_core_path_create (queue->cls, size, buf);
break;
case GNUNET_MESSAGE_TYPE_MESH_PATH_ACK:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "********* path ack\n");
- data_size = send_core_path_ack(queue->cls, size, buf);
+ data_size = send_core_path_ack (queue->cls, size, buf);
+ break;
+ case GNUNET_MESSAGE_TYPE_MESH_PATH_KEEPALIVE:
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "********* path keepalive\n");
+ data_size = send_core_data_multicast (queue->cls, size, buf);
break;
default:
GNUNET_break (0);
queue->type);
data_size = 0;
}
+ switch (queue->type)
+ {
+ case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
+ case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
+ case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
+ cinfo = tunnel_get_neighbor_fc (t, &dst_id);
+ if (cinfo->send_buffer[cinfo->send_buffer_start] != queue)
+ {
+ GNUNET_break (0);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "at pos %u (%p) != %p\n",
+ cinfo->send_buffer_start,
+ cinfo->send_buffer[cinfo->send_buffer_start],
+ queue);
+ }
+ if (cinfo->send_buffer_n > 0)
+ {
+ cinfo->send_buffer[cinfo->send_buffer_start] = NULL;
+ cinfo->send_buffer_n--;
+ cinfo->send_buffer_start++;
+ cinfo->send_buffer_start %= t->fwd_queue_max;
+ }
+ else
+ {
+ GNUNET_break (0);
+ }
+ break;
+ default:
+ break;
+ }
/* Free queue, but cls was freed by send_core_* */
queue_destroy (queue, GNUNET_NO);
}
/* If more data in queue, send next */
- if (NULL != peer->queue_head)
+ queue = queue_get_next(peer);
+ if (NULL != queue)
{
struct GNUNET_PeerIdentity id;
0,
GNUNET_TIME_UNIT_FOREVER_REL,
&id,
- peer->queue_head->size,
+ queue->size,
&queue_send,
peer);
}
+ else
+ {
+ if (NULL != peer->queue_head)
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "********* %s stalled\n",
+ GNUNET_i2s(&my_full_id));
+ }
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "********* return %d\n", data_size);
return data_size;
}
/**
- * Queue and pass message to core when possible.
+ * @brief Queue and pass message to core when possible.
+ *
+ * If type is payload (UNICAST, TO_ORIGIN, MULTICAST) checks for queue status
+ * and accounts for it. In case the queue is full, the message is dropped and
+ * a break issued.
+ *
+ * Otherwise, message is treated as internal and allowed to go regardless of
+ * queue status.
*
- * @param cls Closure (type dependant).
+ * @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 size Size of the message.
* @param dst Neighbor to send message to.
if (NULL == dst->core_transmit)
{
dst->core_transmit =
- GNUNET_CORE_notify_transmit_ready(core_handle,
- 0,
- 0,
- GNUNET_TIME_UNIT_FOREVER_REL,
- &id,
- size,
- &queue_send,
- dst);
+ GNUNET_CORE_notify_transmit_ready (core_handle,
+ 0,
+ 0,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ &id,
+ size,
+ &queue_send,
+ dst);
}
if (NULL == n) // Is this internal mesh traffic?
return;
i = (cinfo->send_buffer_start + cinfo->send_buffer_n) % t->fwd_queue_max;
if (NULL != cinfo->send_buffer[i])
{
- queue_destroy(cinfo->send_buffer[i], GNUNET_YES);
- GNUNET_break (cinfo->send_buffer_n > 0);
- cinfo->send_buffer_n--;
+ GNUNET_break (cinfo->send_buffer_n == t->fwd_queue_max); // aka i == start
+ queue_destroy (cinfo->send_buffer[cinfo->send_buffer_start], GNUNET_YES);
+ cinfo->send_buffer_start++;
+ cinfo->send_buffer_start %= t->fwd_queue_max;
+ }
+ else
+ {
+ cinfo->send_buffer_n++;
}
cinfo->send_buffer[i] = queue;
- cinfo->send_buffer_n++;
if (cinfo->send_buffer_n > t->fwd_queue_max)
{
GNUNET_break (0);
GNUNET_YES : GNUNET_NO;
t->nobuffer = (0 != (opt & MESH_TUNNEL_OPT_NOBUFFER)) ?
GNUNET_YES : GNUNET_NO;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ " speed_min: %d, nobuffer:%d\n",
+ t->speed_min, t->nobuffer);
if (GNUNET_YES == t->nobuffer)
{
if (own_pos == size - 1)
{
/* It is for us! Send ack. */
- struct MeshTransmissionDescriptor *info;
-
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " It's for us!\n");
peer_info_add_path_to_origin (orig_peer_info, path, GNUNET_NO);
if (NULL == t->peers)
{
- /* New tunnel! Notify clients on data. */
+ /* New tunnel! Notify clients on first payload message. */
t->peers = GNUNET_CONTAINER_multihashmap_create (4);
}
GNUNET_break (GNUNET_SYSERR !=
peer_info_get
(&my_full_id),
GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
- info = GNUNET_malloc (sizeof (struct MeshTransmissionDescriptor));
- info->origin = &t->id;
- info->peer = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
- GNUNET_assert (NULL != info->peer);
- queue_add(info,
- GNUNET_MESSAGE_TYPE_MESH_PATH_ACK,
- sizeof (struct GNUNET_MESH_PathACK),
- info->peer,
- t);
+ send_path_ack (t);
}
else
{
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " Own position: %u\n", own_pos);
if (own_pos < path->length - 1)
- send_message (message, &pi[own_pos + 1], t);
+ send_prebuilt_message (message, &pi[own_pos + 1], t);
else
send_client_tunnel_disconnect(t, NULL);
GNUNET_break_op (0);
return GNUNET_OK;
}
- send_message (message, neighbor, t);
+ send_prebuilt_message (message, neighbor, t);
GNUNET_STATISTICS_update (stats, "# unicast forwarded", 1, GNUNET_NO);
return GNUNET_OK;
}
return GNUNET_OK;
}
GNUNET_STATISTICS_update (stats, "# multicast forwarded", 1, GNUNET_NO);
- tunnel_send_multicast (t, message, GNUNET_NO);
+ tunnel_send_multicast (t, message);
return GNUNET_OK;
}
return GNUNET_OK;
}
GNUNET_PEER_resolve (tree_get_predecessor (t->tree), &id);
- send_message (message, &id, t);
+ send_prebuilt_message (message, &id, t);
GNUNET_STATISTICS_update (stats, "# to origin forwarded", 1, GNUNET_NO);
return GNUNET_OK;
{
struct MeshTunnelChildInfo *cinfo;
+ debug_bck_ack++;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " FWD ACK\n");
cinfo = tunnel_get_neighbor_fc (t, peer);
cinfo->fwd_ack = ack;
GNUNET_break (0);
return GNUNET_OK;
}
- send_message (message, &id, t);
+ send_prebuilt_message (message, &id, t);
return GNUNET_OK;
}
+/**
+ * Core handler for mesh keepalives.
+ *
+ * @param cls closure
+ * @param message message
+ * @param peer peer identity this notification is about
+ * @param atsi performance data
+ * @param atsi_count number of records in 'atsi'
+ * @return GNUNET_OK to keep the connection open,
+ * GNUNET_SYSERR to close it (signal serious error)
+ *
+ * TODO: Check who we got this from, to validate route.
+ */
+static int
+handle_mesh_keepalive (void *cls, const struct GNUNET_PeerIdentity *peer,
+ const struct GNUNET_MessageHeader *message,
+ const struct GNUNET_ATS_Information *atsi,
+ unsigned int atsi_count)
+{
+ struct GNUNET_MESH_TunnelKeepAlive *msg;
+ struct MeshTunnel *t;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got a keepalive packet from %s\n",
+ GNUNET_i2s (peer));
+
+ msg = (struct GNUNET_MESH_TunnelKeepAlive *) message;
+ t = tunnel_get (&msg->oid, ntohl (msg->tid));
+
+ if (NULL == t)
+ {
+ /* TODO notify that we dont know that tunnel */
+ GNUNET_STATISTICS_update (stats, "# keepalive on unknown tunnel", 1, GNUNET_NO);
+ GNUNET_break_op (0);
+ return GNUNET_OK;
+ }
+
+ tunnel_reset_timeout (t);
+
+ GNUNET_STATISTICS_update (stats, "# keepalives forwarded", 1, GNUNET_NO);
+ tunnel_send_multicast (t, message);
+ return GNUNET_OK;
+ }
+
+
+
/**
* Functions to handle messages from core
*/
sizeof (struct GNUNET_MESH_TunnelDestroy)},
{&handle_mesh_data_unicast, GNUNET_MESSAGE_TYPE_MESH_UNICAST, 0},
{&handle_mesh_data_multicast, GNUNET_MESSAGE_TYPE_MESH_MULTICAST, 0},
+ {&handle_mesh_keepalive, GNUNET_MESSAGE_TYPE_MESH_PATH_KEEPALIVE,
+ sizeof (struct GNUNET_MESH_TunnelKeepAlive)},
{&handle_mesh_data_to_orig, GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN, 0},
{&handle_mesh_ack, GNUNET_MESSAGE_TYPE_MESH_ACK,
sizeof (struct GNUNET_MESH_ACK)},
*
* @param cls Closure (tunnel for which to send the keepalive).
* @param tc Notification context.
- *
- * TODO: implement explicit multicast keepalive?
*/
static void
path_refresh (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct MeshTunnel *t = cls;
- struct GNUNET_MessageHeader *payload;
- struct GNUNET_MESH_Multicast *msg;
- size_t size =
- sizeof (struct GNUNET_MESH_Multicast) +
- sizeof (struct GNUNET_MessageHeader);
+ struct GNUNET_MESH_TunnelKeepAlive *msg;
+ size_t size = sizeof (struct GNUNET_MESH_TunnelKeepAlive);
char cbuf[size];
+ t->path_refresh_task = GNUNET_SCHEDULER_NO_TASK;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
{
return;
}
- t->path_refresh_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"sending keepalive for tunnel %d\n", t->id.tid);
- msg = (struct GNUNET_MESH_Multicast *) cbuf;
+ msg = (struct GNUNET_MESH_TunnelKeepAlive *) cbuf;
msg->header.size = htons (size);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_MULTICAST);
- // FIXME: change type to != MULTICAST
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_KEEPALIVE);
msg->oid = my_full_id;
msg->tid = htonl (t->id.tid);
- msg->ttl = htonl (default_ttl);
- msg->pid = htonl (t->fwd_pid + 1);
- t->fwd_pid++;
- payload = (struct GNUNET_MessageHeader *) &msg[1];
- payload->size = htons (sizeof (struct GNUNET_MessageHeader));
- payload->type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_KEEPALIVE);
- tunnel_send_multicast (t, &msg->header, GNUNET_YES);
+ tunnel_send_multicast (t, &msg->header);
t->path_refresh_task =
GNUNET_SCHEDULER_add_delayed (refresh_path_time, &path_refresh, t);
- return;
+ tunnel_reset_timeout(t);
}
const struct GNUNET_PeerIdentity *get_path,
unsigned int get_path_length,
const struct GNUNET_PeerIdentity *put_path,
- unsigned int put_path_length, enum GNUNET_BLOCK_Type type,
+ unsigned int put_path_length,
+ enum GNUNET_BLOCK_Type type,
size_t size, const void *data)
{
const struct MeshRegexBlock *block = data;
}
return;
}
- GNUNET_break (GNUNET_OK ==
- GNUNET_MESH_regex_block_iterate (block, size,
- ®ex_edge_iterator, ctx));
+
+ regex_next_edge (block, size, ctx);
+
return;
}
handle_mesh_data_multicast (client, &my_full_id, ©->header, NULL, 0);
}
- /* receive done gets called when last copy is sent to a neighbor */
+ GNUNET_SERVER_receive_done (t->owner->handle, GNUNET_OK);
return;
}
while (NULL != q)
{
n = q->next;
- if (q->peer == pi)
- {
- /* try to reroute this traffic instead */
- queue_destroy(q, GNUNET_YES);
- }
+ /* TODO try to reroute this traffic instead */
+ queue_destroy(q, GNUNET_YES);
q = n;
}
+ if (NULL != pi->core_transmit)
+ {
+ GNUNET_CORE_notify_transmit_ready_cancel(pi->core_transmit);
+ pi->core_transmit = NULL;
+ }
peer_info_remove_path (pi, pi->id, myid);
if (myid == pi->id)
{
return GNUNET_YES;
}
+
/**
* Task run during shutdown.
*
GNUNET_CORE_disconnect (core_handle);
core_handle = NULL;
}
+ if (NULL != keygen)
+ {
+ GNUNET_CRYPTO_rsa_key_create_stop (keygen);
+ keygen = NULL;
+ }
GNUNET_CONTAINER_multihashmap_iterate (tunnels, &shutdown_tunnel, NULL);
GNUNET_CONTAINER_multihashmap_iterate (peers, &shutdown_peer, NULL);
if (dht_handle != NULL)
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shut down\n");
}
+
+/**
+ * Callback for hostkey read/generation
+ *
+ * @param cls NULL
+ * @param pk the private key
+ * @param emsg error message
+ */
+static void
+key_generation_cb (void *cls,
+ struct GNUNET_CRYPTO_RsaPrivateKey *pk,
+ const char *emsg)
+{
+ struct MeshPeerInfo *peer;
+ struct MeshPeerPath *p;
+
+ keygen = NULL;
+ if (NULL == pk)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Mesh service could not access hostkey. Exiting.\n"));
+ GNUNET_SCHEDULER_shutdown ();
+ return;
+ }
+ my_private_key = pk;
+ GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
+ GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
+ &my_full_id.hashPubKey);
+ myid = GNUNET_PEER_intern (&my_full_id);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Mesh for peer [%s] starting\n",
+ GNUNET_i2s(&my_full_id));
+
+// transport_handle = GNUNET_TRANSPORT_connect(c,
+// &my_full_id,
+// NULL,
+// NULL,
+// NULL,
+// NULL);
+
+
+
+ next_tid = 0;
+ next_local_tid = GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
+
+
+ GNUNET_SERVER_add_handlers (server_handle, client_handlers);
+ nc = GNUNET_SERVER_notification_context_create (server_handle, 1);
+ GNUNET_SERVER_disconnect_notify (server_handle,
+ &handle_local_client_disconnect, NULL);
+
+
+ clients = NULL;
+ clients_tail = NULL;
+ next_client_id = 0;
+
+ announce_applications_task = GNUNET_SCHEDULER_NO_TASK;
+ announce_id_task = GNUNET_SCHEDULER_add_now (&announce_id, cls);
+
+ /* Create a peer_info for the local peer */
+ peer = peer_info_get (&my_full_id);
+ p = path_new (1);
+ p->peers[0] = myid;
+ GNUNET_PEER_change_rc (myid, 1);
+ peer_info_add_path (peer, p, GNUNET_YES);
+ GNUNET_SERVER_resume (server_handle);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Mesh service running\n");
+}
+
+
/**
* Process mesh requests.
*
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
- struct MeshPeerInfo *peer;
- struct MeshPeerPath *p;
char *keyfile;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "starting to run\n");
dht_replication_level = 10;
}
-
- my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
- GNUNET_free (keyfile);
- if (my_private_key == NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Mesh service could not access hostkey. Exiting.\n"));
- GNUNET_SCHEDULER_shutdown ();
- return;
- }
- GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
- GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
- &my_full_id.hashPubKey);
- myid = GNUNET_PEER_intern (&my_full_id);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Mesh for peer [%s] starting\n",
- GNUNET_i2s(&my_full_id));
-
-// transport_handle = GNUNET_TRANSPORT_connect(c,
-// &my_full_id,
-// NULL,
-// NULL,
-// NULL,
-// NULL);
-
- dht_handle = GNUNET_DHT_connect (c, 64);
- if (dht_handle == NULL)
- {
- GNUNET_break (0);
- }
-
- stats = GNUNET_STATISTICS_create ("mesh", c);
-
-
- next_tid = 0;
- next_local_tid = GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
-
tunnels = GNUNET_CONTAINER_multihashmap_create (32);
incoming_tunnels = GNUNET_CONTAINER_multihashmap_create (32);
peers = GNUNET_CONTAINER_multihashmap_create (32);
applications = GNUNET_CONTAINER_multihashmap_create (32);
types = GNUNET_CONTAINER_multihashmap_create (32);
- GNUNET_SERVER_add_handlers (server_handle, client_handlers);
- nc = GNUNET_SERVER_notification_context_create (server_handle, 1);
- GNUNET_SERVER_disconnect_notify (server_handle,
- &handle_local_client_disconnect, NULL);
-
-
- clients = NULL;
- clients_tail = NULL;
- next_client_id = 0;
-
- announce_applications_task = GNUNET_SCHEDULER_NO_TASK;
- announce_id_task = GNUNET_SCHEDULER_add_now (&announce_id, cls);
-
- /* Create a peer_info for the local peer */
- peer = peer_info_get (&my_full_id);
- p = path_new (1);
- p->peers[0] = myid;
- GNUNET_PEER_change_rc (myid, 1);
- peer_info_add_path (peer, p, GNUNET_YES);
+ dht_handle = GNUNET_DHT_connect (c, 64);
+ if (NULL == dht_handle)
+ {
+ GNUNET_break (0);
+ }
+ stats = GNUNET_STATISTICS_create ("mesh", c);
+ GNUNET_SERVER_suspend (server_handle);
/* Scheduled the task to clean up when shutdown is called */
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "end of run()\n");
+ keygen = GNUNET_CRYPTO_rsa_key_create_start (keyfile, &key_generation_cb, NULL);
+ GNUNET_free (keyfile);
}
+
/**
* The main function for the mesh service.
*
INTERVAL_SHOW;
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Mesh for peer [%s] FWD ACKs %u, BCK ACKs %u\n",
+ GNUNET_i2s(&my_full_id), debug_fwd_ack, debug_bck_ack);
+
return ret;
}
projects / oweals / gnunet.git / blobdiff