X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fdv%2Fgnunet-service-dv.c;h=84bdc11c23020c69c34710f043ee0140921206ff;hb=37defe2dbd9ea4e5a37710404e8046acbdf4a18e;hp=19303ed83708c00627e4adc6a3b4fba6ccfec9f0;hpb=42cbac4233ac4f4b704649d069fe96d758610b28;p=oweals%2Fgnunet.git diff --git a/src/dv/gnunet-service-dv.c b/src/dv/gnunet-service-dv.c index 19303ed83..84bdc11c2 100644 --- a/src/dv/gnunet-service-dv.c +++ b/src/dv/gnunet-service-dv.c @@ -92,7 +92,7 @@ struct Target /** * Message exchanged between DV services (via core), requesting a - * message to be routed. + * message to be routed. */ struct RouteMessage { @@ -176,7 +176,7 @@ struct DirectNeighbor * with other applications. */ struct GNUNET_HashCode real_session_id; - + /** * Head of linked list of messages to send to this peer. */ @@ -197,7 +197,7 @@ struct DirectNeighbor * Keys are peer identities, values are 'struct Target' entries. * Note that the distances in the targets are from the point-of-view * of the peer, not from us! - */ + */ struct GNUNET_CONTAINER_MultiPeerMap *neighbor_table; /** @@ -206,7 +206,7 @@ struct DirectNeighbor * Keys are peer identities, values are 'struct Target' entries. * Note that the distances in the targets are from the point-of-view * of the peer, not from us! - */ + */ struct GNUNET_CONTAINER_MultiPeerMap *neighbor_table_consensus; /** @@ -249,6 +249,16 @@ struct DirectNeighbor */ unsigned int pm_queue_size; + /** + * Elements in consensus + */ + unsigned int consensus_elements; + + /** + * Direct one hop route + */ + struct Route *direct_route; + /** * Flag set within 'check_target_removed' to trigger full global route refresh. */ @@ -318,13 +328,13 @@ struct ConsensusSet /** * Peermap of all of our neighbors; processing these usually requires - * first checking to see if the peer is core-connected and if the + * first checking to see if the peer is core-connected and if the * distance is 1, in which case they are direct neighbors. */ static struct GNUNET_CONTAINER_MultiPeerMap *direct_neighbors; /** - * Hashmap with all routes that we currently support; contains + * Hashmap with all routes that we currently support; contains * routing information for all peers from distance 2 * up to distance DEFAULT_FISHEYE_DEPTH. */ @@ -367,7 +377,7 @@ static struct GNUNET_STATISTICS_Handle *stats; * Handle to ATS service. */ static struct GNUNET_ATS_PerformanceHandle *ats; - + /** * Start creating a new DV set union by initiating the connection. @@ -375,7 +385,7 @@ static struct GNUNET_ATS_PerformanceHandle *ats; * @param cls the 'struct DirectNeighbor' of the peer we're building * a routing consensus with * @param tc scheduler context - */ + */ static void initiate_set_union (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); @@ -396,7 +406,7 @@ initiate_set_union (void *cls, * necessary to specify the set we want to do the operation with, * whith sometimes can be derived from the context message. * Also necessary to specify the timeout. - */ + */ static void listen_set_union (void *cls, const struct GNUNET_PeerIdentity *other_peer, @@ -412,7 +422,7 @@ listen_set_union (void *cls, * @param distance distance to the original sender of the message */ static void -send_data_to_plugin (const struct GNUNET_MessageHeader *message, +send_data_to_plugin (const struct GNUNET_MessageHeader *message, const struct GNUNET_PeerIdentity *origin, uint32_t distance) { @@ -422,10 +432,10 @@ send_data_to_plugin (const struct GNUNET_MessageHeader *message, GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Delivering message from peer `%s'\n", GNUNET_i2s (origin)); - size = sizeof (struct GNUNET_DV_ReceivedMessage) + + size = sizeof (struct GNUNET_DV_ReceivedMessage) + ntohs (message->size); if (size >= GNUNET_SERVER_MAX_MESSAGE_SIZE) - { + { GNUNET_break (0); /* too big */ return; } @@ -435,7 +445,7 @@ send_data_to_plugin (const struct GNUNET_MessageHeader *message, received_msg->distance = htonl (distance); received_msg->sender = *origin; memcpy (&received_msg[1], message, ntohs (message->size)); - GNUNET_SERVER_notification_context_broadcast (nc, + GNUNET_SERVER_notification_context_broadcast (nc, &received_msg->header, GNUNET_YES); GNUNET_free (received_msg); @@ -450,7 +460,7 @@ send_data_to_plugin (const struct GNUNET_MessageHeader *message, static void send_control_to_plugin (const struct GNUNET_MessageHeader *message) { - GNUNET_SERVER_notification_context_broadcast (nc, + GNUNET_SERVER_notification_context_broadcast (nc, message, GNUNET_NO); } @@ -464,7 +474,7 @@ send_control_to_plugin (const struct GNUNET_MessageHeader *message) * @param nack GNUNET_NO to send ACK, GNUNET_YES to send NACK */ static void -send_ack_to_plugin (const struct GNUNET_PeerIdentity *target, +send_ack_to_plugin (const struct GNUNET_PeerIdentity *target, uint32_t uid, int nack) { @@ -474,7 +484,7 @@ send_ack_to_plugin (const struct GNUNET_PeerIdentity *target, "Delivering ACK for message to peer `%s'\n", GNUNET_i2s (target)); ack_msg.header.size = htons (sizeof (ack_msg)); - ack_msg.header.type = htons ((GNUNET_YES == nack) + ack_msg.header.type = htons ((GNUNET_YES == nack) ? GNUNET_MESSAGE_TYPE_DV_SEND_NACK : GNUNET_MESSAGE_TYPE_DV_SEND_ACK); ack_msg.uid = htonl (uid); @@ -490,7 +500,7 @@ send_ack_to_plugin (const struct GNUNET_PeerIdentity *target, * @param distance new distance to the peer */ static void -send_distance_change_to_plugin (const struct GNUNET_PeerIdentity *peer, +send_distance_change_to_plugin (const struct GNUNET_PeerIdentity *peer, uint32_t distance) { struct GNUNET_DV_DistanceUpdateMessage du_msg; @@ -513,7 +523,7 @@ send_distance_change_to_plugin (const struct GNUNET_PeerIdentity *peer, * @param distance distance to the target */ static void -send_connect_to_plugin (const struct GNUNET_PeerIdentity *target, +send_connect_to_plugin (const struct GNUNET_PeerIdentity *target, uint32_t distance) { struct GNUNET_DV_ConnectMessage cm; @@ -585,7 +595,7 @@ core_transmit_notify (void *cls, size_t size, void *buf) dn->pm_tail, pending); memcpy (&cbuf[off], pending->msg, msize); - if (0 != pending->uid) + if (0 != pending->uid) send_ack_to_plugin (&pending->ultimate_target, pending->uid, GNUNET_NO); @@ -599,7 +609,7 @@ core_transmit_notify (void *cls, size_t size, void *buf) 0 /* priority */, GNUNET_TIME_UNIT_FOREVER_REL, &dn->peer, - msize, + msize, &core_transmit_notify, dn); return off; } @@ -662,7 +672,7 @@ forward_payload (struct DirectNeighbor *target, 0 /* priority */, GNUNET_TIME_UNIT_FOREVER_REL, &target->peer, - msize, + msize, &core_transmit_notify, target); } @@ -684,9 +694,11 @@ get_consensus_slot (uint32_t distance) while ( (i < cs->array_length) && (NULL != cs->targets[i]) ) i++; if (i == cs->array_length) + { GNUNET_array_grow (cs->targets, cs->array_length, cs->array_length * 2 + 2); + } return i; } @@ -738,7 +750,7 @@ move_route (struct Route *route, release_route (route); i = get_consensus_slot (new_distance); route->set_offset = i; - consensi[new_distance].targets[i] = route; + consensi[new_distance].targets[i] = route; route->target.distance = htonl (new_distance); } @@ -747,6 +759,11 @@ move_route (struct Route *route, * Initialize this neighbors 'my_set' and when done give * it to the pending set operation for execution. * + * Add a single element to the set per call: + * + * If we reached the last element of a consensus element: increase distance + * + * * @param cls the neighbor for which we are building the set */ static void @@ -754,15 +771,17 @@ build_set (void *cls) { struct DirectNeighbor *neighbor = cls; struct GNUNET_SET_Element element; - + struct Target *target; + target = NULL; while ( (DEFAULT_FISHEYE_DEPTH - 1 > neighbor->consensus_insertion_distance) && (consensi[neighbor->consensus_insertion_distance].array_length == neighbor->consensus_insertion_offset) ) { + /* If we reached the last element of a consensus array element: increase distance and start with next array */ neighbor->consensus_insertion_offset = 0; neighbor->consensus_insertion_distance++; /* skip over NULL entries */ while ( (DEFAULT_FISHEYE_DEPTH - 1 > neighbor->consensus_insertion_distance) && - (consensi[neighbor->consensus_insertion_distance].array_length < neighbor->consensus_insertion_offset) && + (consensi[neighbor->consensus_insertion_distance].array_length > neighbor->consensus_insertion_offset) && (NULL == consensi[neighbor->consensus_insertion_distance].targets[neighbor->consensus_insertion_offset]) ) neighbor->consensus_insertion_offset++; } @@ -770,28 +789,46 @@ build_set (void *cls) { /* we have added all elements to the set, run the operation */ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Finished building my SET, committing\n"); + "Finished building my SET for peer `%s' with %u elements, committing\n", + GNUNET_i2s(&neighbor->peer), + neighbor->consensus_elements); GNUNET_SET_commit (neighbor->set_op, neighbor->my_set); GNUNET_SET_destroy (neighbor->my_set); neighbor->my_set = NULL; return; } + + target = &consensi[neighbor->consensus_insertion_distance].targets[neighbor->consensus_insertion_offset]->target; element.size = sizeof (struct Target); element.type = htons (0); /* do we need this? */ - element.data = &consensi[neighbor->consensus_insertion_distance].targets[neighbor->consensus_insertion_offset++]->target; + element.data = target; + /* Find next non-NULL entry */ + neighbor->consensus_insertion_offset++; /* skip over NULL entries */ while ( (DEFAULT_FISHEYE_DEPTH - 1 > neighbor->consensus_insertion_distance) && - (consensi[neighbor->consensus_insertion_distance].array_length < neighbor->consensus_insertion_offset) && + (consensi[neighbor->consensus_insertion_distance].array_length > neighbor->consensus_insertion_offset) && (NULL == consensi[neighbor->consensus_insertion_distance].targets[neighbor->consensus_insertion_offset]) ) - neighbor->consensus_insertion_offset++; - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Adding element to SET\n"); - GNUNET_SET_add_element (neighbor->my_set, - &element, - &build_set, neighbor); - + { + neighbor->consensus_insertion_offset++; + } + + if ( (0 != memcmp(&target->peer, &my_identity, sizeof (my_identity))) && + (0 != memcmp(&target->peer, &neighbor->peer, sizeof (neighbor->peer))) ) + { + /* Add target if it is not the neighbor or this peer */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Adding peer `%s' with distance %u to SET\n", + GNUNET_i2s (&target->peer), + ntohl (target->distance)); + GNUNET_SET_add_element (neighbor->my_set, + &element, + &build_set, neighbor); + neighbor->consensus_elements++; + } + else + build_set(neighbor); } @@ -814,14 +851,26 @@ handle_direct_connect (struct DirectNeighbor *neighbor) GNUNET_STATISTICS_update (stats, "# peers connected (1-hop)", 1, GNUNET_NO); - route = GNUNET_CONTAINER_multipeermap_get (all_routes, + route = GNUNET_CONTAINER_multipeermap_get (all_routes, &neighbor->peer); - if (NULL != route) + if (NULL != route) { send_disconnect_to_plugin (&neighbor->peer); release_route (route); GNUNET_free (route); } + + neighbor->direct_route = GNUNET_new (struct Route); + neighbor->direct_route->next_hop = neighbor; + neighbor->direct_route->target.peer= neighbor->peer; + neighbor->direct_route->target.distance = DIRECT_NEIGHBOR_COST; + allocate_route (neighbor->direct_route, DIRECT_NEIGHBOR_COST); + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Adding direct route to %s\n", + GNUNET_i2s (&neighbor->direct_route->target.peer)); + + /* construct session ID seed as XOR of both peer's identities */ GNUNET_CRYPTO_hash (&my_identity, sizeof (my_identity), &h1); GNUNET_CRYPTO_hash (&neighbor->peer, sizeof (struct GNUNET_PeerIdentity), &h2); @@ -838,18 +887,31 @@ handle_direct_connect (struct DirectNeighbor *neighbor) &my_identity, sizeof (struct GNUNET_PeerIdentity))) { - neighbor->initiate_task = GNUNET_SCHEDULER_add_now (&initiate_set_union, - neighbor); + if (NULL != neighbor->listen_handle) + { + GNUNET_break (0); + } + else + neighbor->initiate_task = GNUNET_SCHEDULER_add_now (&initiate_set_union, + neighbor); } else { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Starting SET listen operation\n"); - neighbor->listen_handle = GNUNET_SET_listen (cfg, - GNUNET_SET_OPERATION_UNION, - &neighbor->real_session_id, - &listen_set_union, - neighbor); + if (NULL != neighbor->listen_handle) + { + GNUNET_break (0); + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Starting SET listen operation with peer `%s'\n", + GNUNET_i2s(&neighbor->peer)); + neighbor->listen_handle = GNUNET_SET_listen (cfg, + GNUNET_SET_OPERATION_UNION, + &neighbor->real_session_id, + &listen_set_union, + neighbor); + } } } @@ -861,16 +923,16 @@ handle_direct_connect (struct DirectNeighbor *neighbor) * @param peer peer identity this notification is about */ static void -handle_core_connect (void *cls, +handle_core_connect (void *cls, const struct GNUNET_PeerIdentity *peer) { struct DirectNeighbor *neighbor; - + /* Check for connect to self message */ if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity))) return; /* check if entry exists */ - neighbor = GNUNET_CONTAINER_multipeermap_get (direct_neighbors, + neighbor = GNUNET_CONTAINER_multipeermap_get (direct_neighbors, peer); if (NULL != neighbor) { @@ -929,14 +991,14 @@ free_targets (void *cls, * @return GNUNET_YES to continue iteration, GNUNET_NO to stop */ static int -check_possible_route (void *cls, - const struct GNUNET_PeerIdentity *key, +check_possible_route (void *cls, + const struct GNUNET_PeerIdentity *key, void *value) { struct DirectNeighbor *neighbor = cls; struct Target *target = value; struct Route *route; - + route = GNUNET_CONTAINER_multipeermap_get (all_routes, key); if (NULL != route) @@ -975,15 +1037,15 @@ check_possible_route (void *cls, * @return GNUNET_YES to continue iteration */ static int -refresh_routes (void *cls, - const struct GNUNET_PeerIdentity *key, +refresh_routes (void *cls, + const struct GNUNET_PeerIdentity *key, void *value) { struct DirectNeighbor *neighbor = value; if ( (GNUNET_YES != neighbor->connected) || (DIRECT_NEIGHBOR_COST != neighbor->distance) ) - return GNUNET_YES; + return GNUNET_YES; if (NULL != neighbor->neighbor_table) GNUNET_CONTAINER_multipeermap_iterate (neighbor->neighbor_table, &check_possible_route, @@ -1024,8 +1086,8 @@ get_atsi_distance (const struct GNUNET_ATS_Information *atsi, * @return GNUNET_YES to continue iteration, GNUNET_NO to stop */ static int -cull_routes (void *cls, - const struct GNUNET_PeerIdentity *key, +cull_routes (void *cls, + const struct GNUNET_PeerIdentity *key, void *value) { struct DirectNeighbor *neighbor = cls; @@ -1047,7 +1109,7 @@ cull_routes (void *cls, * disrupted. Remove all routes via that peer and * stop the consensus with it. * - * @param neighbor peer that was disconnected (or at least is no + * @param neighbor peer that was disconnected (or at least is no * longer at distance 1) */ static void @@ -1061,6 +1123,14 @@ handle_direct_disconnect (struct DirectNeighbor *neighbor) GNUNET_CORE_notify_transmit_ready_cancel (neighbor->cth); neighbor->cth = NULL; } + + if (NULL != neighbor->direct_route) + { + release_route (neighbor->direct_route); + GNUNET_free (neighbor->direct_route); + neighbor->direct_route = NULL; + } + if (NULL != neighbor->neighbor_table_consensus) { GNUNET_CONTAINER_multipeermap_iterate (neighbor->neighbor_table_consensus, @@ -1118,7 +1188,7 @@ handle_ats_update (void *cls, int active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, - const struct GNUNET_ATS_Information *ats, + const struct GNUNET_ATS_Information *ats, uint32_t ats_count) { struct DirectNeighbor *neighbor; @@ -1126,25 +1196,26 @@ handle_ats_update (void *cls, if (GNUNET_NO == active) return; - distance = get_atsi_distance (ats, ats_count); + distance = get_atsi_distance (ats, ats_count); + /* GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ATS says distance to %s is %u\n", GNUNET_i2s (&address->peer), - (unsigned int) distance); + (unsigned int) distance);*/ /* check if entry exists */ - neighbor = GNUNET_CONTAINER_multipeermap_get (direct_neighbors, + neighbor = GNUNET_CONTAINER_multipeermap_get (direct_neighbors, &address->peer); if (NULL != neighbor) - { + { if ( (DIRECT_NEIGHBOR_COST == neighbor->distance) && (DIRECT_NEIGHBOR_COST == distance) ) return; /* no change */ - if (DIRECT_NEIGHBOR_COST == neighbor->distance) + if (DIRECT_NEIGHBOR_COST == neighbor->distance) { neighbor->distance = distance; GNUNET_STATISTICS_update (stats, "# peers connected (1-hop)", - -1, GNUNET_NO); + -1, GNUNET_NO); handle_direct_disconnect (neighbor); GNUNET_CONTAINER_multipeermap_iterate (direct_neighbors, &refresh_routes, @@ -1153,7 +1224,7 @@ handle_ats_update (void *cls, } neighbor->distance = distance; if (DIRECT_NEIGHBOR_COST != neighbor->distance) - return; + return; if (GNUNET_YES != neighbor->connected) return; handle_direct_connect (neighbor); @@ -1167,7 +1238,7 @@ handle_ats_update (void *cls, neighbor, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); neighbor->connected = GNUNET_NO; /* not yet */ - neighbor->distance = distance; + neighbor->distance = distance; } @@ -1302,10 +1373,32 @@ handle_set_union_result (void *cls, { struct DirectNeighbor *neighbor = cls; struct Target *target; + char *status_str; + + switch (status) { + case GNUNET_SET_STATUS_OK: + status_str = "GNUNET_SET_STATUS_OK"; + break; + case GNUNET_SET_STATUS_TIMEOUT: + status_str = "GNUNET_SET_STATUS_TIMEOUT"; + break; + case GNUNET_SET_STATUS_FAILURE: + status_str = "GNUNET_SET_STATUS_FAILURE"; + break; + case GNUNET_SET_STATUS_HALF_DONE: + status_str = "GNUNET_SET_STATUS_HALF_DONE"; + break; + case GNUNET_SET_STATUS_DONE: + status_str = "GNUNET_SET_STATUS_DONE"; + break; + default: + status_str = "UNDEFINED"; + break; + } GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Got SET union result: %d\n", - status); + "Got SET union result: %s\n", + status_str); switch (status) { case GNUNET_SET_STATUS_OK: @@ -1316,6 +1409,11 @@ handle_set_union_result (void *cls, } target = GNUNET_new (struct Target); memcpy (target, element->data, sizeof (struct Target)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Received information about peer `%s' with distance %u\n", + GNUNET_i2s (&target->peer), ntohl(target->distance)); + if (NULL == neighbor->neighbor_table_consensus) + neighbor->neighbor_table_consensus = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO); if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_put (neighbor->neighbor_table_consensus, &target->peer, @@ -1347,34 +1445,38 @@ handle_set_union_result (void *cls, neighbor); break; case GNUNET_SET_STATUS_HALF_DONE: + break; + case GNUNET_SET_STATUS_DONE: /* we got all of our updates; integrate routing table! */ neighbor->target_removed = GNUNET_NO; - GNUNET_CONTAINER_multipeermap_iterate (neighbor->neighbor_table, - &check_target_removed, - neighbor); + if (NULL == neighbor->neighbor_table_consensus) + neighbor->neighbor_table_consensus = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO); + if (NULL != neighbor->neighbor_table) + GNUNET_CONTAINER_multipeermap_iterate (neighbor->neighbor_table, + &check_target_removed, + neighbor); if (GNUNET_YES == neighbor->target_removed) { /* check if we got an alternative for the removed routes */ GNUNET_CONTAINER_multipeermap_iterate (direct_neighbors, - &refresh_routes, - NULL); + &refresh_routes, + NULL); } /* add targets that appeared (and check for improved routes) */ GNUNET_CONTAINER_multipeermap_iterate (neighbor->neighbor_table_consensus, - &check_target_added, - neighbor); + &check_target_added, + neighbor); if (NULL != neighbor->neighbor_table) { GNUNET_CONTAINER_multipeermap_iterate (neighbor->neighbor_table, - &free_targets, - NULL); + &free_targets, + NULL); GNUNET_CONTAINER_multipeermap_destroy (neighbor->neighbor_table); neighbor->neighbor_table = NULL; } neighbor->neighbor_table = neighbor->neighbor_table_consensus; neighbor->neighbor_table_consensus = NULL; - break; - case GNUNET_SET_STATUS_DONE: + /* operation done, schedule next run! */ neighbor->set_op = NULL; if (0 < memcmp (&neighbor->peer, @@ -1406,7 +1508,7 @@ handle_set_union_result (void *cls, * necessary to specify the set we want to do the operation with, * whith sometimes can be derived from the context message. * Also necessary to specify the timeout. - */ + */ static void listen_set_union (void *cls, const struct GNUNET_PeerIdentity *other_peer, @@ -1418,7 +1520,7 @@ listen_set_union (void *cls, if (NULL == request) return; /* why??? */ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Starting to create consensus with %s!\n", + "Starting to create consensus with %s\n", GNUNET_i2s (&neighbor->peer)); if (NULL != neighbor->set_op) { @@ -1436,6 +1538,9 @@ listen_set_union (void *cls, GNUNET_SET_RESULT_ADDED, &handle_set_union_result, neighbor); + neighbor->consensus_insertion_offset = 0; + neighbor->consensus_insertion_distance = 0; + neighbor->consensus_elements = 0; build_set (neighbor); } @@ -1446,7 +1551,7 @@ listen_set_union (void *cls, * @param cls the 'struct DirectNeighbor' of the peer we're building * a routing consensus with * @param tc scheduler context - */ + */ static void initiate_set_union (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) @@ -1454,7 +1559,8 @@ initiate_set_union (void *cls, struct DirectNeighbor *neighbor = cls; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Initiating SET union\n"); + "Initiating SET union with peer `%s'\n", + GNUNET_i2s (&neighbor->peer)); neighbor->initiate_task = GNUNET_SCHEDULER_NO_TASK; neighbor->my_set = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION); @@ -1465,6 +1571,9 @@ initiate_set_union (void *cls, GNUNET_SET_RESULT_ADDED, &handle_set_union_result, neighbor); + neighbor->consensus_insertion_offset = 0; + neighbor->consensus_insertion_distance = 0; + neighbor->consensus_elements = 0; build_set (neighbor); } @@ -1550,7 +1659,7 @@ handle_dv_route_message (void *cls, const struct GNUNET_PeerIdentity *peer, &rm->target, &rm->sender, payload); - return GNUNET_OK; + return GNUNET_OK; } @@ -1627,12 +1736,12 @@ cleanup_neighbor (struct DirectNeighbor *neighbor) neighbor->pm_queue_size--; GNUNET_CONTAINER_DLL_remove (neighbor->pm_head, neighbor->pm_tail, - pending); + pending); GNUNET_free (pending); } handle_direct_disconnect (neighbor); GNUNET_assert (GNUNET_YES == - GNUNET_CONTAINER_multipeermap_remove (direct_neighbors, + GNUNET_CONTAINER_multipeermap_remove (direct_neighbors, &neighbor->peer, neighbor)); GNUNET_free (neighbor); @@ -1667,9 +1776,10 @@ handle_core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) neighbor->connected = GNUNET_NO; if (DIRECT_NEIGHBOR_COST == neighbor->distance) { + GNUNET_STATISTICS_update (stats, "# peers connected (1-hop)", - -1, GNUNET_NO); + -1, GNUNET_NO); } cleanup_neighbor (neighbor); GNUNET_CONTAINER_multipeermap_iterate (direct_neighbors, @@ -1770,13 +1880,13 @@ add_route (void *cls, struct GNUNET_SERVER_Client *client = cls; struct Route *route = value; struct GNUNET_DV_ConnectMessage cm; - + cm.header.size = htons (sizeof (cm)); cm.header.type = htons (GNUNET_MESSAGE_TYPE_DV_CONNECT); cm.distance = htonl (route->target.distance); cm.peer = route->target.peer; - GNUNET_SERVER_notification_context_unicast (nc, + GNUNET_SERVER_notification_context_unicast (nc, client, &cm.header, GNUNET_NO); @@ -1796,7 +1906,7 @@ static void handle_start (void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message) { - GNUNET_SERVER_notification_context_add (nc, client); + GNUNET_SERVER_notification_context_add (nc, client); GNUNET_SERVER_receive_done (client, GNUNET_OK); GNUNET_CONTAINER_multipeermap_iterate (all_routes, &add_route, @@ -1837,11 +1947,11 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, {NULL, 0, 0} }; static struct GNUNET_SERVER_MessageHandler plugin_handlers[] = { - {&handle_start, NULL, - GNUNET_MESSAGE_TYPE_DV_START, + {&handle_start, NULL, + GNUNET_MESSAGE_TYPE_DV_START, sizeof (struct GNUNET_MessageHeader) }, - { &handle_dv_send_message, NULL, - GNUNET_MESSAGE_TYPE_DV_SEND, + { &handle_dv_send_message, NULL, + GNUNET_MESSAGE_TYPE_DV_SEND, 0}, {NULL, NULL, 0, 0} }; @@ -1850,11 +1960,11 @@ run (void *cls, struct GNUNET_SERVER_Handle *server, direct_neighbors = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO); all_routes = GNUNET_CONTAINER_multipeermap_create (65536, GNUNET_NO); core_api = GNUNET_CORE_connect (cfg, NULL, - &core_init, + &core_init, &handle_core_connect, &handle_core_disconnect, - NULL, GNUNET_NO, - NULL, GNUNET_NO, + NULL, GNUNET_NO, + NULL, GNUNET_NO, core_handlers); if (NULL == core_api)