*/
uint32_t last_fwd_ack;
- /**
- * BCK ACK value received from the hop towards the owner of the tunnel,
- * (previous node / owner): up to what message PID can we sent back to him.
- */
+ /**
+ * BCK ACK value received from the hop towards the owner of the tunnel,
+ * (previous node / owner): up to what message PID can we sent back to him.
+ */
uint32_t bck_ack;
/**
*/
unsigned int peers_ready;
- /**
- * Number of peers that have been added to the tunnel
- */
- unsigned int peers_total;
-
/**
* Client owner of the tunnel, if any
*/
struct GNUNET_SERVER_Client *handle;
/**
- * Applications that this client has claimed to provide
+ * Applications that this client has claimed to provide: H(app) = app.
*/
struct GNUNET_CONTAINER_MultiHashMap *apps;
/**
* Hostkey generation context
*/
-static struct GNUNET_CRYPTO_RsaKeyGenerationContext *keygen;
+static struct GNUNET_CRYPTO_EccKeyGenerationContext *keygen;
/**
* DLL with all the clients, head.
/**
* Own private key.
*/
-static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
+static struct GNUNET_CRYPTO_EccPrivateKey *my_private_key;
/**
* Own public key.
*/
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key;
+static struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded my_public_key;
/**
* Tunnel ID for the next created tunnel (global tunnel number).
static MESH_TunnelNumber next_local_tid;
/**
- * All application types provided by this peer.
+ * All application types provided by this peer: H(app) = *Client.
*/
static struct GNUNET_CONTAINER_MultiHashMap *applications;
return GNUNET_YES;
}
block.type = htonl (block.type);
-
+ DEBUG_DHT ("Putting APP key: %s\n", GNUNET_h2s (key));
GNUNET_break (NULL !=
GNUNET_DHT_put (dht_handle, key,
dht_replication_level,
{
peer->ntunnels--;
peer->tunnels[i] = peer->tunnels[peer->ntunnels];
- peer->tunnels = GNUNET_realloc (peer->tunnels, peer->ntunnels);
+ peer->tunnels =
+ GNUNET_realloc (peer->tunnels,
+ peer->ntunnels * sizeof(struct MeshTunnel *));
return GNUNET_YES;
}
}
if (GNUNET_NO ==
GNUNET_CONTAINER_multihashmap_contains (t->peers, &id.hashPubKey))
{
- t->peers_total++;
GNUNET_array_append (peer->tunnels, peer->ntunnels, t);
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (t->peers, &id.hashPubKey,
* @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)
*/
static int
handle_mesh_path_create (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+ const struct GNUNET_MessageHeader *message)
{
unsigned int own_pos;
uint16_t size;
* @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)
*/
static int
handle_mesh_path_destroy (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_MESH_ManipulatePath *msg;
struct GNUNET_PeerIdentity *pi;
* @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)
*/
static int
handle_mesh_path_broken (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_MESH_PathBroken *msg;
struct MeshTunnel *t;
* @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)
*/
static int
handle_mesh_tunnel_destroy (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_MESH_TunnelDestroy *msg;
struct MeshTunnel *t;
* @param cls closure
* @param peer peer identity this notification is about
* @param message message
- * @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)
*/
static int
handle_mesh_data_unicast (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_MESH_Unicast *msg;
struct GNUNET_PeerIdentity *neighbor;
* @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)
*
*/
static int
handle_mesh_data_multicast (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_MESH_Multicast *msg;
struct MeshTunnel *t;
* @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)
*/
static int
handle_mesh_data_to_orig (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_MESH_ToOrigin *msg;
struct GNUNET_PeerIdentity id;
* @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)
*/
static int
handle_mesh_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_MESH_ACK *msg;
struct MeshTunnel *t;
* @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)
*/
static int
handle_mesh_poll (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_MESH_Poll *msg;
struct MeshTunnel *t;
* @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)
*/
static int
handle_mesh_path_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_MESH_PathACK *msg;
struct GNUNET_PeerIdentity id;
tree_set_status (t->tree, peer_info->id, MESH_PEER_READY);
send_client_peer_connected (t, peer_info->id);
}
+ if (NULL != peer_info->dhtget)
+ {
+ GNUNET_DHT_get_stop (peer_info->dhtget);
+ peer_info->dhtget = NULL;
+ }
return GNUNET_OK;
}
" not for us, retransmitting...\n");
GNUNET_PEER_resolve (tree_get_predecessor (t->tree), &id);
peer_info = peer_info_get (&msg->oid);
- if (NULL == peer_info)
- {
- /* If we know the tunnel, we should DEFINITELY know the peer */
- GNUNET_break (0);
- return GNUNET_OK;
- }
send_prebuilt_message (message, &id, t);
return GNUNET_OK;
}
* @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)
*
*/
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)
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_MESH_TunnelKeepAlive *msg;
struct MeshTunnel *t;
static int
deregister_app (void *cls, const struct GNUNET_HashCode * key, void *value)
{
- struct GNUNET_CONTAINER_MultiHashMap *h = cls;
+ struct MeshClient *c = cls;
+
GNUNET_break (GNUNET_YES ==
- GNUNET_CONTAINER_multihashmap_remove (h, key, value));
+ GNUNET_CONTAINER_multihashmap_remove (applications, key, c));
return GNUNET_OK;
}
GNUNET_PEER_resolve (path_info->peer->id, &pi);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " for %s\n", GNUNET_i2s (&pi));
- p = path_build_from_dht (get_path, get_path_length, put_path,
- put_path_length);
+ p = path_build_from_dht (get_path, get_path_length,
+ put_path, put_path_length);
path_add_to_peers (p, GNUNET_NO);
- path_destroy(p);
+ path_destroy (p);
for (i = 0; i < path_info->peer->ntunnels; i++)
{
tunnel_add_peer (path_info->peer->tunnels[i], path_info->peer);
/* deregister clients applications */
if (NULL != c->apps)
{
- GNUNET_CONTAINER_multihashmap_iterate (c->apps, &deregister_app, c->apps);
+ GNUNET_CONTAINER_multihashmap_iterate (c->apps, &deregister_app, c);
GNUNET_CONTAINER_multihashmap_destroy (c->apps);
}
if (0 == GNUNET_CONTAINER_multihashmap_size (applications) &&
{
struct GNUNET_MESH_ConnectPeerByString *msg;
struct MeshRegexSearchInfo *info;
- struct GNUNET_HashCode key;
struct MeshTunnel *t;
struct MeshClient *c;
MESH_TunnelNumber tid;
len = size - sizeof(struct GNUNET_MESH_ConnectPeerByString);
string = (const char *) &msg[1];
- /* Initialize context */
- size = GNUNET_REGEX_get_first_key (string, len, &key);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- " consumed %u bits out of %u\n", size, len);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- " looking for %s\n", GNUNET_h2s (&key));
-
info = GNUNET_malloc (sizeof (struct MeshRegexSearchInfo));
info->t = t;
info->description = GNUNET_strndup (string, len);
copy->ttl = htonl (default_ttl);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
" calling generic handler...\n");
- handle_mesh_data_unicast (NULL, &my_full_id, ©->header, NULL, 0);
+ handle_mesh_data_unicast (NULL, &my_full_id, ©->header);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "receive done OK\n");
GNUNET_SERVER_receive_done (client, GNUNET_OK);
copy->sender = my_full_id;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
" calling generic handler...\n");
- handle_mesh_data_to_orig (NULL, &my_full_id, ©->header, NULL, 0);
+ handle_mesh_data_to_orig (NULL, &my_full_id, ©->header);
}
GNUNET_SERVER_receive_done (client, GNUNET_OK);
GNUNET_assert (ntohl (copy->pid) == (t->fwd_pid + 1));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
" calling generic handler...\n");
- handle_mesh_data_multicast (client, &my_full_id, ©->header, NULL, 0);
+ handle_mesh_data_multicast (client, &my_full_id, ©->header);
}
GNUNET_SERVER_receive_done (t->owner->handle, GNUNET_OK);
*resp = *msg;
resp->npeers = 0;
ctx.msg = resp;
- ctx.lookup = GNUNET_CONTAINER_multihashmap_create (4 * t->peers_total,
- GNUNET_YES);
+ ctx.lookup = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES);
ctx.c = c;
/* Collect and send information */
*
* @param cls closure
* @param peer peer identity this notification is about
- * @param atsi performance data for the connection
- * @param atsi_count number of records in 'atsi'
*/
static void
-core_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_ATS_Information *atsi,
- unsigned int atsi_count)
+core_connect (void *cls, const struct GNUNET_PeerIdentity *peer)
{
struct MeshPeerInfo *peer_info;
struct MeshPeerPath *path;
}
if (NULL != keygen)
{
- GNUNET_CRYPTO_rsa_key_create_stop (keygen);
+ GNUNET_CRYPTO_ecc_key_create_stop (keygen);
keygen = NULL;
}
GNUNET_CONTAINER_multihashmap_iterate (tunnels, &shutdown_tunnel, NULL);
/**
- * Callback for hostkey read/generation
+ * Callback for hostkey read/generation.
*
* @param cls Closure (Configuration handle).
- * @param pk the private key
- * @param emsg error message
+ * @param pk The ECC private key.
+ * @param emsg Error message, if any.
*/
static void
key_generation_cb (void *cls,
- struct GNUNET_CRYPTO_RsaPrivateKey *pk,
+ struct GNUNET_CRYPTO_EccPrivateKey *pk,
const char *emsg)
{
const struct GNUNET_CONFIGURATION_Handle *c = cls;
keygen = NULL;
if (NULL == pk)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Mesh service could not access hostkey: %s. Exiting.\n"),
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ _("Could not access hostkey: %s. Exiting.\n"),
emsg);
GNUNET_SCHEDULER_shutdown ();
return;
}
my_private_key = pk;
- GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
+ GNUNET_CRYPTO_ecc_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);
"Mesh for peer [%s] starting\n",
GNUNET_i2s(&my_full_id));
-// transport_handle = GNUNET_TRANSPORT_connect(c,
-// &my_full_id,
-// NULL,
-// NULL,
-// NULL,
-// NULL);
-
core_handle = GNUNET_CORE_connect (c, /* Main configuration */
NULL, /* Closure passed to MESH functions */
&core_init, /* Call core_init once connected */
server_handle = server;
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (c, "GNUNETD", "HOSTKEY",
+ GNUNET_CONFIGURATION_get_value_filename (c, "PEER", "PRIVATE_KEY",
&keyfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
("%s service is lacking key configuration settings (%s). Exiting.\n"),
- "mesh", "hostkey");
+ "mesh", "peer/privatekey");
GNUNET_SCHEDULER_shutdown ();
return;
}
/* Scheduled the task to clean up when shutdown is called */
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
- keygen = GNUNET_CRYPTO_rsa_key_create_start (keyfile,
+ keygen = GNUNET_CRYPTO_ecc_key_create_start (keyfile,
&key_generation_cb,
(void *) c);
GNUNET_free (keyfile);