/** Used to allow a client send more traffic to the service after a
* previous packet was tried to be sent to a neighbor and couldn't */
- GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+ GNUNET_SCHEDULER_TaskIdentifier *timeout_task;
};
*/
static struct GNUNET_CORE_Handle *core_handle;
+/**
+ * Handle to communicate with transport
+ */
+// static struct GNUNET_TRANSPORT_Handle *transport_handle;
+
/**
* Handle to use DHT
*/
* - Adapt X to churn
*/
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: DHT_put for ID %s started.\n",
- GNUNET_h2s_full (&my_full_id.hashPubKey));
+ GNUNET_i2s (&my_full_id));
GNUNET_DHT_put (dht_handle, /* DHT handle */
&my_full_id.hashPubKey, /* Key to use */
10U, /* Replication level */
return GNUNET_CONTAINER_multihashmap_contains (c->types, &hc);
}
+
+/**
+ * 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
+ */
static void
client_allow_send(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (GNUNET_SCHEDULER_REASON_SHUTDOWN == tc->reason)
return;
- info->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+#if MESH_DEBUG
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "MESH: CLIENT ALLOW SEND DESPITE %u COPIES PENDING\n",
+ *(info->copies));
+#endif
+ *(info->timeout_task) = GNUNET_SCHEDULER_NO_TASK;
GNUNET_SERVER_receive_done(info->client, GNUNET_OK);
}
send_core_data_multicast (void *cls, size_t size, void *buf);
+/**
+ * Decrements the reference counter and frees all resources if needed
+ *
+ * @param dd Data Descriptor used in a multicast message
+ */
+static void
+data_descriptor_decrement_multicast (struct MeshDataDescriptor *dd)
+{
+ if (0 == --(*(dd->copies)))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Last copy!\n");
+ if (NULL != dd->client)
+ {
+ if (GNUNET_SCHEDULER_NO_TASK != *(dd->timeout_task))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "MESH: cancelling client timeout (%u)...\n",
+ *(dd->timeout_task));
+ GNUNET_SCHEDULER_cancel(*(dd->timeout_task));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: notifying client...\n");
+ GNUNET_SERVER_receive_done (dd->client, GNUNET_OK);
+ }
+ GNUNET_free (dd->timeout_task);
+ }
+ GNUNET_free (dd->copies);
+ GNUNET_free (dd->data);
+ }
+}
+
+
/**
* Cancel a core transmission that was already requested and free all resources
* associated to the request.
case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: type payload\n");
dd = peer->infos[i];
- if (0 == --(*dd->copies))
- {
- GNUNET_free (dd->copies);
- GNUNET_free (dd->data);
- }
+ data_descriptor_decrement_multicast (dd);
break;
case GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: type create path\n");
* Sends an already built message to a peer, properly registrating
* all used resources.
*
- * @param message Message to send.
+ * @param message Message to send. Fucntion makes a copy of it.
* @param peer Short ID of the neighbor whom to send the message.
*/
static void
{
struct MeshDataDescriptor *info;
struct MeshPeerInfo *neighbor;
+ struct MeshPeerPath *p;
unsigned int i;
size_t size;
+// GNUNET_TRANSPORT_try_connect();
+
size = ntohs (message->size);
info = GNUNET_malloc (sizeof (struct MeshDataDescriptor));
info->data = GNUNET_malloc (size);
memcpy (info->data, message, size);
neighbor = peer_info_get (peer);
+ for (p = neighbor->path_head; NULL != p; p = p->next)
+ {
+ if (2 == p->length)
+ {
+ break;
+ }
+ }
+ if (NULL == p)
+ {
+ GNUNET_break (0);
+ return;
+ }
i = peer_info_transmit_slot (neighbor);
info->handler_n = i;
info->peer = neighbor;
static void
send_destroy_path (struct MeshTunnel *t, GNUNET_PEER_Id destination)
{
- struct GNUNET_MESH_ManipulatePath *msg;
- struct GNUNET_PeerIdentity *pi;
struct MeshPeerPath *p;
- unsigned int i;
size_t size;
p = tree_get_path_to_peer(t->tree, destination);
}
size = sizeof (struct GNUNET_MESH_ManipulatePath);
size += p->length * sizeof (struct GNUNET_PeerIdentity);
- msg = GNUNET_malloc (size);
- msg->header.size = htons (size);
- msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_DESTROY);
- msg->tid = htonl (t->id.tid);
- pi = (struct GNUNET_PeerIdentity *) &msg[1];
- for (i = 0; i < p->length; i++)
{
- GNUNET_PEER_resolve(p->peers[i], &pi[i]);
+ struct GNUNET_MESH_ManipulatePath *msg;
+ struct GNUNET_PeerIdentity *pi;
+ char cbuf[size];
+ unsigned int i;
+
+ msg = (struct GNUNET_MESH_ManipulatePath *) cbuf;
+ msg->header.size = htons (size);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_DESTROY);
+ msg->tid = htonl (t->id.tid);
+ pi = (struct GNUNET_PeerIdentity *) &msg[1];
+ for (i = 0; i < p->length; i++)
+ {
+ GNUNET_PEER_resolve(p->peers[i], &pi[i]);
+ }
+ send_message (&msg->header, path_get_first_hop(t->tree, destination));
}
- send_message (&msg->header, path_get_first_hop(t->tree, destination));
path_destroy (p);
}
if (NULL != peer->path_head)
{
p = tree_get_path_to_peer(t->tree, peer->id);
+ if (NULL == p)
+ {
+ GNUNET_break (0);
+ return;
+ }
+
if (p->length > 1)
{
send_create_path(peer, p, t);
}
+/**
+ * Task to delay the connection of a peer
+ *
+ * @param cls Closure (path info with tunnel and peer to connect).
+ * Will be free'd on exection.
+ * @param tc TaskContext
+ */
+static void
+peer_info_connect_task (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct MeshPathInfo *path_info = cls;
+
+ if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
+ {
+ GNUNET_free (cls);
+ return;
+ }
+ peer_info_connect (path_info->peer, path_info->t);
+ GNUNET_free (cls);
+}
+
+
/**
* Destroy the peer_info and free any allocated resources linked to it
*
GNUNET_PEER_resolve (pi->id, &id);
GNUNET_PEER_change_rc (pi->id, -1);
- if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (peers, &id.hashPubKey, pi))
+ if (GNUNET_YES !=
+ GNUNET_CONTAINER_multihashmap_remove (peers,&id.hashPubKey, pi))
{
GNUNET_break (0);
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
* @param peer_info Destination peer to add the path to.
* @param path New path to add. Last peer must be the peer in arg 1.
* Path will be either used of freed if already known.
- *
- * TODO: trim the part from origin to us? Add it as path to origin?
+ * @param trusted Do we trust that this path is real?
*/
void
-path_add_to_peer (struct MeshPeerInfo *peer_info, struct MeshPeerPath *path)
+path_add_to_peer (struct MeshPeerInfo *peer_info,
+ struct MeshPeerPath *path,
+ int trusted)
{
struct MeshPeerPath *aux;
unsigned int l;
unsigned int l2;
- if (NULL == peer_info || NULL == path)
+ if ((NULL == peer_info) || (NULL == path))
{
GNUNET_break (0);
+ path_destroy (path);
return;
}
+ if (path->length <= 2 && GNUNET_NO == trusted)
+ {
+ /* Only allow CORE to tell us about direct paths */
+ return;
+ }
+ for (l = 1; l < path->length; l++)
+ {
+ if (path->peers[l] == myid)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "MESH: shortening path by %u\n",
+ l);
+ for (l2 = 0; l2 < path->length - l - 1 ; l2++)
+ {
+ path->peers[l2] = path->peers[l + l2];
+ }
+ path->length -= l;
+ l = 0;
+ path->peers = GNUNET_realloc (path->peers,
+ path->length * sizeof (GNUNET_PEER_Id));
+ }
+ }
+#if MESH_DEBUG
+ {
+ struct GNUNET_PeerIdentity id;
+ GNUNET_PEER_resolve (peer_info->id, &id);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "MESH: adding path [%u] to peer %s\n",
+ path->length,
+ GNUNET_i2s (&id));
+ }
+#endif
l = path_get_length (path);
if (0 == l)
{
if (l2 > l)
{
GNUNET_CONTAINER_DLL_insert_before (peer_info->path_head,
- peer_info->path_tail, aux, path);
+ peer_info->path_tail,
+ aux,
+ path);
+ return;
}
else
{
}
}
}
- GNUNET_CONTAINER_DLL_insert_tail (peer_info->path_head, peer_info->path_tail,
+ GNUNET_CONTAINER_DLL_insert_tail (peer_info->path_head,
+ peer_info->path_tail,
path);
return;
}
*
* @param peer_info Peer to add the path to, being the origin of the path.
* @param path New path to add after being inversed.
+ * @param trusted Do we trust that this path is real?
*/
static void
-path_add_to_origin (struct MeshPeerInfo *peer_info, struct MeshPeerPath *path)
+path_add_to_origin (struct MeshPeerInfo *peer_info,
+ struct MeshPeerPath *path,
+ int trusted)
{
path_invert(path);
- path_add_to_peer (peer_info, path);
+ path_add_to_peer (peer_info, path, trusted);
}
*/
static struct MeshPeerPath *
path_build_from_dht (const struct GNUNET_PeerIdentity *get_path,
- unsigned int get_path_length,
+ unsigned int get_path_length,
const struct GNUNET_PeerIdentity *put_path,
- unsigned int put_path_length)
+ unsigned int put_path_length)
{
struct MeshPeerPath *p;
GNUNET_PEER_Id id;
if (get_path_length > 0)
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"MESH: (first of GET: %s)\n",
- GNUNET_h2s_full(&get_path[0].hashPubKey));
+ GNUNET_i2s(&get_path[0]));
if (put_path_length > 0)
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"MESH: (first of PUT: %s)\n",
- GNUNET_h2s_full(&put_path[0].hashPubKey));
+ GNUNET_i2s(&put_path[0]));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"MESH: In total: %d hops\n",
p->length);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"MESH: %u: %s\n",
p->peers[i],
- GNUNET_h2s_full(&peer_id.hashPubKey));
+ GNUNET_i2s(&peer_id));
}
#endif
return p;
/**
- * Search for a tunnel among the tunnels for a client
+ * Search for a tunnel among the incoming tunnels
*
- * @param c the client whose tunnels to search in
* @param tid the local id of the tunnel
*
* @return tunnel handler, NULL if doesn't exist
*/
static struct MeshTunnel *
-tunnel_get_by_local_id (struct MeshClient *c, MESH_TunnelNumber tid)
+tunnel_get_incoming (MESH_TunnelNumber tid)
{
GNUNET_HashCode hash;
+ GNUNET_assert (tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV);
GNUNET_CRYPTO_hash (&tid, sizeof (MESH_TunnelNumber), &hash);
+ return GNUNET_CONTAINER_multihashmap_get (incoming_tunnels, &hash);
+}
+
+
+/**
+ * Search for a tunnel among the tunnels for a client
+ *
+ * @param c the client whose tunnels to search in
+ * @param tid the local id of the tunnel
+ *
+ * @return tunnel handler, NULL if doesn't exist
+ */
+static struct MeshTunnel *
+tunnel_get_by_local_id (struct MeshClient *c, MESH_TunnelNumber tid)
+{
if (tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV)
{
- return GNUNET_CONTAINER_multihashmap_get (incoming_tunnels, &hash);
+ return tunnel_get_incoming (tid);
+ }
+ else
+ {
+ GNUNET_HashCode hash;
+
+ GNUNET_CRYPTO_hash (&tid, sizeof (MESH_TunnelNumber), &hash);
+ return GNUNET_CONTAINER_multihashmap_get (c->tunnels, &hash);
}
- return GNUNET_CONTAINER_multihashmap_get (c->tunnels, &hash);
}
notify_peer_disconnected (const struct MeshTunnelTreeNode *n)
{
struct MeshPeerInfo *peer;
+ struct MeshPathInfo *path_info;
if (NULL != n->t->client && NULL != nc)
{
&msg.header, GNUNET_NO);
}
peer = peer_info_get_short(n->peer);
- peer_info_connect(peer, n->t);
+ path_info = GNUNET_malloc (sizeof (struct MeshPathInfo));
+ path_info->peer = peer;
+ path_info->t = n->t;
+ GNUNET_SCHEDULER_add_now(&peer_info_connect_task, path_info);
}
{
t->peers_total++;
GNUNET_array_append (peer->tunnels, peer->ntunnels, t);
- GNUNET_CONTAINER_multihashmap_put(
+ GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put(
t->peers,
&id.hashPubKey,
peer,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
}
if (NULL != (p = peer->path_head))
* @param msg Message to be sent
*
* @return Number of copies sent.
+ *
+ * TODO: unifiy shared resources and reference counter management
*/
static int
tunnel_send_multicast (struct MeshTunnel *t,
struct GNUNET_PeerIdentity neighbor;
struct MeshDataDescriptor *info;
struct MeshTunnelTreeNode *n;
+ struct MeshTunnelTreeNode *counter;
+ GNUNET_SCHEDULER_TaskIdentifier *task;
unsigned int *copies;
unsigned int i;
size_t size;
return 0;
}
copies = GNUNET_malloc (sizeof (unsigned int));
- for (*copies = 0; NULL != n; n = n->next)
+ for (counter = n; NULL != counter; counter = counter->next)
(*copies)++;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: (%u copies)\n", *copies);
- n = t->tree->me->children_head;
data = GNUNET_malloc (size);
memcpy (data, msg, size);
+ if (NULL != t->client)
+ {
+ task = GNUNET_malloc (sizeof (GNUNET_SCHEDULER_TaskIdentifier));
+ *task = GNUNET_SCHEDULER_add_delayed (UNACKNOWLEDGED_WAIT,
+ &client_allow_send,
+ t->client->handle);
+ }
+ else
+ task = NULL; // So GCC shuts up about task being potentially uninitialized
while (NULL != n)
{
info = GNUNET_malloc (sizeof (struct MeshDataDescriptor));
if (NULL != t->client)
{
info->client = t->client->handle;
- info->timeout_task = GNUNET_SCHEDULER_add_delayed (UNACKNOWLEDGED_WAIT,
- &client_allow_send,
- t->client->handle);
+ info->timeout_task = task;
}
info->destination = n->peer;
GNUNET_PEER_resolve (n->peer, &neighbor);
}
}
#endif
- if (0 == --(*info->copies))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Last copy!\n");
- if (NULL != info->client)
- {
- if (GNUNET_SCHEDULER_NO_TASK != info->timeout_task)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "MESH: cancelling client timeout (%u)...\n",
- info->timeout_task);
- GNUNET_SCHEDULER_cancel(info->timeout_task);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: notifying client...\n");
- GNUNET_SERVER_receive_done (info->client, GNUNET_OK);
- }
- }
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: freeing memory...\n");
- GNUNET_free (info->data);
- GNUNET_free (info->copies);
- }
+ data_descriptor_decrement_multicast (info);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: freeing info...\n");
GNUNET_free (info);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: return %u\n", total_size);
t = GNUNET_malloc (sizeof (struct MeshTunnel));
t->id.oid = GNUNET_PEER_intern (pi);
t->id.tid = tid;
+ while (NULL != tunnel_get_incoming (next_local_tid))
+ next_local_tid = (next_local_tid + 1) | GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
t->local_tid = next_local_tid++;
- /* FIXME test if taken */
- next_local_tid |= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
+ next_local_tid = next_local_tid | GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
t->tree = tree_new(t, t->id.oid);
GNUNET_CRYPTO_hash (&t->id, sizeof (struct MESH_TunnelID), &hash);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"MESH: It's for us!\n");
- path_add_to_origin (orig_peer_info, path);
- t->peers = GNUNET_CONTAINER_multihashmap_create(4);
+ path_add_to_origin (orig_peer_info, path, GNUNET_NO);
+ if (NULL == t->peers)
+ t->peers = GNUNET_CONTAINER_multihashmap_create(4);
GNUNET_break (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (
t->peers,
&my_full_id.hashPubKey,
path2 = path_duplicate(path);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"MESH: Retransmitting.\n");
- path_add_to_peer(dest_peer_info, path);
+ path_add_to_peer(dest_peer_info, path, GNUNET_NO);
path = path_duplicate(path2);
- path_add_to_origin(orig_peer_info, path2);
+ path_add_to_origin(orig_peer_info, path2, GNUNET_NO);
send_create_path(dest_peer_info, path, t);
}
return GNUNET_OK;
if (own_pos < path->length - 1)
send_message (message, &pi[own_pos + 1]);
tunnel_delete_peer (t, path->peers[path->length - 1]);
+ path_destroy (path);
return GNUNET_OK;
}
t = tunnel_get (&msg->oid, ntohl (msg->tid));
if (NULL == t)
{
- /* TODO notify back: we don't know this tunnel */
- GNUNET_break_op (0);
+ /* Probably already got the message from another path,
+ * destroyed the tunnel and retransmitted to children.
+ * Safe to ignore.
+ */
return GNUNET_OK;
}
if (t->id.oid == myid)
GNUNET_PEER_resolve (path_info->peer->id, &pi);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"MESH: for %s\n",
- GNUNET_h2s_full(&pi.hashPubKey));
+ GNUNET_i2s(&pi));
// GNUNET_DHT_get_stop(path_info->peer->dhtget);
// path_info->peer->dhtget = NULL;
p = path_build_from_dht (get_path, get_path_length,
put_path, put_path_length);
- path_add_to_peer (path_info->peer, p);
+ path_add_to_peer (path_info->peer, p, GNUNET_NO);
for (i = 0; i < path_info->peer->ntunnels; i++)
{
tunnel_add_peer (path_info->peer->tunnels[i], path_info->peer);
peer_info_connect(path_info->peer, path_info->t);
}
- GNUNET_free (path_info);
+// GNUNET_free (path_info);
return;
}
p = path_build_from_dht (get_path, get_path_length,
put_path, put_path_length);
- path_add_to_peer (peer_info, p);
+ path_add_to_peer (peer_info, p, GNUNET_NO);
tunnel_add_peer(t, peer_info);
peer_info_connect (peer_info, t);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: client disconnected\n");
if (client == NULL)
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: (SERVER DOWN)\n");
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: (SERVER DOWN)\n");
+ return;
+ }
c = clients;
while (NULL != c)
{
continue;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: matching client found\n");
+ GNUNET_SERVER_client_drop (c->handle);
if (NULL != c->tunnels)
{
GNUNET_CONTAINER_multihashmap_iterate (c->tunnels,
}
if (NULL != c->types)
GNUNET_CONTAINER_multihashmap_destroy (c->types);
- GNUNET_CONTAINER_DLL_remove (clients, clients_tail, c);
next = c->next;
+ GNUNET_CONTAINER_DLL_remove (clients, clients_tail, c);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: CLIENT FREE at %p\n", c);
GNUNET_free (c);
c = next;
}
#if MESH_DEBUG
c->id = next_client_id++;
#endif
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: CLIENT NEW %u at %p\n", c->id, c);
c->handle = client;
+ GNUNET_SERVER_client_keep (client);
a = (GNUNET_MESH_ApplicationType *) &cc_msg[1];
if (napps > 0)
{
}
t = GNUNET_malloc (sizeof (struct MeshTunnel));
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: CREATED TUNNEL at %p\n", t);
while (NULL != tunnel_get_by_pi (myid, next_tid))
next_tid = (next_tid + 1) & ~GNUNET_MESH_LOCAL_TUNNEL_ID_CLI;
t->id.tid = next_tid++;
+ next_tid = next_tid & ~GNUNET_MESH_LOCAL_TUNNEL_ID_CLI;
t->id.oid = myid;
t->local_tid = ntohl (t_msg->tunnel_id);
+#if MESH_DEBUG
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "MESH: CREATED TUNNEL %s [%x] (%x)\n",
+ GNUNET_i2s (&my_full_id),
+ t->id.tid,
+ t->local_tid);
+#endif
t->client = c;
t->peers = GNUNET_CONTAINER_multihashmap_create (32);
GNUNET_CRYPTO_hash (&t->local_tid, sizeof (MESH_TunnelNumber), &hash);
if (GNUNET_OK !=
- GNUNET_CONTAINER_multihashmap_put (c->tunnels, &hash, t,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+ GNUNET_CONTAINER_multihashmap_put (
+ c->tunnels, &hash, t,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
GNUNET_CRYPTO_hash (&t->id, sizeof (struct MESH_TunnelID), &hash);
if (GNUNET_OK !=
- GNUNET_CONTAINER_multihashmap_put (tunnels, &hash, t,
- GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+ GNUNET_CONTAINER_multihashmap_put (
+ tunnels, &hash, t,
+ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
/* Remove from local id hashmap */
GNUNET_CRYPTO_hash (&tid, sizeof (MESH_TunnelNumber), &hash);
t = GNUNET_CONTAINER_multihashmap_get (c->tunnels, &hash);
- GNUNET_CONTAINER_multihashmap_remove (c->tunnels, &hash, t);
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_CONTAINER_multihashmap_remove (c->tunnels, &hash, t));
t->client = NULL;
tunnel_send_destroy (t);
return;
}
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "MESH: for %s\n",
- GNUNET_h2s_full(&peer_msg->peer.hashPubKey));
+ GNUNET_i2s(&peer_msg->peer));
peer_info = peer_info_get (&peer_msg->peer);
tunnel_add_peer(t, peer_info);
GNUNET_DHT_get_stop (t->dht_get_type);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: looking in DHT for %s\n",
- GNUNET_h2s_full (&hash));
+ GNUNET_h2s (&hash));
t->dht_get_type =
GNUNET_DHT_get_start (dht_handle,
GNUNET_TIME_UNIT_FOREVER_REL,
#if MESH_DEBUG_CONNECTION
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Peer connected\n");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: %s\n",
- GNUNET_h2s(&my_full_id.hashPubKey));
+ GNUNET_i2s(&my_full_id));
#endif
peer_info = peer_info_get (peer);
if (myid == peer_info->id)
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: %s\n",
- GNUNET_h2s(&peer->hashPubKey));
+ GNUNET_i2s(peer));
}
#endif
path = path_new (2);
path->peers[1] = peer_info->id;
GNUNET_PEER_change_rc(myid, 1);
GNUNET_PEER_change_rc(peer_info->id, 1);
- path_add_to_peer (peer_info, path);
+ path_add_to_peer (peer_info, path, GNUNET_YES);
return;
}
NULL, /* Don't notify about all outbound messages */
GNUNET_NO, /* For header-only out notification */
core_handlers); /* Register these handlers */
+
if (core_handle == NULL)
{
GNUNET_break (0);
&my_full_id.hashPubKey);
myid = GNUNET_PEER_intern (&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)
{
peer = peer_info_get(&my_full_id);
p = path_new (1);
p->peers[0] = myid;
- path_add_to_peer(peer, p);
+ path_add_to_peer(peer, p, GNUNET_YES);
/* Scheduled the task to clean up when shutdown is called */
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
projects / oweals / gnunet.git / blobdiff