*/
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 */
* 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
*
* @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
{
*
* @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))
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;
}
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);
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: (SERVER DOWN)\n");
return;
}
- GNUNET_SERVER_client_drop (client);
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,
uint16_t i;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: new client connected\n");
- GNUNET_SERVER_client_keep (client);
/* Check data sanity */
size = ntohs (message->size) - sizeof (struct GNUNET_MESH_ClientConnect);
cc_msg = (struct GNUNET_MESH_ClientConnect *) message;
#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)
{
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
/* 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