/************************ DEBUG FUNCTIONS ****************************/
/******************************************************************************/
-#if LATER /* FIXME DHT */
+
/**
* GNUNET_SCHEDULER_Task for printing a message after some operation is done
* @param cls string to print
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: %s\n", s);
}
-#endif
/******************************************************************************/
/**
* Handle to use DHT
*/
-//static struct GNUNET_DHT_Handle *dht_handle; FIXME DHT
+static struct GNUNET_DHT_Handle *dht_handle;
/**
* Handle to server
announce_application (void *cls, const GNUNET_HashCode * key, void *value)
{
/* FIXME are hashes in multihash map equal on all aquitectures? */
- /* FIXME DHT */
-/* GNUNET_DHT_put (dht_handle, key, 10U, GNUNET_DHT_RO_RECORD_ROUTE,
+
+ GNUNET_DHT_put (dht_handle, key, 10U, GNUNET_DHT_RO_RECORD_ROUTE,
GNUNET_BLOCK_TYPE_TEST, sizeof (struct GNUNET_PeerIdentity),
(const char *) &my_full_id,
#if MESH_DEBUG
GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
APP_ANNOUNCE_TIME),
APP_ANNOUNCE_TIME, NULL, NULL);
-#endif*/
+#endif
return GNUNET_OK;
}
* - Set data expiration in function of X
* - 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_DHT_put (dht_handle, /* DHT handle */ FIXME DHT
-// &my_full_id.hashPubKey, /* Key to use */
-// 10U, /* Replication level */
-// GNUNET_DHT_RO_RECORD_ROUTE, /* DHT options */
-// GNUNET_BLOCK_TYPE_TEST, /* Block type */
-// sizeof(my_full_id), /* Size of the data */
-// (char *)&my_full_id, /* Data itself */
-// GNUNET_TIME_absolute_get_forever (), /* Data expiration */
-// GNUNET_TIME_UNIT_FOREVER_REL, /* Retry time */
-// #if MESH_DEBUG
-// &mesh_debug, "DHT_put for id completed");
-// #else
-// NULL, /* Continuation */
-// NULL); /* Continuation closure */
-// #endif
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: DHT_put for ID %s started.\n",
+ GNUNET_h2s_full (&my_full_id.hashPubKey));
+ GNUNET_DHT_put (dht_handle, /* DHT handle */
+ &my_full_id.hashPubKey, /* Key to use */
+ 10U, /* Replication level */
+ GNUNET_DHT_RO_RECORD_ROUTE, /* DHT options */
+ GNUNET_BLOCK_TYPE_TEST, /* Block type */
+ sizeof(my_full_id), /* Size of the data */
+ (char *)&my_full_id, /* Data itself */
+ GNUNET_TIME_absolute_get_forever (), /* Data expiration */
+ GNUNET_TIME_UNIT_FOREVER_REL, /* Retry time */
+#if MESH_DEBUG
+ &mesh_debug, "DHT_put for id completed");
+#else
+ NULL, /* Continuation */
+ NULL); /* Continuation closure */
+#endif
announce_id_task =
GNUNET_SCHEDULER_add_delayed (ID_ANNOUNCE_TIME, &announce_id, cls);
}
-#if LATER /* FIXME DHT */
+
/**
* Function to process paths received for a new peer addition. The recorded
* paths form the initial tunnel, which can be optimized later.
const struct GNUNET_PeerIdentity *put_path,
unsigned int put_path_length,
enum GNUNET_BLOCK_Type type, size_t size, const void *data);
-#endif
+
/******************************************************************************/
/****************** GENERAL HELPER FUNCTIONS ************************/
}
else
{
-// struct MeshPathInfo *path_info;
+ struct MeshPathInfo *path_info;
if (NULL != peer_d->dhtget)
return;
-// path_info = GNUNET_malloc(sizeof(struct MeshPathInfo)); FIXME DHT
-// path_info->path = p;
-// path_info->peer = peer_d;
-// path_info->t = peer->tunnels[i];
-// peer_d->dhtget = GNUNET_DHT_get_start(dht_handle, /* handle */
-// GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */
-// GNUNET_BLOCK_TYPE_TEST, /* type */
-// &id.hashPubKey, /*key to search */
-// 4, /* replication level */
-// GNUNET_DHT_RO_RECORD_ROUTE,
-// NULL, /* xquery */
-// 0, /* xquery bits */
-// &dht_get_id_handler,
-// (void *) path_info);
+ path_info = GNUNET_malloc(sizeof(struct MeshPathInfo));
+ path_info->path = p;
+ path_info->peer = peer_d;
+ path_info->t = peer->tunnels[i];
+ peer_d->dhtget = GNUNET_DHT_get_start(dht_handle, /* handle */
+ GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */
+ GNUNET_BLOCK_TYPE_TEST, /* type */
+ &id.hashPubKey, /*key to search */
+ 4, /* replication level */
+ GNUNET_DHT_RO_RECORD_ROUTE,
+ NULL, /* xquery */
+ 0, /* xquery bits */
+ &dht_get_id_handler,
+ (void *) path_info);
}
}
}
}
-#if LATER /* FIXME DHT */
/**
* Build a PeerPath from the paths returned from the DHT, reversing the paths
* to obtain a local peer -> destination path and interning the peer ids.
#endif
return p;
}
-#endif
/**
return;
}
-#if LATER /* FIXME DHT */
+
/**
* Function to process paths received for a new peer addition. The recorded
* paths form the initial tunnel, which can be optimized later.
{
// Find ourselves some alternate initial path to the destination: retry
GNUNET_DHT_get_stop (path_info->peer->dhtget);
-// path_info->peer->dhtget = GNUNET_DHT_get_start (dht_handle, /* handle */ FIXME DHT
-// GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */
-// GNUNET_BLOCK_TYPE_TEST, /* type */
-// &pi.hashPubKey, /*key to search */
-// 4, /* replication level */
-// GNUNET_DHT_RO_RECORD_ROUTE,
-// NULL, /* xquery */
-// 0, /* xquery bits */
-// &dht_get_id_handler,
-// (void *) path_info);
+ path_info->peer->dhtget = GNUNET_DHT_get_start (dht_handle, /* handle */
+ GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */
+ GNUNET_BLOCK_TYPE_TEST, /* type */
+ &pi.hashPubKey, /*key to search */
+ 4, /* replication level */
+ GNUNET_DHT_RO_RECORD_ROUTE,
+ NULL, /* xquery */
+ 0, /* xquery bits */
+ &dht_get_id_handler,
+ (void *) path_info);
return;
}
}
if ((NULL == get_path || NULL == put_path) && NULL == peer_info->path_head &&
NULL == peer_info->dhtget)
{
-// path_info = GNUNET_malloc (sizeof (struct MeshPathInfo)); FIXME DHT
-// path_info->peer = peer_info;
-// path_info->t = t;
-// /* we don't have a route to the peer, let's try a direct lookup */
-// peer_info->dhtget = GNUNET_DHT_get_start (dht_handle,
-// /* handle */
-// GNUNET_TIME_UNIT_FOREVER_REL,
-// /* timeout */
-// GNUNET_BLOCK_TYPE_TEST,
-// /* block type */
-// &pi->hashPubKey,
-// /* key to look up */
-// 10U,
-// /* replication level */
-// GNUNET_DHT_RO_RECORD_ROUTE,
-// /* option to dht: record route */
-// NULL, /* xquery */
-// 0, /* xquery bits */
-// dht_get_id_handler,
-// /* callback */
-// path_info); /* closure */
+ path_info = GNUNET_malloc (sizeof (struct MeshPathInfo));
+ path_info->peer = peer_info;
+ path_info->t = t;
+ /* we don't have a route to the peer, let's try a direct lookup */
+ peer_info->dhtget = GNUNET_DHT_get_start (dht_handle,
+ /* handle */
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ /* timeout */
+ GNUNET_BLOCK_TYPE_TEST,
+ /* block type */
+ &pi->hashPubKey,
+ /* key to look up */
+ 10U,
+ /* replication level */
+ GNUNET_DHT_RO_RECORD_ROUTE,
+ /* option to dht: record route */
+ NULL, /* xquery */
+ 0, /* xquery bits */
+ dht_get_id_handler,
+ /* callback */
+ path_info); /* closure */
return;
}
send_client_peer_connected(t, myid);
}
-#endif
/******************************************************************************/
/********************* MESH LOCAL HANDLES **************************/
/* Start DHT search if needed, otherwise just add peer to tunnel. */
if (NULL == peer_info->dhtget && NULL == peer_info->path_head)
{
-// path_info = GNUNET_malloc(sizeof(struct MeshPathInfo));
-// path_info->peer = peer_info;
-// path_info->t = t;
-// peer_info->dhtget = GNUNET_DHT_get_start(dht_handle, /* handle */ FIXME DHT
-// GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */
-// GNUNET_BLOCK_TYPE_TEST, /* type */
-// &peer_msg->peer.hashPubKey, /*key to search */
-// 4, /* replication level */
-// GNUNET_DHT_RO_RECORD_ROUTE,
-// NULL, /* xquery */
-// 0, /* xquery bits */
-// &dht_get_id_handler,
-// (void *) path_info);
+ path_info = GNUNET_malloc(sizeof(struct MeshPathInfo));
+ path_info->peer = peer_info;
+ path_info->t = t;
+ peer_info->dhtget = GNUNET_DHT_get_start(dht_handle, /* handle */
+ GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */
+ GNUNET_BLOCK_TYPE_TEST, /* type */
+ &peer_msg->peer.hashPubKey, /*key to search */
+ 4, /* replication level */
+ GNUNET_DHT_RO_RECORD_ROUTE,
+ NULL, /* xquery */
+ 0, /* xquery bits */
+ &dht_get_id_handler,
+ (void *) path_info);
}
else if (NULL != peer_info->path_head)
{
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: looking in DHT for %s\n",
GNUNET_h2s_full (&hash));
-// c->dht_get_type = FIXME DHT
-// GNUNET_DHT_get_start (dht_handle, GNUNET_TIME_UNIT_FOREVER_REL,
-// GNUNET_BLOCK_TYPE_TEST, &hash, 10U,
-// GNUNET_DHT_RO_RECORD_ROUTE, NULL, 0,
-// &dht_get_type_handler, t);
+ c->dht_get_type =
+ GNUNET_DHT_get_start (dht_handle, GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_BLOCK_TYPE_TEST, &hash, 10U,
+ GNUNET_DHT_RO_RECORD_ROUTE, NULL, 0,
+ &dht_get_type_handler, t);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
static void
shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
-// struct MeshClient *c;
+ struct MeshClient *c;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: shutting down\n");
if (core_handle != NULL)
GNUNET_CORE_disconnect (core_handle);
core_handle = NULL;
}
-// if (dht_handle != NULL) FIXME DHT
-// {
-// for (c = clients; NULL != c; c = c->next)
-// if (NULL != c->dht_get_type)
-// GNUNET_DHT_get_stop (c->dht_get_type);
-// GNUNET_DHT_disconnect (dht_handle);
-// dht_handle = NULL;
-// }
+ if (dht_handle != NULL)
+ {
+ for (c = clients; NULL != c; c = c->next)
+ if (NULL != c->dht_get_type)
+ GNUNET_DHT_get_stop (c->dht_get_type);
+ GNUNET_DHT_disconnect (dht_handle);
+ dht_handle = NULL;
+ }
if (nc != NULL)
{
GNUNET_SERVER_notification_context_destroy (nc);
&my_full_id.hashPubKey);
myid = GNUNET_PEER_intern (&my_full_id);
-// dht_handle = GNUNET_DHT_connect (c, 64); FIXME DHT
-// if (dht_handle == NULL)
-// {
-// GNUNET_break (0);
-// }
+ dht_handle = GNUNET_DHT_connect (c, 64);
+ if (dht_handle == NULL)
+ {
+ GNUNET_break (0);
+ }
next_tid = 0;
next_local_tid = GNUNET_MESH_LOCAL_TUNNEL_ID_SERV;
projects / oweals / gnunet.git / commitdiff