X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fmesh%2Fgnunet-service-mesh.c;h=f0a42f118f32942b94172e7eb783c8c1f999ed99;hb=60b22d16687c7cf4e9af0641448e1c182ad262e2;hp=c45bc86984d0a495b6d0c4a073229e0506c0503e;hpb=90913a15275c8659008909068512b015e08c0bd8;p=oweals%2Fgnunet.git diff --git a/src/mesh/gnunet-service-mesh.c b/src/mesh/gnunet-service-mesh.c index c45bc8698..f0a42f118 100644 --- a/src/mesh/gnunet-service-mesh.c +++ b/src/mesh/gnunet-service-mesh.c @@ -523,6 +523,11 @@ struct MeshTunnel * Total messages pending for this tunnels, payload or not. */ unsigned int pending_messages; + + /** + * If the tunnel is empty, destoy it. + */ + GNUNET_SCHEDULER_TaskIdentifier delayed_destroy; }; @@ -743,6 +748,11 @@ struct MeshClient */ GNUNET_SCHEDULER_TaskIdentifier regex_announce_task; + /** + * Tmp store for partially retrieved regex. + */ + char *partial_regex; + }; @@ -923,6 +933,11 @@ static unsigned long long max_tunnels; */ static unsigned long long max_msgs_queue; +/** + * How many peers do we want to remember? + */ +static unsigned long long max_peers; + /*************************** Static global variables **************************/ @@ -2258,6 +2273,9 @@ send_client_peer_connected (const struct MeshTunnel *t, const GNUNET_PEER_Id id) { struct GNUNET_MESH_PeerControl pc; + if (NULL == t->owner || GNUNET_YES == t->destroy) + return; + pc.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_ADD); pc.header.size = htons (sizeof (struct GNUNET_MESH_PeerControl)); pc.tunnel_id = htonl (t->local_tid); @@ -2327,6 +2345,23 @@ send_client_tunnel_disconnect (struct MeshTunnel *t, struct MeshClient *c) } +/** + * Iterator over all the peers to remove the oldest not-used entry. + * + * @param cls Closure (unsued). + * @param key ID of the peer. + * @param value Peer_Info of the peer. + * + * FIXME implement + */ +static int +peer_info_timeout (void *cls, + const struct GNUNET_HashCode *key, + void *value) +{ + return GNUNET_YES; +} + /** * Retrieve the MeshPeerInfo stucture associated with the peer, create one * and insert it in the appropiate structures if the peer is not known yet. @@ -2345,10 +2380,17 @@ peer_info_get (const struct GNUNET_PeerIdentity *peer) { peer_info = (struct MeshPeerInfo *) GNUNET_malloc (sizeof (struct MeshPeerInfo)); + if (GNUNET_CONTAINER_multihashmap_size (peers) > max_peers) + { + GNUNET_CONTAINER_multihashmap_iterate (peers, + &peer_info_timeout, + NULL); + } GNUNET_CONTAINER_multihashmap_put (peers, &peer->hashPubKey, peer_info, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST); peer_info->id = GNUNET_PEER_intern (peer); } + peer_info->last_contact = GNUNET_TIME_absolute_get(); return peer_info; } @@ -4336,17 +4378,30 @@ tunnel_unlock_bck_queue (struct MeshTunnel *t) * valid. * * @param t The tunnel whose peers to notify. + * @param send_back Do we need to notify our parent node? */ static void -tunnel_send_destroy (struct MeshTunnel *t) +tunnel_send_destroy (struct MeshTunnel *t, int send_back) { struct GNUNET_MESH_TunnelDestroy msg; + struct GNUNET_PeerIdentity id; + GNUNET_PEER_Id parent; + + if (tree_count_children(t->tree) > 0) + { + msg.header.size = htons (sizeof (msg)); + msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY); + GNUNET_PEER_resolve (t->id.oid, &msg.oid); + msg.tid = htonl (t->id.tid); + tunnel_send_multicast (t, &msg.header); + } + parent = tree_get_predecessor(t->tree); + if (GNUNET_NO == send_back || 0 == parent) + return; msg.header.size = htons (sizeof (msg)); msg.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY); - GNUNET_PEER_resolve (t->id.oid, &msg.oid); - msg.tid = htonl (t->id.tid); - tunnel_send_multicast (t, &msg.header); + send_prebuilt_message(&msg.header, &id, t); } @@ -4459,17 +4514,9 @@ tunnel_destroy (struct MeshTunnel *t) } } - if (t->nclients > 0) - { - if (GNUNET_YES != - GNUNET_CONTAINER_multihashmap_remove (incoming_tunnels, &hash, t)) - { - GNUNET_break (0); - r = GNUNET_SYSERR; - } - GNUNET_free (t->clients); - GNUNET_free (t->clients_fc); - } + (void) GNUNET_CONTAINER_multihashmap_remove (incoming_tunnels, &hash, t); + GNUNET_free_non_null (t->clients); + GNUNET_free_non_null (t->clients_fc); if (NULL != t->peers) { @@ -4502,6 +4549,78 @@ tunnel_destroy (struct MeshTunnel *t) return r; } +#define TUNNEL_DESTROY_EMPTY_TIME GNUNET_TIME_UNIT_MILLISECONDS + +/** + * Tunnel is empty: destroy it. + * + * @param cls Closure (Tunnel). + * @param tc TaskContext. + */ +static void +tunnel_destroy_empty_delayed (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct MeshTunnel *t = cls; + + t->delayed_destroy = GNUNET_SCHEDULER_NO_TASK; + if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) + return; + + if (0 != t->nclients || + 0 != tree_count_children (t->tree)) + return; + + #if MESH_DEBUG + { + struct GNUNET_PeerIdentity id; + + GNUNET_PEER_resolve (t->id.oid, &id); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "executing destruction of empty tunnel %s [%X]\n", + GNUNET_i2s (&id), t->id.tid); + } + #endif + + tunnel_destroy (t); +} + + +/** + * Schedule tunnel destruction if is empty and no new traffic comes in a time. + * + * @param t Tunnel to destroy if empty. + */ +static void +tunnel_destroy_empty (struct MeshTunnel *t) +{ + if (GNUNET_SCHEDULER_NO_TASK != t->delayed_destroy || + 0 != t->nclients || + 0 != tree_count_children (t->tree)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%u %u %u\n", + t->delayed_destroy, t->nclients, tree_count_children(t->tree)); + return; + } + + #if MESH_DEBUG + { + struct GNUNET_PeerIdentity id; + + GNUNET_PEER_resolve (t->id.oid, &id); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "scheduling destruction of empty tunnel %s [%X]\n", + GNUNET_i2s (&id), t->id.tid); + } + #endif + + t->delayed_destroy = + GNUNET_SCHEDULER_add_delayed (TUNNEL_DESTROY_EMPTY_TIME, + &tunnel_destroy_empty_delayed, + t); +} + /** * Create a new tunnel @@ -4610,21 +4729,23 @@ tunnel_delete_peer (struct MeshTunnel *t, GNUNET_PEER_Id peer) * @return GNUNET_OK, keep iterating. */ static int -tunnel_destroy_iterator (void *cls, const struct GNUNET_HashCode * key, void *value) +tunnel_destroy_iterator (void *cls, + const struct GNUNET_HashCode * key, + void *value) { struct MeshTunnel *t = value; struct MeshClient *c = cls; - send_client_tunnel_disconnect(t, c); + send_client_tunnel_disconnect (t, c); if (c != t->owner) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Client %u is destination, keeping the tunnel alive.\n", c->id); - tunnel_delete_client(t, c); - client_delete_tunnel(c, t); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %u is destination.\n", c->id); + tunnel_delete_client (t, c); + client_delete_tunnel (c, t); + tunnel_destroy_empty (t); return GNUNET_OK; } - tunnel_send_destroy(t); + tunnel_send_destroy (t, GNUNET_YES); t->owner = NULL; t->destroy = GNUNET_YES; @@ -5666,10 +5787,12 @@ handle_mesh_tunnel_destroy (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MESH_TunnelDestroy *msg; struct MeshTunnel *t; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Got a TUNNEL DESTROY packet from %s\n", GNUNET_i2s (peer)); msg = (struct GNUNET_MESH_TunnelDestroy *) message; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " for tunnel %s [%u]\n", + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Got a TUNNEL DESTROY packet from %s\n", + GNUNET_i2s (peer)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + " for tunnel %s [%u]\n", GNUNET_i2s (&msg->oid), ntohl (msg->tid)); t = tunnel_get (&msg->oid, ntohl (msg->tid)); if (NULL == t) @@ -5678,7 +5801,8 @@ handle_mesh_tunnel_destroy (void *cls, const struct GNUNET_PeerIdentity *peer, * destroyed the tunnel and retransmitted to children. * Safe to ignore. */ - GNUNET_STATISTICS_update (stats, "# control on unknown tunnel", 1, GNUNET_NO); + GNUNET_STATISTICS_update (stats, "# control on unknown tunnel", + 1, GNUNET_NO); return GNUNET_OK; } if (t->id.oid == myid) @@ -5693,7 +5817,7 @@ handle_mesh_tunnel_destroy (void *cls, const struct GNUNET_PeerIdentity *peer, t->local_tid, t->local_tid_dest); send_clients_tunnel_destroy (t); } - tunnel_send_destroy (t); + tunnel_send_destroy (t, GNUNET_YES); t->destroy = GNUNET_YES; // TODO: add timeout to destroy the tunnel anyway return GNUNET_OK; @@ -5926,6 +6050,7 @@ handle_mesh_data_to_orig (void *cls, const struct GNUNET_PeerIdentity *peer, struct MeshPeerInfo *peer_info; struct MeshTunnel *t; struct MeshTunnelChildInfo *cinfo; + GNUNET_PEER_Id predecessor; size_t size; uint32_t pid; @@ -5948,8 +6073,7 @@ handle_mesh_data_to_orig (void *cls, const struct GNUNET_PeerIdentity *peer, { /* TODO notify that we dont know this tunnel (whom)? */ GNUNET_STATISTICS_update (stats, "# data on unknown tunnel", 1, GNUNET_NO); - GNUNET_break_op (0); - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received to_origin with PID %u on unknown tunnel %s [%u]\n", pid, GNUNET_i2s (&msg->oid), ntohl (msg->tid)); return GNUNET_OK; @@ -6005,7 +6129,31 @@ handle_mesh_data_to_orig (void *cls, const struct GNUNET_PeerIdentity *peer, GNUNET_break (0); return GNUNET_OK; } - GNUNET_PEER_resolve (tree_get_predecessor (t->tree), &id); + predecessor = tree_get_predecessor (t->tree); + if (0 == predecessor) + { + if (GNUNET_YES == t->destroy) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "to orig received on a dying tunnel %s [%X]\n", + GNUNET_i2s (&msg->oid), ntohl(msg->tid)); + return GNUNET_OK; + } + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "unknown to origin at %s\n", + GNUNET_i2s (&my_full_id)); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "from peer %s\n", + GNUNET_i2s (peer)); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "for tunnel %s [%X]\n", + GNUNET_i2s (&msg->oid), ntohl(msg->tid)); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "current tree:\n"); + tree_debug (t->tree); + return GNUNET_OK; + } + GNUNET_PEER_resolve (predecessor, &id); send_prebuilt_message (message, &id, t); GNUNET_STATISTICS_update (stats, "# to origin forwarded", 1, GNUNET_NO); @@ -6682,7 +6830,6 @@ handle_local_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client) return; } -// return; uncomment for regex_profiler c = clients; while (NULL != c) { @@ -6859,6 +7006,7 @@ handle_local_announce_regex (void *cls, struct GNUNET_SERVER_Client *client, struct MeshClient *c; char *regex; size_t len; + size_t offset; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "announce regex started\n"); @@ -6872,10 +7020,34 @@ handle_local_announce_regex (void *cls, struct GNUNET_SERVER_Client *client, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " by client %u\n", c->id); msg = (const struct GNUNET_MESH_RegexAnnounce *) message; + len = ntohs (message->size) - sizeof(struct GNUNET_MESH_RegexAnnounce); - regex = GNUNET_malloc (len + 1); - memcpy (regex, &msg[1], len); - regex[len] = '\0'; + if (NULL != c->partial_regex) + { + regex = c->partial_regex; + offset = strlen (c->partial_regex); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + " continuation, already have %u bytes\n", + offset); + } + else + { + regex = NULL; + offset = 0; + } + + regex = GNUNET_realloc (regex, offset + len + 1); + memcpy (®ex[offset], &msg[1], len); + regex[offset + len] = '\0'; + if (0 == ntohs (msg->last)) + { + c->partial_regex = regex; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + " not ended, stored %u bytes for later\n", + len); + GNUNET_SERVER_receive_done (client, GNUNET_OK); + return; + } rd.regex = regex; rd.compression = ntohs (msg->compression_characters); rd.dfa = NULL; @@ -6883,6 +7055,7 @@ handle_local_announce_regex (void *cls, struct GNUNET_SERVER_Client *client, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " regex %s\n", regex); GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " cm %u\n", ntohs(rd.compression)); GNUNET_array_append (c->regexes, c->n_regex, rd); + c->partial_regex = NULL; if (GNUNET_SCHEDULER_NO_TASK == c->regex_announce_task) { c->regex_announce_task = GNUNET_SCHEDULER_add_now(&announce_regex, c); @@ -7020,19 +7193,7 @@ handle_local_tunnel_destroy (void *cls, struct GNUNET_SERVER_Client *client, if (c != t->owner || tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_SERV) { client_ignore_tunnel (c, t); -#if 0 - // TODO: when to destroy incoming tunnel? - if (t->nclients == 0) - { - GNUNET_assert (GNUNET_YES == - GNUNET_CONTAINER_multihashmap_remove (incoming_tunnels, - &hash, t)); - GNUNET_assert (GNUNET_YES == - GNUNET_CONTAINER_multihashmap_remove (t->peers, - &my_full_id.hashPubKey, - t)); - } -#endif + tunnel_destroy_empty (t); GNUNET_SERVER_receive_done (client, GNUNET_OK); return; } @@ -7041,7 +7202,7 @@ handle_local_tunnel_destroy (void *cls, struct GNUNET_SERVER_Client *client, /* Don't try to ACK the client about the tunnel_destroy multicast packet */ t->owner = NULL; - tunnel_send_destroy (t); + tunnel_send_destroy (t, GNUNET_YES); t->destroy = GNUNET_YES; // The tunnel will be destroyed when the last message is transmitted. GNUNET_SERVER_receive_done (client, GNUNET_OK); @@ -8799,6 +8960,16 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, default_ttl = 64; } + if (GNUNET_OK != + GNUNET_CONFIGURATION_get_value_number (c, "MESH", "MAX_PEERS", + &max_peers)) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _("%s service is lacking key configuration settings (%s). Using default (%u).\n"), + "mesh", "max peers", 1000); + max_peers = 1000; + } + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (c, "MESH", "DHT_REPLICATION_LEVEL", &dht_replication_level))