*/
static struct GNUNET_CORE_Handle *core_handle;
+/**
+ * Handle to communicate with transport
+ */
+// static struct GNUNET_TRANSPORT_Handle *transport_handle;
+
/**
* Handle to use DHT
*/
{
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;
{
struct MeshPathInfo *path_info = cls;
- if (GNUNET_SCHEDULER_REASON_SHUTDOWN == tc->reason)
+ if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
{
GNUNET_free (cls);
+ return;
}
peer_info_connect (path_info->peer, path_info->t);
GNUNET_free (cls);
* @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 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
- 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)
{
*
* @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);
}
/**
- * 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);
}
{
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);
+ 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 (
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;
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);
}
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);
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