diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/consensus | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/consensus')
-rw-r--r-- | src/consensus/consensus.h | 6 | ||||
-rw-r--r-- | src/consensus/consensus_api.c | 183 | ||||
-rw-r--r-- | src/consensus/consensus_protocol.h | 15 | ||||
-rw-r--r-- | src/consensus/gnunet-consensus-profiler.c | 536 | ||||
-rw-r--r-- | src/consensus/gnunet-service-consensus.c | 3196 | ||||
-rw-r--r-- | src/consensus/plugin_block_consensus.c | 60 | ||||
-rw-r--r-- | src/consensus/test_consensus_api.c | 74 |
7 files changed, 2092 insertions, 1978 deletions
diff --git a/src/consensus/consensus.h b/src/consensus/consensus.h index f110b23b2..888213d55 100644 --- a/src/consensus/consensus.h +++ b/src/consensus/consensus.h @@ -34,7 +34,8 @@ GNUNET_NETWORK_STRUCT_BEGIN * Sent by the client to the service, * when the client wants the service to join a consensus session. */ -struct GNUNET_CONSENSUS_JoinMessage { +struct GNUNET_CONSENSUS_JoinMessage +{ /** * Type: GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN */ @@ -68,7 +69,8 @@ struct GNUNET_CONSENSUS_JoinMessage { /** * Message with an element */ -struct GNUNET_CONSENSUS_ElementMessage { +struct GNUNET_CONSENSUS_ElementMessage +{ /** * Type: * Either GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT diff --git a/src/consensus/consensus_api.c b/src/consensus/consensus_api.c index 2da145932..c4350adaf 100644 --- a/src/consensus/consensus_api.c +++ b/src/consensus/consensus_api.c @@ -31,13 +31,14 @@ #include "consensus.h" -#define LOG(kind, ...) GNUNET_log_from(kind, "consensus-api", __VA_ARGS__) +#define LOG(kind, ...) GNUNET_log_from (kind, "consensus-api", __VA_ARGS__) /** * Handle for the service. */ -struct GNUNET_CONSENSUS_Handle { +struct GNUNET_CONSENSUS_Handle +{ /** * Configuration to use. */ @@ -89,7 +90,8 @@ struct GNUNET_CONSENSUS_Handle { * FIXME: this should not bee necessary when the API * issue has been fixed */ -struct InsertDoneInfo { +struct InsertDoneInfo +{ GNUNET_CONSENSUS_InsertDoneCallback idc; void *cls; }; @@ -102,8 +104,8 @@ struct InsertDoneInfo { * @param msg element message */ static int -check_new_element(void *cls, - const struct GNUNET_CONSENSUS_ElementMessage *msg) +check_new_element (void *cls, + const struct GNUNET_CONSENSUS_ElementMessage *msg) { /* any size is fine, elements are variable-size */ return GNUNET_OK; @@ -117,19 +119,20 @@ check_new_element(void *cls, * @param msg element message */ static void -handle_new_element(void *cls, - const struct GNUNET_CONSENSUS_ElementMessage *msg) +handle_new_element (void *cls, + const struct GNUNET_CONSENSUS_ElementMessage *msg) { struct GNUNET_CONSENSUS_Handle *consensus = cls; struct GNUNET_SET_Element element; - LOG(GNUNET_ERROR_TYPE_DEBUG, - "received new element\n"); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "received new element\n"); element.element_type = msg->element_type; - element.size = ntohs(msg->header.size) - sizeof(struct GNUNET_CONSENSUS_ElementMessage); + element.size = ntohs (msg->header.size) - sizeof(struct + GNUNET_CONSENSUS_ElementMessage); element.data = &msg[1]; - consensus->new_element_cb(consensus->new_element_cls, - &element); + consensus->new_element_cb (consensus->new_element_cls, + &element); } @@ -141,17 +144,17 @@ handle_new_element(void *cls, * @param msg conclude done message */ static void -handle_conclude_done(void *cls, - const struct GNUNET_MessageHeader *msg) +handle_conclude_done (void *cls, + const struct GNUNET_MessageHeader *msg) { struct GNUNET_CONSENSUS_Handle *consensus = cls; GNUNET_CONSENSUS_ConcludeCallback cc; - GNUNET_MQ_destroy(consensus->mq); + GNUNET_MQ_destroy (consensus->mq); consensus->mq = NULL; - GNUNET_assert(NULL != (cc = consensus->conclude_cb)); + GNUNET_assert (NULL != (cc = consensus->conclude_cb)); consensus->conclude_cb = NULL; - cc(consensus->conclude_cls); + cc (consensus->conclude_cls); } @@ -165,11 +168,11 @@ handle_conclude_done(void *cls, * @param error error code */ static void -mq_error_handler(void *cls, - enum GNUNET_MQ_Error error) +mq_error_handler (void *cls, + enum GNUNET_MQ_Error error) { - LOG(GNUNET_ERROR_TYPE_WARNING, - "consensus service disconnected us\n"); + LOG (GNUNET_ERROR_TYPE_WARNING, + "consensus service disconnected us\n"); } @@ -191,27 +194,27 @@ mq_error_handler(void *cls, * @return handle to use, NULL on error */ struct GNUNET_CONSENSUS_Handle * -GNUNET_CONSENSUS_create(const struct GNUNET_CONFIGURATION_Handle *cfg, - unsigned int num_peers, - const struct GNUNET_PeerIdentity *peers, - const struct GNUNET_HashCode *session_id, - struct GNUNET_TIME_Absolute start, - struct GNUNET_TIME_Absolute deadline, - GNUNET_CONSENSUS_ElementCallback new_element_cb, - void *new_element_cls) +GNUNET_CONSENSUS_create (const struct GNUNET_CONFIGURATION_Handle *cfg, + unsigned int num_peers, + const struct GNUNET_PeerIdentity *peers, + const struct GNUNET_HashCode *session_id, + struct GNUNET_TIME_Absolute start, + struct GNUNET_TIME_Absolute deadline, + GNUNET_CONSENSUS_ElementCallback new_element_cb, + void *new_element_cls) { struct GNUNET_CONSENSUS_Handle *consensus - = GNUNET_new(struct GNUNET_CONSENSUS_Handle); + = GNUNET_new (struct GNUNET_CONSENSUS_Handle); struct GNUNET_MQ_MessageHandler mq_handlers[] = { - GNUNET_MQ_hd_var_size(new_element, - GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT, - struct GNUNET_CONSENSUS_ElementMessage, - consensus), - GNUNET_MQ_hd_fixed_size(conclude_done, - GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE, - struct GNUNET_MessageHeader, - consensus), - GNUNET_MQ_handler_end() + GNUNET_MQ_hd_var_size (new_element, + GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT, + struct GNUNET_CONSENSUS_ElementMessage, + consensus), + GNUNET_MQ_hd_fixed_size (conclude_done, + GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE, + struct GNUNET_MessageHeader, + consensus), + GNUNET_MQ_handler_end () }; struct GNUNET_CONSENSUS_JoinMessage *join_msg; struct GNUNET_MQ_Envelope *ev; @@ -220,40 +223,40 @@ GNUNET_CONSENSUS_create(const struct GNUNET_CONFIGURATION_Handle *cfg, consensus->new_element_cb = new_element_cb; consensus->new_element_cls = new_element_cls; consensus->session_id = *session_id; - consensus->mq = GNUNET_CLIENT_connect(cfg, - "consensus", - mq_handlers, - &mq_error_handler, - consensus); + consensus->mq = GNUNET_CLIENT_connect (cfg, + "consensus", + mq_handlers, + &mq_error_handler, + consensus); if (NULL == consensus->mq) - { - GNUNET_free(consensus); - return NULL; - } - ev = GNUNET_MQ_msg_extra(join_msg, - (num_peers * sizeof(struct GNUNET_PeerIdentity)), - GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN); + { + GNUNET_free (consensus); + return NULL; + } + ev = GNUNET_MQ_msg_extra (join_msg, + (num_peers * sizeof(struct GNUNET_PeerIdentity)), + GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN); join_msg->session_id = consensus->session_id; - join_msg->start = GNUNET_TIME_absolute_hton(start); - join_msg->deadline = GNUNET_TIME_absolute_hton(deadline); - join_msg->num_peers = htonl(num_peers); - GNUNET_memcpy(&join_msg[1], - peers, - num_peers * sizeof(struct GNUNET_PeerIdentity)); - - GNUNET_MQ_send(consensus->mq, ev); + join_msg->start = GNUNET_TIME_absolute_hton (start); + join_msg->deadline = GNUNET_TIME_absolute_hton (deadline); + join_msg->num_peers = htonl (num_peers); + GNUNET_memcpy (&join_msg[1], + peers, + num_peers * sizeof(struct GNUNET_PeerIdentity)); + + GNUNET_MQ_send (consensus->mq, ev); return consensus; } static void -idc_adapter(void *cls) +idc_adapter (void *cls) { struct InsertDoneInfo *i = cls; - i->idc(i->cls, GNUNET_OK); - GNUNET_free(i); + i->idc (i->cls, GNUNET_OK); + GNUNET_free (i); } /** @@ -267,30 +270,30 @@ idc_adapter(void *cls) * @param idc_cls closure for 'idc' */ void -GNUNET_CONSENSUS_insert(struct GNUNET_CONSENSUS_Handle *consensus, - const struct GNUNET_SET_Element *element, - GNUNET_CONSENSUS_InsertDoneCallback idc, - void *idc_cls) +GNUNET_CONSENSUS_insert (struct GNUNET_CONSENSUS_Handle *consensus, + const struct GNUNET_SET_Element *element, + GNUNET_CONSENSUS_InsertDoneCallback idc, + void *idc_cls) { struct GNUNET_CONSENSUS_ElementMessage *element_msg; struct GNUNET_MQ_Envelope *ev; struct InsertDoneInfo *i; - LOG(GNUNET_ERROR_TYPE_DEBUG, "inserting, size=%llu\n", element->size); + LOG (GNUNET_ERROR_TYPE_DEBUG, "inserting, size=%llu\n", element->size); - ev = GNUNET_MQ_msg_extra(element_msg, element->size, - GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT); + ev = GNUNET_MQ_msg_extra (element_msg, element->size, + GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT); - GNUNET_memcpy(&element_msg[1], element->data, element->size); + GNUNET_memcpy (&element_msg[1], element->data, element->size); if (NULL != idc) - { - i = GNUNET_new(struct InsertDoneInfo); - i->idc = idc; - i->cls = idc_cls; - GNUNET_MQ_notify_sent(ev, idc_adapter, i); - } - GNUNET_MQ_send(consensus->mq, ev); + { + i = GNUNET_new (struct InsertDoneInfo); + i->idc = idc; + i->cls = idc_cls; + GNUNET_MQ_notify_sent (ev, idc_adapter, i); + } + GNUNET_MQ_send (consensus->mq, ev); } @@ -307,20 +310,20 @@ GNUNET_CONSENSUS_insert(struct GNUNET_CONSENSUS_Handle *consensus, * @param conclude_cls closure for the conclude callback */ void -GNUNET_CONSENSUS_conclude(struct GNUNET_CONSENSUS_Handle *consensus, - GNUNET_CONSENSUS_ConcludeCallback conclude, - void *conclude_cls) +GNUNET_CONSENSUS_conclude (struct GNUNET_CONSENSUS_Handle *consensus, + GNUNET_CONSENSUS_ConcludeCallback conclude, + void *conclude_cls) { struct GNUNET_MQ_Envelope *ev; - GNUNET_assert(NULL != conclude); - GNUNET_assert(NULL == consensus->conclude_cb); + GNUNET_assert (NULL != conclude); + GNUNET_assert (NULL == consensus->conclude_cb); consensus->conclude_cls = conclude_cls; consensus->conclude_cb = conclude; - ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE); - GNUNET_MQ_send(consensus->mq, ev); + ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE); + GNUNET_MQ_send (consensus->mq, ev); } @@ -331,14 +334,14 @@ GNUNET_CONSENSUS_conclude(struct GNUNET_CONSENSUS_Handle *consensus, * @param consensus handle to destroy */ void -GNUNET_CONSENSUS_destroy(struct GNUNET_CONSENSUS_Handle *consensus) +GNUNET_CONSENSUS_destroy (struct GNUNET_CONSENSUS_Handle *consensus) { if (NULL != consensus->mq) - { - GNUNET_MQ_destroy(consensus->mq); - consensus->mq = NULL; - } - GNUNET_free(consensus); + { + GNUNET_MQ_destroy (consensus->mq); + consensus->mq = NULL; + } + GNUNET_free (consensus); } /* end of consensus_api.c */ diff --git a/src/consensus/consensus_protocol.h b/src/consensus/consensus_protocol.h index fc8ae7533..a40162fb8 100644 --- a/src/consensus/consensus_protocol.h +++ b/src/consensus/consensus_protocol.h @@ -42,7 +42,8 @@ GNUNET_NETWORK_STRUCT_BEGIN * Essentially contains all the fields * from 'struct TaskKey', but in NBO. */ -struct GNUNET_CONSENSUS_RoundContextMessage { +struct GNUNET_CONSENSUS_RoundContextMessage +{ /** * Type: #GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT */ @@ -88,7 +89,8 @@ struct GNUNET_CONSENSUS_RoundContextMessage { }; -enum { +enum +{ CONSENSUS_MARKER_CONTESTED = 1, CONSENSUS_MARKER_SIZE = 2, }; @@ -97,7 +99,8 @@ enum { /** * Consensus element, either marker or payload. */ -struct ConsensusElement { +struct ConsensusElement +{ /** * Payload element_type, only valid * if this is not a marker element. @@ -113,14 +116,16 @@ struct ConsensusElement { }; -struct ConsensusSizeElement { +struct ConsensusSizeElement +{ struct ConsensusElement ce; uint64_t size GNUNET_PACKED; uint8_t sender_index; }; -struct ConsensusStuffedElement { +struct ConsensusStuffedElement +{ struct ConsensusElement ce; struct GNUNET_HashCode rand GNUNET_PACKED; }; diff --git a/src/consensus/gnunet-consensus-profiler.c b/src/consensus/gnunet-consensus-profiler.c index 9feee87cd..65fc23d8f 100644 --- a/src/consensus/gnunet-consensus-profiler.c +++ b/src/consensus/gnunet-consensus-profiler.c @@ -92,26 +92,26 @@ static struct GNUNET_TIME_Absolute deadline; * @param event information about the event */ static void -controller_cb(void *cls, - const struct GNUNET_TESTBED_EventInformation *event) +controller_cb (void *cls, + const struct GNUNET_TESTBED_EventInformation *event) { - GNUNET_assert(0); + GNUNET_assert (0); } static void -statistics_done_cb(void *cls, - struct - GNUNET_TESTBED_Operation - *op, - const char *emsg) +statistics_done_cb (void *cls, + struct + GNUNET_TESTBED_Operation + *op, + const char *emsg) { - GNUNET_assert(NULL == emsg); - GNUNET_TESTBED_operation_done(op); + GNUNET_assert (NULL == emsg); + GNUNET_TESTBED_operation_done (op); if (NULL != statistics_file) - fclose(statistics_file); - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "got statistics, shutting down\n"); - GNUNET_SCHEDULER_shutdown(); + fclose (statistics_file); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "got statistics, shutting down\n"); + GNUNET_SCHEDULER_shutdown (); } @@ -127,47 +127,48 @@ statistics_done_cb(void *cls, * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration */ static int -statistics_cb(void *cls, - const struct GNUNET_TESTBED_Peer *peer, - const char *subsystem, - const char *name, - uint64_t value, - int is_persistent) +statistics_cb (void *cls, + const struct GNUNET_TESTBED_Peer *peer, + const char *subsystem, + const char *name, + uint64_t value, + int is_persistent) { if (NULL != statistics_file) - { - fprintf(statistics_file, "P%u\t%s\t%s\t%lu\n", GNUNET_TESTBED_get_index(peer), subsystem, name, (unsigned long)value); - } + { + fprintf (statistics_file, "P%u\t%s\t%s\t%lu\n", GNUNET_TESTBED_get_index ( + peer), subsystem, name, (unsigned long) value); + } return GNUNET_OK; } static void -destroy(void *cls) +destroy (void *cls) { struct GNUNET_CONSENSUS_Handle *consensus = cls; - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "destroying consensus\n"); - GNUNET_CONSENSUS_destroy(consensus); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "destroying consensus\n"); + GNUNET_CONSENSUS_destroy (consensus); peers_done++; if (peers_done == num_peers) - { - unsigned int i; - for (i = 0; i < num_peers; i++) - GNUNET_TESTBED_operation_done(testbed_operations[i]); - for (i = 0; i < num_peers; i++) - printf("P%u got %u of %u elements\n", - i, - results_for_peer[i], - num_values); - if (NULL != statistics_filename) - statistics_file = fopen(statistics_filename, "w"); - GNUNET_TESTBED_get_statistics(num_peers, peers, NULL, NULL, - statistics_cb, - statistics_done_cb, - NULL); - } + { + unsigned int i; + for (i = 0; i < num_peers; i++) + GNUNET_TESTBED_operation_done (testbed_operations[i]); + for (i = 0; i < num_peers; i++) + printf ("P%u got %u of %u elements\n", + i, + results_for_peer[i], + num_values); + if (NULL != statistics_filename) + statistics_file = fopen (statistics_filename, "w"); + GNUNET_TESTBED_get_statistics (num_peers, peers, NULL, NULL, + statistics_cb, + statistics_done_cb, + NULL); + } } @@ -179,44 +180,44 @@ destroy(void *cls) * #GNUNET_NO if not */ static void -conclude_cb(void *cls) +conclude_cb (void *cls) { struct GNUNET_CONSENSUS_Handle **chp = cls; - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "consensus %d done\n", - (int)(chp - consensus_handles)); - GNUNET_SCHEDULER_add_now(destroy, *chp); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "consensus %d done\n", + (int) (chp - consensus_handles)); + GNUNET_SCHEDULER_add_now (destroy, *chp); } static void -generate_indices(int *indices) +generate_indices (int *indices) { int j; j = 0; while (j < replication) - { - int n; - int k; - int repeat; - n = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); - repeat = GNUNET_NO; - for (k = 0; k < j; k++) - if (indices[k] == n) - { - repeat = GNUNET_YES; - break; - } - if (GNUNET_NO == repeat) - indices[j++] = n; - } + { + int n; + int k; + int repeat; + n = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, num_peers); + repeat = GNUNET_NO; + for (k = 0; k < j; k++) + if (indices[k] == n) + { + repeat = GNUNET_YES; + break; + } + if (GNUNET_NO == repeat) + indices[j++] = n; + } } static void -do_consensus() +do_consensus () { int unique_indices[replication]; unsigned int i; @@ -225,48 +226,48 @@ do_consensus() struct GNUNET_SET_Element element; if (dist_static) + { + for (i = 0; i < num_values; i++) { - for (i = 0; i < num_values; i++) - { - GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &val); - - element.data = &val; - element.size = sizeof(val); - for (j = 0; j < replication; j++) - { - GNUNET_CONSENSUS_insert(consensus_handles[j], - &element, - NULL, NULL); - } - } + GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &val); + + element.data = &val; + element.size = sizeof(val); + for (j = 0; j < replication; j++) + { + GNUNET_CONSENSUS_insert (consensus_handles[j], + &element, + NULL, NULL); + } } + } else + { + for (i = 0; i < num_values; i++) { - for (i = 0; i < num_values; i++) - { - generate_indices(unique_indices); - GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &val); - - element.data = &val; - element.size = sizeof(val); - for (j = 0; j < replication; j++) - { - int cid; - - cid = unique_indices[j]; - GNUNET_CONSENSUS_insert(consensus_handles[cid], - &element, - NULL, NULL); - } - } + generate_indices (unique_indices); + GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &val); + + element.data = &val; + element.size = sizeof(val); + for (j = 0; j < replication; j++) + { + int cid; + + cid = unique_indices[j]; + GNUNET_CONSENSUS_insert (consensus_handles[cid], + &element, + NULL, NULL); + } } + } - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "all elements inserted, calling conclude\n"); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "all elements inserted, calling conclude\n"); for (i = 0; i < num_peers; i++) - GNUNET_CONSENSUS_conclude(consensus_handles[i], - conclude_cb, &consensus_handles[i]); + GNUNET_CONSENSUS_conclude (consensus_handles[i], + conclude_cb, &consensus_handles[i]); } @@ -280,50 +281,50 @@ do_consensus() * operation has executed successfully. */ static void -connect_complete(void *cls, - struct GNUNET_TESTBED_Operation *op, - void *ca_result, - const char *emsg) +connect_complete (void *cls, + struct GNUNET_TESTBED_Operation *op, + void *ca_result, + const char *emsg) { if (NULL != emsg) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "testbed connect emsg: %s\n", - emsg); - GNUNET_assert(0); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "testbed connect emsg: %s\n", + emsg); + GNUNET_assert (0); + } num_connected_handles++; - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "connect complete\n"); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "connect complete\n"); if (num_connected_handles == num_peers) - { - do_consensus(); - } + { + do_consensus (); + } } static void -new_element_cb(void *cls, - const struct GNUNET_SET_Element *element) +new_element_cb (void *cls, + const struct GNUNET_SET_Element *element) { struct GNUNET_CONSENSUS_Handle **chp = cls; int idx = chp - consensus_handles; - GNUNET_assert(NULL != cls); + GNUNET_assert (NULL != cls); results_for_peer[idx]++; - GNUNET_assert(sizeof(struct GNUNET_HashCode) == element->size); + GNUNET_assert (sizeof(struct GNUNET_HashCode) == element->size); if (GNUNET_YES == verbose) - { - printf("P%d received %s\n", - idx, - GNUNET_h2s((struct GNUNET_HashCode *)element->data)); - } + { + printf ("P%d received %s\n", + idx, + GNUNET_h2s ((struct GNUNET_HashCode *) element->data)); + } } @@ -338,24 +339,24 @@ new_element_cb(void *cls, * @return service handle to return in 'op_result', NULL on error */ static void * -connect_adapter(void *cls, - const struct GNUNET_CONFIGURATION_Handle *cfg) +connect_adapter (void *cls, + const struct GNUNET_CONFIGURATION_Handle *cfg) { struct GNUNET_CONSENSUS_Handle **chp = cls; struct GNUNET_CONSENSUS_Handle *consensus; - chp = (struct GNUNET_CONSENSUS_Handle **)cls; - - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "connect adapter, %d peers\n", - num_peers); - consensus = GNUNET_CONSENSUS_create(cfg, - num_peers, peer_ids, - &session_id, - start, - deadline, - &new_element_cb, chp); - *chp = (struct GNUNET_CONSENSUS_Handle *)consensus; + chp = (struct GNUNET_CONSENSUS_Handle **) cls; + + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "connect adapter, %d peers\n", + num_peers); + consensus = GNUNET_CONSENSUS_create (cfg, + num_peers, peer_ids, + &session_id, + start, + deadline, + &new_element_cb, chp); + *chp = (struct GNUNET_CONSENSUS_Handle *) consensus; return consensus; } @@ -368,11 +369,11 @@ connect_adapter(void *cls, * @param op_result service handle returned from the connect adapter */ static void -disconnect_adapter(void *cls, void *op_result) +disconnect_adapter (void *cls, void *op_result) { /* FIXME: what to do here? */ - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "disconnect adapter called\n"); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "disconnect adapter called\n"); } @@ -386,34 +387,36 @@ disconnect_adapter(void *cls, void *op_result) * operation is successfull */ static void -peer_info_cb(void *cb_cls, - struct GNUNET_TESTBED_Operation *op, - const struct GNUNET_TESTBED_PeerInformation *pinfo, - const char *emsg) +peer_info_cb (void *cb_cls, + struct GNUNET_TESTBED_Operation *op, + const struct GNUNET_TESTBED_PeerInformation *pinfo, + const char *emsg) { struct GNUNET_PeerIdentity *p; int i; - GNUNET_assert(NULL == emsg); + GNUNET_assert (NULL == emsg); - p = (struct GNUNET_PeerIdentity *)cb_cls; + p = (struct GNUNET_PeerIdentity *) cb_cls; if (pinfo->pit == GNUNET_TESTBED_PIT_IDENTITY) - { - *p = *pinfo->result.id; - num_retrieved_peer_ids++; - if (num_retrieved_peer_ids == num_peers) - for (i = 0; i < num_peers; i++) - testbed_operations[i] = - GNUNET_TESTBED_service_connect(NULL, peers[i], "consensus", connect_complete, NULL, - connect_adapter, disconnect_adapter, &consensus_handles[i]); - } + { + *p = *pinfo->result.id; + num_retrieved_peer_ids++; + if (num_retrieved_peer_ids == num_peers) + for (i = 0; i < num_peers; i++) + testbed_operations[i] = + GNUNET_TESTBED_service_connect (NULL, peers[i], "consensus", + connect_complete, NULL, + connect_adapter, disconnect_adapter, + &consensus_handles[i]); + } else - { - GNUNET_assert(0); - } + { + GNUNET_assert (0); + } - GNUNET_TESTBED_operation_done(op); + GNUNET_TESTBED_operation_done (op); } @@ -431,144 +434,153 @@ peer_info_cb(void *cb_cls, * failed */ static void -test_master(void *cls, - struct GNUNET_TESTBED_RunHandle *h, - unsigned int num_peers, - struct GNUNET_TESTBED_Peer **started_peers, - unsigned int links_succeeded, - unsigned int links_failed) +test_master (void *cls, + struct GNUNET_TESTBED_RunHandle *h, + unsigned int num_peers, + struct GNUNET_TESTBED_Peer **started_peers, + unsigned int links_succeeded, + unsigned int links_failed) { int i; - GNUNET_log_setup("gnunet-consensus", "INFO", NULL); + GNUNET_log_setup ("gnunet-consensus", "INFO", NULL); - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "test master\n"); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "test master\n"); peers = started_peers; - peer_ids = GNUNET_malloc(num_peers * sizeof(struct GNUNET_PeerIdentity)); + peer_ids = GNUNET_malloc (num_peers * sizeof(struct GNUNET_PeerIdentity)); - results_for_peer = GNUNET_malloc(num_peers * sizeof(unsigned int)); - consensus_handles = GNUNET_malloc(num_peers * sizeof(struct ConsensusHandle *)); - testbed_operations = GNUNET_malloc(num_peers * sizeof(struct ConsensusHandle *)); + results_for_peer = GNUNET_malloc (num_peers * sizeof(unsigned int)); + consensus_handles = GNUNET_malloc (num_peers * sizeof(struct + ConsensusHandle *)); + testbed_operations = GNUNET_malloc (num_peers * sizeof(struct + ConsensusHandle *)); for (i = 0; i < num_peers; i++) - GNUNET_TESTBED_peer_get_information(peers[i], - GNUNET_TESTBED_PIT_IDENTITY, - peer_info_cb, - &peer_ids[i]); + GNUNET_TESTBED_peer_get_information (peers[i], + GNUNET_TESTBED_PIT_IDENTITY, + peer_info_cb, + &peer_ids[i]); } static void -run(void *cls, char *const *args, const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *cfg) +run (void *cls, char *const *args, const char *cfgfile, + const struct GNUNET_CONFIGURATION_Handle *cfg) { static char *session_str = "gnunet-consensus/test"; char *topology; int topology_cmp_result; - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "testbed", "OVERLAY_TOPOLOGY", &topology)) - { - fprintf(stderr, - "'OVERLAY_TOPOLOGY' not found in 'testbed' config section, " - "seems like you passed the wrong configuration file\n"); - return; - } + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "testbed", + "OVERLAY_TOPOLOGY", + &topology)) + { + fprintf (stderr, + "'OVERLAY_TOPOLOGY' not found in 'testbed' config section, " + "seems like you passed the wrong configuration file\n"); + return; + } - topology_cmp_result = strcasecmp(topology, "NONE"); - GNUNET_free(topology); + topology_cmp_result = strcasecmp (topology, "NONE"); + GNUNET_free (topology); if (0 == topology_cmp_result) - { - fprintf(stderr, - "'OVERLAY_TOPOLOGY' set to 'NONE', " - "seems like you passed the wrong configuration file\n"); - return; - } + { + fprintf (stderr, + "'OVERLAY_TOPOLOGY' set to 'NONE', " + "seems like you passed the wrong configuration file\n"); + return; + } if (num_peers < replication) - { - fprintf(stderr, "k must be <=n\n"); - return; - } - - start = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), consensus_delay); - deadline = GNUNET_TIME_absolute_add(start, conclude_timeout); - - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "running gnunet-consensus\n"); - - GNUNET_CRYPTO_hash(session_str, strlen(session_str), &session_id); - - (void)GNUNET_TESTBED_test_run("gnunet-consensus", - cfgfile, - num_peers, - 0, - controller_cb, - NULL, - test_master, - NULL); + { + fprintf (stderr, "k must be <=n\n"); + return; + } + + start = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), + consensus_delay); + deadline = GNUNET_TIME_absolute_add (start, conclude_timeout); + + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "running gnunet-consensus\n"); + + GNUNET_CRYPTO_hash (session_str, strlen (session_str), &session_id); + + (void) GNUNET_TESTBED_test_run ("gnunet-consensus", + cfgfile, + num_peers, + 0, + controller_cb, + NULL, + test_master, + NULL); } int -main(int argc, char **argv) +main (int argc, char **argv) { struct GNUNET_GETOPT_CommandLineOption options[] = { - GNUNET_GETOPT_option_uint('n', - "num-peers", - NULL, - gettext_noop("number of peers in consensus"), - &num_peers), - - GNUNET_GETOPT_option_uint('k', - "value-replication", - NULL, - gettext_noop("how many peers (random selection without replacement) receive one value?"), - &replication), - - GNUNET_GETOPT_option_uint('x', - "num-values", - NULL, - gettext_noop("number of values"), - &num_values), - - GNUNET_GETOPT_option_relative_time('t', - "timeout", - NULL, - gettext_noop("consensus timeout"), - &conclude_timeout), - - - GNUNET_GETOPT_option_relative_time('d', - "delay", - NULL, - gettext_noop("delay until consensus starts"), - &consensus_delay), - - GNUNET_GETOPT_option_filename('s', - "statistics", - "FILENAME", - gettext_noop("write statistics to file"), - &statistics_filename), - - GNUNET_GETOPT_option_flag('S', - "dist-static", - gettext_noop("distribute elements to a static subset of good peers"), - &dist_static), - - GNUNET_GETOPT_option_flag('V', - "verbose", - gettext_noop("be more verbose (print received values)"), - &verbose), + GNUNET_GETOPT_option_uint ('n', + "num-peers", + NULL, + gettext_noop ("number of peers in consensus"), + &num_peers), + + GNUNET_GETOPT_option_uint ('k', + "value-replication", + NULL, + gettext_noop ( + "how many peers (random selection without replacement) receive one value?"), + &replication), + + GNUNET_GETOPT_option_uint ('x', + "num-values", + NULL, + gettext_noop ("number of values"), + &num_values), + + GNUNET_GETOPT_option_relative_time ('t', + "timeout", + NULL, + gettext_noop ("consensus timeout"), + &conclude_timeout), + + + GNUNET_GETOPT_option_relative_time ('d', + "delay", + NULL, + gettext_noop ( + "delay until consensus starts"), + &consensus_delay), + + GNUNET_GETOPT_option_filename ('s', + "statistics", + "FILENAME", + gettext_noop ("write statistics to file"), + &statistics_filename), + + GNUNET_GETOPT_option_flag ('S', + "dist-static", + gettext_noop ( + "distribute elements to a static subset of good peers"), + &dist_static), + + GNUNET_GETOPT_option_flag ('V', + "verbose", + gettext_noop ( + "be more verbose (print received values)"), + &verbose), GNUNET_GETOPT_OPTION_END }; conclude_timeout = GNUNET_TIME_UNIT_SECONDS; - GNUNET_PROGRAM_run2(argc, argv, "gnunet-consensus-profiler", - "help", - options, &run, NULL, GNUNET_YES); + GNUNET_PROGRAM_run2 (argc, argv, "gnunet-consensus-profiler", + "help", + options, &run, NULL, GNUNET_YES); return 0; } diff --git a/src/consensus/gnunet-service-consensus.c b/src/consensus/gnunet-service-consensus.c index 98fd551b2..8ef70eee8 100644 --- a/src/consensus/gnunet-service-consensus.c +++ b/src/consensus/gnunet-service-consensus.c @@ -36,7 +36,8 @@ #include "consensus.h" -enum ReferendumVote { +enum ReferendumVote +{ /** * Vote that nothing should change. * This option is never voted explicitly. @@ -53,7 +54,8 @@ enum ReferendumVote { }; -enum EarlyStoppingPhase { +enum EarlyStoppingPhase +{ EARLY_STOPPING_NONE = 0, EARLY_STOPPING_ONE_MORE = 1, EARLY_STOPPING_DONE = 2, @@ -66,7 +68,8 @@ GNUNET_NETWORK_STRUCT_BEGIN * Tuple of integers that together * identify a task uniquely. */ -struct TaskKey { +struct TaskKey +{ /** * A value from 'enum PhaseKind'. */ @@ -98,14 +101,16 @@ struct TaskKey { -struct SetKey { +struct SetKey +{ int set_kind GNUNET_PACKED; int k1 GNUNET_PACKED; int k2 GNUNET_PACKED; }; -struct SetEntry { +struct SetEntry +{ struct SetKey key; struct GNUNET_SET_Handle *h; /** @@ -117,13 +122,15 @@ struct SetEntry { }; -struct DiffKey { +struct DiffKey +{ int diff_kind GNUNET_PACKED; int k1 GNUNET_PACKED; int k2 GNUNET_PACKED; }; -struct RfnKey { +struct RfnKey +{ int rfn_kind GNUNET_PACKED; int k1 GNUNET_PACKED; int k2 GNUNET_PACKED; @@ -132,7 +139,8 @@ struct RfnKey { GNUNET_NETWORK_STRUCT_END -enum PhaseKind { +enum PhaseKind +{ PHASE_KIND_ALL_TO_ALL, PHASE_KIND_ALL_TO_ALL_2, PHASE_KIND_GRADECAST_LEADER, @@ -149,7 +157,8 @@ enum PhaseKind { }; -enum SetKind { +enum SetKind +{ SET_KIND_NONE = 0, SET_KIND_CURRENT, /** @@ -160,14 +169,16 @@ enum SetKind { SET_KIND_ECHO_RESULT, }; -enum DiffKind { +enum DiffKind +{ DIFF_KIND_NONE = 0, DIFF_KIND_LEADER_PROPOSAL, DIFF_KIND_LEADER_CONSENSUS, DIFF_KIND_GRADECAST_RESULT, }; -enum RfnKind { +enum RfnKind +{ RFN_KIND_NONE = 0, RFN_KIND_ECHO, RFN_KIND_CONFIRM, @@ -175,7 +186,8 @@ enum RfnKind { }; -struct SetOpCls { +struct SetOpCls +{ struct SetKey input_set; struct SetKey output_set; @@ -190,7 +202,8 @@ struct SetOpCls { }; -struct FinishCls { +struct FinishCls +{ struct SetKey input_set; }; @@ -198,7 +211,8 @@ struct FinishCls { * Closure for both @a start_task * and @a cancel_task. */ -union TaskFuncCls { +union TaskFuncCls +{ struct SetOpCls setop; struct FinishCls finish; }; @@ -210,7 +224,8 @@ typedef void (*TaskFunc) (struct TaskEntry *task); /* * Node in the consensus task graph. */ -struct TaskEntry { +struct TaskEntry +{ struct TaskKey key; struct Step *step; @@ -226,7 +241,8 @@ struct TaskEntry { }; -struct Step { +struct Step +{ /** * All steps of one session are in a * linked list for easier deallocation. @@ -304,7 +320,8 @@ struct Step { }; -struct RfnElementInfo { +struct RfnElementInfo +{ const struct GNUNET_SET_Element *element; /* @@ -320,7 +337,8 @@ struct RfnElementInfo { }; -struct ReferendumEntry { +struct ReferendumEntry +{ struct RfnKey key; /* @@ -355,7 +373,8 @@ struct ReferendumEntry { }; -struct DiffElementInfo { +struct DiffElementInfo +{ const struct GNUNET_SET_Element *element; /** @@ -369,12 +388,14 @@ struct DiffElementInfo { /** * Weighted diff. */ -struct DiffEntry { +struct DiffEntry +{ struct DiffKey key; struct GNUNET_CONTAINER_MultiHashMap *changes; }; -struct SetHandle { +struct SetHandle +{ struct SetHandle *prev; struct SetHandle *next; @@ -386,7 +407,8 @@ struct SetHandle { /** * A consensus session consists of one local client and the remote authorities. */ -struct ConsensusSession { +struct ConsensusSession +{ /** * Consensus sessions are kept in a DLL. */ @@ -518,147 +540,147 @@ struct GNUNET_STATISTICS_Handle *statistics; static void -finish_task(struct TaskEntry *task); +finish_task (struct TaskEntry *task); static void -run_ready_steps(struct ConsensusSession *session); +run_ready_steps (struct ConsensusSession *session); static const char * -phasename(uint16_t phase) +phasename (uint16_t phase) { switch (phase) - { - case PHASE_KIND_ALL_TO_ALL: return "ALL_TO_ALL"; + { + case PHASE_KIND_ALL_TO_ALL: return "ALL_TO_ALL"; - case PHASE_KIND_ALL_TO_ALL_2: return "ALL_TO_ALL_2"; + case PHASE_KIND_ALL_TO_ALL_2: return "ALL_TO_ALL_2"; - case PHASE_KIND_FINISH: return "FINISH"; + case PHASE_KIND_FINISH: return "FINISH"; - case PHASE_KIND_GRADECAST_LEADER: return "GRADECAST_LEADER"; + case PHASE_KIND_GRADECAST_LEADER: return "GRADECAST_LEADER"; - case PHASE_KIND_GRADECAST_ECHO: return "GRADECAST_ECHO"; + case PHASE_KIND_GRADECAST_ECHO: return "GRADECAST_ECHO"; - case PHASE_KIND_GRADECAST_ECHO_GRADE: return "GRADECAST_ECHO_GRADE"; + case PHASE_KIND_GRADECAST_ECHO_GRADE: return "GRADECAST_ECHO_GRADE"; - case PHASE_KIND_GRADECAST_CONFIRM: return "GRADECAST_CONFIRM"; + case PHASE_KIND_GRADECAST_CONFIRM: return "GRADECAST_CONFIRM"; - case PHASE_KIND_GRADECAST_CONFIRM_GRADE: return "GRADECAST_CONFIRM_GRADE"; + case PHASE_KIND_GRADECAST_CONFIRM_GRADE: return "GRADECAST_CONFIRM_GRADE"; - case PHASE_KIND_APPLY_REP: return "APPLY_REP"; + case PHASE_KIND_APPLY_REP: return "APPLY_REP"; - default: return "(unknown)"; - } + default: return "(unknown)"; + } } static const char * -setname(uint16_t kind) +setname (uint16_t kind) { switch (kind) - { - case SET_KIND_CURRENT: return "CURRENT"; + { + case SET_KIND_CURRENT: return "CURRENT"; - case SET_KIND_LEADER_PROPOSAL: return "LEADER_PROPOSAL"; + case SET_KIND_LEADER_PROPOSAL: return "LEADER_PROPOSAL"; - case SET_KIND_NONE: return "NONE"; + case SET_KIND_NONE: return "NONE"; - default: return "(unknown)"; - } + default: return "(unknown)"; + } } static const char * -rfnname(uint16_t kind) +rfnname (uint16_t kind) { switch (kind) - { - case RFN_KIND_NONE: return "NONE"; + { + case RFN_KIND_NONE: return "NONE"; - case RFN_KIND_ECHO: return "ECHO"; + case RFN_KIND_ECHO: return "ECHO"; - case RFN_KIND_CONFIRM: return "CONFIRM"; + case RFN_KIND_CONFIRM: return "CONFIRM"; - default: return "(unknown)"; - } + default: return "(unknown)"; + } } static const char * -diffname(uint16_t kind) +diffname (uint16_t kind) { switch (kind) - { - case DIFF_KIND_NONE: return "NONE"; + { + case DIFF_KIND_NONE: return "NONE"; - case DIFF_KIND_LEADER_CONSENSUS: return "LEADER_CONSENSUS"; + case DIFF_KIND_LEADER_CONSENSUS: return "LEADER_CONSENSUS"; - case DIFF_KIND_GRADECAST_RESULT: return "GRADECAST_RESULT"; + case DIFF_KIND_GRADECAST_RESULT: return "GRADECAST_RESULT"; - case DIFF_KIND_LEADER_PROPOSAL: return "LEADER_PROPOSAL"; + case DIFF_KIND_LEADER_PROPOSAL: return "LEADER_PROPOSAL"; - default: return "(unknown)"; - } + default: return "(unknown)"; + } } #ifdef GNUNET_EXTRA_LOGGING static const char * -debug_str_element(const struct GNUNET_SET_Element *el) +debug_str_element (const struct GNUNET_SET_Element *el) { struct GNUNET_HashCode hash; - GNUNET_SET_element_hash(el, &hash); + GNUNET_SET_element_hash (el, &hash); - return GNUNET_h2s(&hash); + return GNUNET_h2s (&hash); } static const char * -debug_str_task_key(struct TaskKey *tk) +debug_str_task_key (struct TaskKey *tk) { static char buf[256]; - snprintf(buf, sizeof(buf), - "TaskKey kind=%s, p1=%d, p2=%d, l=%d, rep=%d", - phasename(tk->kind), tk->peer1, tk->peer2, - tk->leader, tk->repetition); + snprintf (buf, sizeof(buf), + "TaskKey kind=%s, p1=%d, p2=%d, l=%d, rep=%d", + phasename (tk->kind), tk->peer1, tk->peer2, + tk->leader, tk->repetition); return buf; } static const char * -debug_str_diff_key(struct DiffKey *dk) +debug_str_diff_key (struct DiffKey *dk) { static char buf[256]; - snprintf(buf, sizeof(buf), - "DiffKey kind=%s, k1=%d, k2=%d", - diffname(dk->diff_kind), dk->k1, dk->k2); + snprintf (buf, sizeof(buf), + "DiffKey kind=%s, k1=%d, k2=%d", + diffname (dk->diff_kind), dk->k1, dk->k2); return buf; } static const char * -debug_str_set_key(const struct SetKey *sk) +debug_str_set_key (const struct SetKey *sk) { static char buf[256]; - snprintf(buf, sizeof(buf), - "SetKey kind=%s, k1=%d, k2=%d", - setname(sk->set_kind), sk->k1, sk->k2); + snprintf (buf, sizeof(buf), + "SetKey kind=%s, k1=%d, k2=%d", + setname (sk->set_kind), sk->k1, sk->k2); return buf; } static const char * -debug_str_rfn_key(const struct RfnKey *rk) +debug_str_rfn_key (const struct RfnKey *rk) { static char buf[256]; - snprintf(buf, sizeof(buf), - "RfnKey kind=%s, k1=%d, k2=%d", - rfnname(rk->rfn_kind), rk->k1, rk->k2); + snprintf (buf, sizeof(buf), + "RfnKey kind=%s, k1=%d, k2=%d", + rfnname (rk->rfn_kind), rk->k1, rk->k2); return buf; } @@ -676,164 +698,170 @@ debug_str_rfn_key(const struct RfnKey *rk) * @return #GNUNET_YES to continue iterating, #GNUNET_NO to stop. */ static int -send_to_client_iter(void *cls, - const struct GNUNET_SET_Element *element) +send_to_client_iter (void *cls, + const struct GNUNET_SET_Element *element) { - struct TaskEntry *task = (struct TaskEntry *)cls; + struct TaskEntry *task = (struct TaskEntry *) cls; struct ConsensusSession *session = task->step->session; struct GNUNET_MQ_Envelope *ev; if (NULL != element) - { - struct GNUNET_CONSENSUS_ElementMessage *m; - const struct ConsensusElement *ce; - - GNUNET_assert(GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT == element->element_type); - ce = element->data; - - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "marker is %u\n", (unsigned)ce->marker); - - if (0 != ce->marker) - return GNUNET_YES; - - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%d: sending element %s to client\n", - session->local_peer_idx, - debug_str_element(element)); - - ev = GNUNET_MQ_msg_extra(m, element->size - sizeof(struct ConsensusElement), - GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT); - m->element_type = ce->payload_type; - GNUNET_memcpy(&m[1], &ce[1], element->size - sizeof(struct ConsensusElement)); - GNUNET_MQ_send(session->client_mq, ev); - } + { + struct GNUNET_CONSENSUS_ElementMessage *m; + const struct ConsensusElement *ce; + + GNUNET_assert (GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT == + element->element_type); + ce = element->data; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "marker is %u\n", + (unsigned) ce->marker); + + if (0 != ce->marker) + return GNUNET_YES; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%d: sending element %s to client\n", + session->local_peer_idx, + debug_str_element (element)); + + ev = GNUNET_MQ_msg_extra (m, element->size - sizeof(struct + ConsensusElement), + GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT); + m->element_type = ce->payload_type; + GNUNET_memcpy (&m[1], &ce[1], element->size - sizeof(struct + ConsensusElement)); + GNUNET_MQ_send (session->client_mq, ev); + } else - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%d: finished iterating elements for client\n", - session->local_peer_idx); - ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE); - GNUNET_MQ_send(session->client_mq, ev); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%d: finished iterating elements for client\n", + session->local_peer_idx); + ev = GNUNET_MQ_msg_header ( + GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE); + GNUNET_MQ_send (session->client_mq, ev); + } return GNUNET_YES; } static struct SetEntry * -lookup_set(struct ConsensusSession *session, struct SetKey *key) +lookup_set (struct ConsensusSession *session, struct SetKey *key) { struct GNUNET_HashCode hash; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: looking up set {%s}\n", - session->local_peer_idx, - debug_str_set_key(key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: looking up set {%s}\n", + session->local_peer_idx, + debug_str_set_key (key)); - GNUNET_assert(SET_KIND_NONE != key->set_kind); - GNUNET_CRYPTO_hash(key, sizeof(struct SetKey), &hash); - return GNUNET_CONTAINER_multihashmap_get(session->setmap, &hash); + GNUNET_assert (SET_KIND_NONE != key->set_kind); + GNUNET_CRYPTO_hash (key, sizeof(struct SetKey), &hash); + return GNUNET_CONTAINER_multihashmap_get (session->setmap, &hash); } static struct DiffEntry * -lookup_diff(struct ConsensusSession *session, struct DiffKey *key) +lookup_diff (struct ConsensusSession *session, struct DiffKey *key) { struct GNUNET_HashCode hash; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: looking up diff {%s}\n", - session->local_peer_idx, - debug_str_diff_key(key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: looking up diff {%s}\n", + session->local_peer_idx, + debug_str_diff_key (key)); - GNUNET_assert(DIFF_KIND_NONE != key->diff_kind); - GNUNET_CRYPTO_hash(key, sizeof(struct DiffKey), &hash); - return GNUNET_CONTAINER_multihashmap_get(session->diffmap, &hash); + GNUNET_assert (DIFF_KIND_NONE != key->diff_kind); + GNUNET_CRYPTO_hash (key, sizeof(struct DiffKey), &hash); + return GNUNET_CONTAINER_multihashmap_get (session->diffmap, &hash); } static struct ReferendumEntry * -lookup_rfn(struct ConsensusSession *session, struct RfnKey *key) +lookup_rfn (struct ConsensusSession *session, struct RfnKey *key) { struct GNUNET_HashCode hash; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: looking up rfn {%s}\n", - session->local_peer_idx, - debug_str_rfn_key(key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: looking up rfn {%s}\n", + session->local_peer_idx, + debug_str_rfn_key (key)); - GNUNET_assert(RFN_KIND_NONE != key->rfn_kind); - GNUNET_CRYPTO_hash(key, sizeof(struct RfnKey), &hash); - return GNUNET_CONTAINER_multihashmap_get(session->rfnmap, &hash); + GNUNET_assert (RFN_KIND_NONE != key->rfn_kind); + GNUNET_CRYPTO_hash (key, sizeof(struct RfnKey), &hash); + return GNUNET_CONTAINER_multihashmap_get (session->rfnmap, &hash); } static void -diff_insert(struct DiffEntry *diff, - int weight, - const struct GNUNET_SET_Element *element) +diff_insert (struct DiffEntry *diff, + int weight, + const struct GNUNET_SET_Element *element) { struct DiffElementInfo *di; struct GNUNET_HashCode hash; - GNUNET_assert((1 == weight) || (-1 == weight)); + GNUNET_assert ((1 == weight) || (-1 == weight)); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "diff_insert with element size %u\n", - element->size); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "diff_insert with element size %u\n", + element->size); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "hashing element\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "hashing element\n"); - GNUNET_SET_element_hash(element, &hash); + GNUNET_SET_element_hash (element, &hash); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "hashed element\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "hashed element\n"); - di = GNUNET_CONTAINER_multihashmap_get(diff->changes, &hash); + di = GNUNET_CONTAINER_multihashmap_get (diff->changes, &hash); if (NULL == di) - { - di = GNUNET_new(struct DiffElementInfo); - di->element = GNUNET_SET_element_dup(element); - GNUNET_assert(GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put(diff->changes, + { + di = GNUNET_new (struct DiffElementInfo); + di->element = GNUNET_SET_element_dup (element); + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multihashmap_put (diff->changes, &hash, di, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); - } + } di->weight = weight; } static void -rfn_commit(struct ReferendumEntry *rfn, - uint16_t commit_peer) +rfn_commit (struct ReferendumEntry *rfn, + uint16_t commit_peer) { - GNUNET_assert(commit_peer < rfn->num_peers); + GNUNET_assert (commit_peer < rfn->num_peers); rfn->peer_commited[commit_peer] = GNUNET_YES; } static void -rfn_contest(struct ReferendumEntry *rfn, - uint16_t contested_peer) +rfn_contest (struct ReferendumEntry *rfn, + uint16_t contested_peer) { - GNUNET_assert(contested_peer < rfn->num_peers); + GNUNET_assert (contested_peer < rfn->num_peers); rfn->peer_contested[contested_peer] = GNUNET_YES; } static uint16_t -rfn_noncontested(struct ReferendumEntry *rfn) +rfn_noncontested (struct ReferendumEntry *rfn) { uint16_t i; uint16_t ret; ret = 0; for (i = 0; i < rfn->num_peers; i++) - if ((GNUNET_YES == rfn->peer_commited[i]) && (GNUNET_NO == rfn->peer_contested[i])) + if ((GNUNET_YES == rfn->peer_commited[i]) && (GNUNET_NO == + rfn->peer_contested[i])) ret++; return ret; @@ -841,33 +869,33 @@ rfn_noncontested(struct ReferendumEntry *rfn) static void -rfn_vote(struct ReferendumEntry *rfn, - uint16_t voting_peer, - enum ReferendumVote vote, - const struct GNUNET_SET_Element *element) +rfn_vote (struct ReferendumEntry *rfn, + uint16_t voting_peer, + enum ReferendumVote vote, + const struct GNUNET_SET_Element *element) { struct RfnElementInfo *ri; struct GNUNET_HashCode hash; - GNUNET_assert(voting_peer < rfn->num_peers); + GNUNET_assert (voting_peer < rfn->num_peers); /* Explicit voting only makes sense with VOTE_ADD or VOTE_REMOTE, since VOTE_KEEP is implicit in not voting. */ - GNUNET_assert((VOTE_ADD == vote) || (VOTE_REMOVE == vote)); + GNUNET_assert ((VOTE_ADD == vote) || (VOTE_REMOVE == vote)); - GNUNET_SET_element_hash(element, &hash); - ri = GNUNET_CONTAINER_multihashmap_get(rfn->rfn_elements, &hash); + GNUNET_SET_element_hash (element, &hash); + ri = GNUNET_CONTAINER_multihashmap_get (rfn->rfn_elements, &hash); if (NULL == ri) - { - ri = GNUNET_new(struct RfnElementInfo); - ri->element = GNUNET_SET_element_dup(element); - ri->votes = GNUNET_new_array(rfn->num_peers, int); - GNUNET_assert(GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put(rfn->rfn_elements, + { + ri = GNUNET_new (struct RfnElementInfo); + ri->element = GNUNET_SET_element_dup (element); + ri->votes = GNUNET_new_array (rfn->num_peers, int); + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multihashmap_put (rfn->rfn_elements, &hash, ri, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); - } + } ri->votes[voting_peer] = GNUNET_YES; ri->proposal = vote; @@ -875,7 +903,7 @@ rfn_vote(struct ReferendumEntry *rfn, static uint16_t -task_other_peer(struct TaskEntry *task) +task_other_peer (struct TaskEntry *task) { uint16_t me = task->step->session->local_peer_idx; @@ -886,10 +914,10 @@ task_other_peer(struct TaskEntry *task) static int -cmp_uint64_t(const void *pa, const void *pb) +cmp_uint64_t (const void *pa, const void *pb) { - uint64_t a = *(uint64_t *)pa; - uint64_t b = *(uint64_t *)pb; + uint64_t a = *(uint64_t *) pa; + uint64_t b = *(uint64_t *) pb; if (a == b) return 0; @@ -909,10 +937,10 @@ cmp_uint64_t(const void *pa, const void *pb) * @param status see enum GNUNET_SET_Status */ static void -set_result_cb(void *cls, - const struct GNUNET_SET_Element *element, - uint64_t current_size, - enum GNUNET_SET_Status status) +set_result_cb (void *cls, + const struct GNUNET_SET_Element *element, + uint64_t current_size, + enum GNUNET_SET_Status status) { struct TaskEntry *task = cls; struct ConsensusSession *session = task->step->session; @@ -924,246 +952,250 @@ set_result_cb(void *cls, const struct ConsensusElement *consensus_element = NULL; if (NULL != element) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: got element of type %u, status %u\n", - session->local_peer_idx, - (unsigned)element->element_type, - (unsigned)status); - GNUNET_assert(GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT == element->element_type); - consensus_element = element->data; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: got element of type %u, status %u\n", + session->local_peer_idx, + (unsigned) element->element_type, + (unsigned) status); + GNUNET_assert (GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT == + element->element_type); + consensus_element = element->data; + } setop = &task->cls.setop; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: got set result for {%s}, status %u\n", - session->local_peer_idx, - debug_str_task_key(&task->key), - status); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: got set result for {%s}, status %u\n", + session->local_peer_idx, + debug_str_task_key (&task->key), + status); if (GNUNET_NO == task->is_started) - { - GNUNET_break_op(0); - return; - } + { + GNUNET_break_op (0); + return; + } if (GNUNET_YES == task->is_finished) - { - GNUNET_break_op(0); - return; - } + { + GNUNET_break_op (0); + return; + } - other_idx = task_other_peer(task); + other_idx = task_other_peer (task); if (SET_KIND_NONE != setop->output_set.set_kind) - { - output_set = lookup_set(session, &setop->output_set); - GNUNET_assert(NULL != output_set); - } + { + output_set = lookup_set (session, &setop->output_set); + GNUNET_assert (NULL != output_set); + } if (DIFF_KIND_NONE != setop->output_diff.diff_kind) - { - output_diff = lookup_diff(session, &setop->output_diff); - GNUNET_assert(NULL != output_diff); - } + { + output_diff = lookup_diff (session, &setop->output_diff); + GNUNET_assert (NULL != output_diff); + } if (RFN_KIND_NONE != setop->output_rfn.rfn_kind) - { - output_rfn = lookup_rfn(session, &setop->output_rfn); - GNUNET_assert(NULL != output_rfn); - } + { + output_rfn = lookup_rfn (session, &setop->output_rfn); + GNUNET_assert (NULL != output_rfn); + } if (GNUNET_YES == session->peers_blacklisted[other_idx]) - { - /* Peer might have been blacklisted - by a gradecast running in parallel, ignore elements from now */ - if (GNUNET_SET_STATUS_ADD_LOCAL == status) - return; - if (GNUNET_SET_STATUS_ADD_REMOTE == status) - return; - } + { + /* Peer might have been blacklisted + by a gradecast running in parallel, ignore elements from now */ + if (GNUNET_SET_STATUS_ADD_LOCAL == status) + return; + if (GNUNET_SET_STATUS_ADD_REMOTE == status) + return; + } if ((NULL != consensus_element) && (0 != consensus_element->marker)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: got some marker\n", + session->local_peer_idx); + if ((GNUNET_YES == setop->transceive_contested) && + (CONSENSUS_MARKER_CONTESTED == consensus_element->marker)) + { + GNUNET_assert (NULL != output_rfn); + rfn_contest (output_rfn, task_other_peer (task)); + return; + } + + if (CONSENSUS_MARKER_SIZE == consensus_element->marker) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: got some marker\n", - session->local_peer_idx); - if ((GNUNET_YES == setop->transceive_contested) && - (CONSENSUS_MARKER_CONTESTED == consensus_element->marker)) - { - GNUNET_assert(NULL != output_rfn); - rfn_contest(output_rfn, task_other_peer(task)); - return; - } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: got size marker\n", + session->local_peer_idx); - if (CONSENSUS_MARKER_SIZE == consensus_element->marker) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: got size marker\n", - session->local_peer_idx); - - - struct ConsensusSizeElement *cse = (void *)consensus_element; - - if (cse->sender_index == other_idx) - { - if (NULL == session->first_sizes_received) - session->first_sizes_received = GNUNET_new_array(session->num_peers, uint64_t); - session->first_sizes_received[other_idx] = GNUNET_ntohll(cse->size); - - uint64_t *copy = GNUNET_memdup(session->first_sizes_received, sizeof(uint64_t) * session->num_peers); - qsort(copy, session->num_peers, sizeof(uint64_t), cmp_uint64_t); - session->lower_bound = copy[session->num_peers / 3 + 1]; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: lower bound %llu\n", - session->local_peer_idx, - (long long)session->lower_bound); - GNUNET_free(copy); - } - return; - } + struct ConsensusSizeElement *cse = (void *) consensus_element; + + if (cse->sender_index == other_idx) + { + if (NULL == session->first_sizes_received) + session->first_sizes_received = GNUNET_new_array (session->num_peers, + uint64_t); + session->first_sizes_received[other_idx] = GNUNET_ntohll (cse->size); + + uint64_t *copy = GNUNET_memdup (session->first_sizes_received, + sizeof(uint64_t) * session->num_peers); + qsort (copy, session->num_peers, sizeof(uint64_t), cmp_uint64_t); + session->lower_bound = copy[session->num_peers / 3 + 1]; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: lower bound %llu\n", + session->local_peer_idx, + (long long) session->lower_bound); + GNUNET_free (copy); + } return; } + return; + } + switch (status) - { - case GNUNET_SET_STATUS_ADD_LOCAL: - GNUNET_assert(NULL != consensus_element); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Adding element in Task {%s}\n", - debug_str_task_key(&task->key)); - if (NULL != output_set) - { - // FIXME: record pending adds, use callback - GNUNET_SET_add_element(output_set->h, - element, - NULL, - NULL); + { + case GNUNET_SET_STATUS_ADD_LOCAL: + GNUNET_assert (NULL != consensus_element); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Adding element in Task {%s}\n", + debug_str_task_key (&task->key)); + if (NULL != output_set) + { + // FIXME: record pending adds, use callback + GNUNET_SET_add_element (output_set->h, + element, + NULL, + NULL); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: adding element %s into set {%s} of task {%s}\n", - session->local_peer_idx, - debug_str_element(element), - debug_str_set_key(&setop->output_set), - debug_str_task_key(&task->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: adding element %s into set {%s} of task {%s}\n", + session->local_peer_idx, + debug_str_element (element), + debug_str_set_key (&setop->output_set), + debug_str_task_key (&task->key)); #endif - } - if (NULL != output_diff) - { - diff_insert(output_diff, 1, element); + } + if (NULL != output_diff) + { + diff_insert (output_diff, 1, element); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: adding element %s into diff {%s} of task {%s}\n", - session->local_peer_idx, - debug_str_element(element), - debug_str_diff_key(&setop->output_diff), - debug_str_task_key(&task->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: adding element %s into diff {%s} of task {%s}\n", + session->local_peer_idx, + debug_str_element (element), + debug_str_diff_key (&setop->output_diff), + debug_str_task_key (&task->key)); #endif - } - if (NULL != output_rfn) - { - rfn_vote(output_rfn, task_other_peer(task), VOTE_ADD, element); + } + if (NULL != output_rfn) + { + rfn_vote (output_rfn, task_other_peer (task), VOTE_ADD, element); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: adding element %s into rfn {%s} of task {%s}\n", - session->local_peer_idx, - debug_str_element(element), - debug_str_rfn_key(&setop->output_rfn), - debug_str_task_key(&task->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: adding element %s into rfn {%s} of task {%s}\n", + session->local_peer_idx, + debug_str_element (element), + debug_str_rfn_key (&setop->output_rfn), + debug_str_task_key (&task->key)); #endif - } - // XXX: add result to structures in task - break; + } + // XXX: add result to structures in task + break; - case GNUNET_SET_STATUS_ADD_REMOTE: - GNUNET_assert(NULL != consensus_element); - if (GNUNET_YES == setop->do_not_remove) - break; - if (CONSENSUS_MARKER_CONTESTED == consensus_element->marker) - break; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Removing element in Task {%s}\n", - debug_str_task_key(&task->key)); - if (NULL != output_set) - { - // FIXME: record pending adds, use callback - GNUNET_SET_remove_element(output_set->h, - element, - NULL, - NULL); + case GNUNET_SET_STATUS_ADD_REMOTE: + GNUNET_assert (NULL != consensus_element); + if (GNUNET_YES == setop->do_not_remove) + break; + if (CONSENSUS_MARKER_CONTESTED == consensus_element->marker) + break; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Removing element in Task {%s}\n", + debug_str_task_key (&task->key)); + if (NULL != output_set) + { + // FIXME: record pending adds, use callback + GNUNET_SET_remove_element (output_set->h, + element, + NULL, + NULL); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: removing element %s from set {%s} of task {%s}\n", - session->local_peer_idx, - debug_str_element(element), - debug_str_set_key(&setop->output_set), - debug_str_task_key(&task->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: removing element %s from set {%s} of task {%s}\n", + session->local_peer_idx, + debug_str_element (element), + debug_str_set_key (&setop->output_set), + debug_str_task_key (&task->key)); #endif - } - if (NULL != output_diff) - { - diff_insert(output_diff, -1, element); + } + if (NULL != output_diff) + { + diff_insert (output_diff, -1, element); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: removing element %s from diff {%s} of task {%s}\n", - session->local_peer_idx, - debug_str_element(element), - debug_str_diff_key(&setop->output_diff), - debug_str_task_key(&task->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: removing element %s from diff {%s} of task {%s}\n", + session->local_peer_idx, + debug_str_element (element), + debug_str_diff_key (&setop->output_diff), + debug_str_task_key (&task->key)); #endif - } - if (NULL != output_rfn) - { - rfn_vote(output_rfn, task_other_peer(task), VOTE_REMOVE, element); + } + if (NULL != output_rfn) + { + rfn_vote (output_rfn, task_other_peer (task), VOTE_REMOVE, element); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: removing element %s from rfn {%s} of task {%s}\n", - session->local_peer_idx, - debug_str_element(element), - debug_str_rfn_key(&setop->output_rfn), - debug_str_task_key(&task->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: removing element %s from rfn {%s} of task {%s}\n", + session->local_peer_idx, + debug_str_element (element), + debug_str_rfn_key (&setop->output_rfn), + debug_str_task_key (&task->key)); #endif - } - break; + } + break; - case GNUNET_SET_STATUS_DONE: - // XXX: check first if any changes to the underlying - // set are still pending - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: Finishing setop in Task {%s} (%u/%u)\n", - session->local_peer_idx, - debug_str_task_key(&task->key), - (unsigned int)task->step->finished_tasks, - (unsigned int)task->step->tasks_len); - if (NULL != output_rfn) - { - rfn_commit(output_rfn, task_other_peer(task)); - } - if (PHASE_KIND_ALL_TO_ALL == task->key.kind) - { - session->first_size = current_size; - } - finish_task(task); - break; + case GNUNET_SET_STATUS_DONE: + // XXX: check first if any changes to the underlying + // set are still pending + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: Finishing setop in Task {%s} (%u/%u)\n", + session->local_peer_idx, + debug_str_task_key (&task->key), + (unsigned int) task->step->finished_tasks, + (unsigned int) task->step->tasks_len); + if (NULL != output_rfn) + { + rfn_commit (output_rfn, task_other_peer (task)); + } + if (PHASE_KIND_ALL_TO_ALL == task->key.kind) + { + session->first_size = current_size; + } + finish_task (task); + break; - case GNUNET_SET_STATUS_FAILURE: - // XXX: cleanup - GNUNET_break_op(0); - finish_task(task); - return; + case GNUNET_SET_STATUS_FAILURE: + // XXX: cleanup + GNUNET_break_op (0); + finish_task (task); + return; - default: - /* not reached */ - GNUNET_assert(0); - } + default: + /* not reached */ + GNUNET_assert (0); + } } #ifdef EVIL -enum EvilnessType { +enum EvilnessType +{ EVILNESS_NONE, EVILNESS_CRAM_ALL, EVILNESS_CRAM_LEAD, @@ -1172,13 +1204,15 @@ enum EvilnessType { EVILNESS_SLACK_A2A, }; -enum EvilnessSubType { +enum EvilnessSubType +{ EVILNESS_SUB_NONE, EVILNESS_SUB_REPLACEMENT, EVILNESS_SUB_NO_REPLACEMENT, }; -struct Evilness { +struct Evilness +{ enum EvilnessType type; enum EvilnessSubType subtype; unsigned int num; @@ -1186,129 +1220,133 @@ struct Evilness { static int -parse_evilness_cram_subtype(const char *evil_subtype_str, struct Evilness *evil) +parse_evilness_cram_subtype (const char *evil_subtype_str, struct + Evilness *evil) { - if (0 == strcmp("replace", evil_subtype_str)) - { - evil->subtype = EVILNESS_SUB_REPLACEMENT; - } - else if (0 == strcmp("noreplace", evil_subtype_str)) - { - evil->subtype = EVILNESS_SUB_NO_REPLACEMENT; - } + if (0 == strcmp ("replace", evil_subtype_str)) + { + evil->subtype = EVILNESS_SUB_REPLACEMENT; + } + else if (0 == strcmp ("noreplace", evil_subtype_str)) + { + evil->subtype = EVILNESS_SUB_NO_REPLACEMENT; + } else - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Malformed field '%s' in EVIL_SPEC (unknown subtype), behaving like a good peer.\n", - evil_subtype_str); - return GNUNET_SYSERR; - } + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Malformed field '%s' in EVIL_SPEC (unknown subtype), behaving like a good peer.\n", + evil_subtype_str); + return GNUNET_SYSERR; + } return GNUNET_OK; } static void -get_evilness(struct ConsensusSession *session, struct Evilness *evil) +get_evilness (struct ConsensusSession *session, struct Evilness *evil) { char *evil_spec; char *field; char *evil_type_str = NULL; char *evil_subtype_str = NULL; - GNUNET_assert(NULL != evil); + GNUNET_assert (NULL != evil); - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "consensus", "EVIL_SPEC", &evil_spec)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: no evilness\n", - session->local_peer_idx); - evil->type = EVILNESS_NONE; - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: got evilness spec\n", - session->local_peer_idx); + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "consensus", + "EVIL_SPEC", + &evil_spec)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: no evilness\n", + session->local_peer_idx); + evil->type = EVILNESS_NONE; + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: got evilness spec\n", + session->local_peer_idx); - for (field = strtok(evil_spec, "/"); + for (field = strtok (evil_spec, "/"); NULL != field; - field = strtok(NULL, "/")) - { - unsigned int peer_num; - unsigned int evil_num; - int ret; + field = strtok (NULL, "/")) + { + unsigned int peer_num; + unsigned int evil_num; + int ret; - evil_type_str = NULL; - evil_subtype_str = NULL; + evil_type_str = NULL; + evil_subtype_str = NULL; - ret = sscanf(field, "%u;%m[a-z-];%m[a-z-];%u", &peer_num, &evil_type_str, &evil_subtype_str, &evil_num); + ret = sscanf (field, "%u;%m[a-z-];%m[a-z-];%u", &peer_num, &evil_type_str, + &evil_subtype_str, &evil_num); - if (ret != 4) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Malformed field '%s' in EVIL_SPEC (expected 4 components got %d), behaving like a good peer.\n", - field, - ret); - goto not_evil; - } + if (ret != 4) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Malformed field '%s' in EVIL_SPEC (expected 4 components got %d), behaving like a good peer.\n", + field, + ret); + goto not_evil; + } - GNUNET_assert(NULL != evil_type_str); - GNUNET_assert(NULL != evil_subtype_str); + GNUNET_assert (NULL != evil_type_str); + GNUNET_assert (NULL != evil_subtype_str); - if (peer_num == session->local_peer_idx) - { - if (0 == strcmp("slack", evil_type_str)) - { - evil->type = EVILNESS_SLACK; - } - if (0 == strcmp("slack-a2a", evil_type_str)) - { - evil->type = EVILNESS_SLACK_A2A; - } - else if (0 == strcmp("cram-all", evil_type_str)) - { - evil->type = EVILNESS_CRAM_ALL; - evil->num = evil_num; - if (GNUNET_OK != parse_evilness_cram_subtype(evil_subtype_str, evil)) - goto not_evil; - } - else if (0 == strcmp("cram-lead", evil_type_str)) - { - evil->type = EVILNESS_CRAM_LEAD; - evil->num = evil_num; - if (GNUNET_OK != parse_evilness_cram_subtype(evil_subtype_str, evil)) - goto not_evil; - } - else if (0 == strcmp("cram-echo", evil_type_str)) - { - evil->type = EVILNESS_CRAM_ECHO; - evil->num = evil_num; - if (GNUNET_OK != parse_evilness_cram_subtype(evil_subtype_str, evil)) - goto not_evil; - } - else - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Malformed field '%s' in EVIL_SPEC (unknown type), behaving like a good peer.\n", - evil_type_str); - goto not_evil; - } - goto cleanup; - } - /* No GNUNET_free since memory was allocated by libc */ - free(evil_type_str); - evil_type_str = NULL; - evil_subtype_str = NULL; + if (peer_num == session->local_peer_idx) + { + if (0 == strcmp ("slack", evil_type_str)) + { + evil->type = EVILNESS_SLACK; + } + if (0 == strcmp ("slack-a2a", evil_type_str)) + { + evil->type = EVILNESS_SLACK_A2A; + } + else if (0 == strcmp ("cram-all", evil_type_str)) + { + evil->type = EVILNESS_CRAM_ALL; + evil->num = evil_num; + if (GNUNET_OK != parse_evilness_cram_subtype (evil_subtype_str, evil)) + goto not_evil; + } + else if (0 == strcmp ("cram-lead", evil_type_str)) + { + evil->type = EVILNESS_CRAM_LEAD; + evil->num = evil_num; + if (GNUNET_OK != parse_evilness_cram_subtype (evil_subtype_str, evil)) + goto not_evil; + } + else if (0 == strcmp ("cram-echo", evil_type_str)) + { + evil->type = EVILNESS_CRAM_ECHO; + evil->num = evil_num; + if (GNUNET_OK != parse_evilness_cram_subtype (evil_subtype_str, evil)) + goto not_evil; + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Malformed field '%s' in EVIL_SPEC (unknown type), behaving like a good peer.\n", + evil_type_str); + goto not_evil; + } + goto cleanup; } + /* No GNUNET_free since memory was allocated by libc */ + free (evil_type_str); + evil_type_str = NULL; + evil_subtype_str = NULL; + } not_evil: evil->type = EVILNESS_NONE; cleanup: - GNUNET_free(evil_spec); + GNUNET_free (evil_spec); /* no GNUNET_free_non_null since it wasn't * allocated with GNUNET_malloc */ if (NULL != evil_type_str) - free(evil_type_str); + free (evil_type_str); if (NULL != evil_subtype_str) - free(evil_subtype_str); + free (evil_subtype_str); } #endif @@ -1319,301 +1357,312 @@ cleanup: * task. */ static void -commit_set(struct ConsensusSession *session, - struct TaskEntry *task) +commit_set (struct ConsensusSession *session, + struct TaskEntry *task) { struct SetEntry *set; struct SetOpCls *setop = &task->cls.setop; - GNUNET_assert(NULL != setop->op); - set = lookup_set(session, &setop->input_set); - GNUNET_assert(NULL != set); + GNUNET_assert (NULL != setop->op); + set = lookup_set (session, &setop->input_set); + GNUNET_assert (NULL != set); - if ((GNUNET_YES == setop->transceive_contested) && (GNUNET_YES == set->is_contested)) - { - struct GNUNET_SET_Element element; - struct ConsensusElement ce = { 0 }; - ce.marker = CONSENSUS_MARKER_CONTESTED; - element.data = &ce; - element.size = sizeof(struct ConsensusElement); - element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT; - GNUNET_SET_add_element(set->h, &element, NULL, NULL); - } + if ((GNUNET_YES == setop->transceive_contested) && (GNUNET_YES == + set->is_contested)) + { + struct GNUNET_SET_Element element; + struct ConsensusElement ce = { 0 }; + ce.marker = CONSENSUS_MARKER_CONTESTED; + element.data = &ce; + element.size = sizeof(struct ConsensusElement); + element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT; + GNUNET_SET_add_element (set->h, &element, NULL, NULL); + } if (PHASE_KIND_ALL_TO_ALL_2 == task->key.kind) - { - struct GNUNET_SET_Element element; - struct ConsensusSizeElement cse = { - .size = 0, - .sender_index = 0 - }; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "inserting size marker\n"); - cse.ce.marker = CONSENSUS_MARKER_SIZE; - cse.size = GNUNET_htonll(session->first_size); - cse.sender_index = session->local_peer_idx; - element.data = &cse; - element.size = sizeof(struct ConsensusSizeElement); - element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT; - GNUNET_SET_add_element(set->h, &element, NULL, NULL); - } + { + struct GNUNET_SET_Element element; + struct ConsensusSizeElement cse = { + .size = 0, + .sender_index = 0 + }; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "inserting size marker\n"); + cse.ce.marker = CONSENSUS_MARKER_SIZE; + cse.size = GNUNET_htonll (session->first_size); + cse.sender_index = session->local_peer_idx; + element.data = &cse; + element.size = sizeof(struct ConsensusSizeElement); + element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT; + GNUNET_SET_add_element (set->h, &element, NULL, NULL); + } #ifdef EVIL { unsigned int i; struct Evilness evil; - get_evilness(session, &evil); + get_evilness (session, &evil); if (EVILNESS_NONE != evil.type) + { + /* Useful for evaluation */ + GNUNET_STATISTICS_set (statistics, + "is evil", + 1, + GNUNET_NO); + } + switch (evil.type) + { + case EVILNESS_CRAM_ALL: + case EVILNESS_CRAM_LEAD: + case EVILNESS_CRAM_ECHO: + /* We're not cramming elements in the + all-to-all round, since that would just + add more elements to the result set, but + wouldn't test robustness. */ + if (PHASE_KIND_ALL_TO_ALL == task->key.kind) { - /* Useful for evaluation */ - GNUNET_STATISTICS_set(statistics, - "is evil", - 1, - GNUNET_NO); + GNUNET_SET_commit (setop->op, set->h); + break; } - switch (evil.type) + if ((EVILNESS_CRAM_LEAD == evil.type) && + ((PHASE_KIND_GRADECAST_LEADER != task->key.kind) || + (SET_KIND_CURRENT != set->key.set_kind) )) + { + GNUNET_SET_commit (setop->op, set->h); + break; + } + if ((EVILNESS_CRAM_ECHO == evil.type) && (PHASE_KIND_GRADECAST_ECHO != + task->key.kind)) { - case EVILNESS_CRAM_ALL: - case EVILNESS_CRAM_LEAD: - case EVILNESS_CRAM_ECHO: - /* We're not cramming elements in the - all-to-all round, since that would just - add more elements to the result set, but - wouldn't test robustness. */ - if (PHASE_KIND_ALL_TO_ALL == task->key.kind) - { - GNUNET_SET_commit(setop->op, set->h); - break; - } - if ((EVILNESS_CRAM_LEAD == evil.type) && - ((PHASE_KIND_GRADECAST_LEADER != task->key.kind) || SET_KIND_CURRENT != set->key.set_kind)) - { - GNUNET_SET_commit(setop->op, set->h); - break; - } - if (EVILNESS_CRAM_ECHO == evil.type && (PHASE_KIND_GRADECAST_ECHO != task->key.kind)) - { - GNUNET_SET_commit(setop->op, set->h); - break; - } - for (i = 0; i < evil.num; i++) - { - struct GNUNET_SET_Element element; - struct ConsensusStuffedElement se = { - .ce.payload_type = 0, - .ce.marker = 0, - }; - element.data = &se; - element.size = sizeof(struct ConsensusStuffedElement); - element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT; - - if (EVILNESS_SUB_REPLACEMENT == evil.subtype) - { - /* Always generate a new element. */ - GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &se.rand); - } - else if (EVILNESS_SUB_NO_REPLACEMENT == evil.subtype) - { - /* Always cram the same elements, derived from counter. */ - GNUNET_CRYPTO_hash(&i, sizeof(i), &se.rand); - } - else - { - GNUNET_assert(0); - } - GNUNET_SET_add_element(set->h, &element, NULL, NULL); + GNUNET_SET_commit (setop->op, set->h); + break; + } + for (i = 0; i < evil.num; i++) + { + struct GNUNET_SET_Element element; + struct ConsensusStuffedElement se = { + .ce.payload_type = 0, + .ce.marker = 0, + }; + element.data = &se; + element.size = sizeof(struct ConsensusStuffedElement); + element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT; + + if (EVILNESS_SUB_REPLACEMENT == evil.subtype) + { + /* Always generate a new element. */ + GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, + &se.rand); + } + else if (EVILNESS_SUB_NO_REPLACEMENT == evil.subtype) + { + /* Always cram the same elements, derived from counter. */ + GNUNET_CRYPTO_hash (&i, sizeof(i), &se.rand); + } + else + { + GNUNET_assert (0); + } + GNUNET_SET_add_element (set->h, &element, NULL, NULL); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: evil peer: cramming element %s into set {%s} of task {%s}\n", - session->local_peer_idx, - debug_str_element(&element), - debug_str_set_key(&setop->input_set), - debug_str_task_key(&task->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: evil peer: cramming element %s into set {%s} of task {%s}\n", + session->local_peer_idx, + debug_str_element (&element), + debug_str_set_key (&setop->input_set), + debug_str_task_key (&task->key)); #endif - } - GNUNET_STATISTICS_update(statistics, - "# stuffed elements", - evil.num, - GNUNET_NO); - GNUNET_SET_commit(setop->op, set->h); - break; + } + GNUNET_STATISTICS_update (statistics, + "# stuffed elements", + evil.num, + GNUNET_NO); + GNUNET_SET_commit (setop->op, set->h); + break; - case EVILNESS_SLACK: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: evil peer: slacking\n", - (unsigned int)session->local_peer_idx); - - /* Do nothing. */ - case EVILNESS_SLACK_A2A: - if ((PHASE_KIND_ALL_TO_ALL_2 == task->key.kind) || - (PHASE_KIND_ALL_TO_ALL == task->key.kind)) - { - struct GNUNET_SET_Handle *empty_set; - empty_set = GNUNET_SET_create(cfg, GNUNET_SET_OPERATION_UNION); - GNUNET_SET_commit(setop->op, empty_set); - GNUNET_SET_destroy(empty_set); - } - else - { - GNUNET_SET_commit(setop->op, set->h); - } - break; + case EVILNESS_SLACK: + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: evil peer: slacking\n", + (unsigned int) session->local_peer_idx); - case EVILNESS_NONE: - GNUNET_SET_commit(setop->op, set->h); - break; + /* Do nothing. */ + case EVILNESS_SLACK_A2A: + if ((PHASE_KIND_ALL_TO_ALL_2 == task->key.kind) || + (PHASE_KIND_ALL_TO_ALL == task->key.kind)) + { + struct GNUNET_SET_Handle *empty_set; + empty_set = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION); + GNUNET_SET_commit (setop->op, empty_set); + GNUNET_SET_destroy (empty_set); } + else + { + GNUNET_SET_commit (setop->op, set->h); + } + break; + + case EVILNESS_NONE: + GNUNET_SET_commit (setop->op, set->h); + break; + } } #else - if (GNUNET_NO == session->peers_blacklisted[task_other_peer(task)]) - { - GNUNET_SET_commit(setop->op, set->h); - } + if (GNUNET_NO == session->peers_blacklisted[task_other_peer (task)]) + { + GNUNET_SET_commit (setop->op, set->h); + } else - { - /* For our testcases, we don't want the blacklisted - peers to wait. */ - GNUNET_SET_operation_cancel(setop->op); - setop->op = NULL; - finish_task(task); - } + { + /* For our testcases, we don't want the blacklisted + peers to wait. */ + GNUNET_SET_operation_cancel (setop->op); + setop->op = NULL; + finish_task (task); + } #endif } static void -put_diff(struct ConsensusSession *session, - struct DiffEntry *diff) +put_diff (struct ConsensusSession *session, + struct DiffEntry *diff) { struct GNUNET_HashCode hash; - GNUNET_assert(NULL != diff); + GNUNET_assert (NULL != diff); - GNUNET_CRYPTO_hash(&diff->key, sizeof(struct DiffKey), &hash); - GNUNET_assert(GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put(session->diffmap, &hash, diff, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + GNUNET_CRYPTO_hash (&diff->key, sizeof(struct DiffKey), &hash); + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multihashmap_put (session->diffmap, &hash, + diff, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); } static void -put_set(struct ConsensusSession *session, - struct SetEntry *set) +put_set (struct ConsensusSession *session, + struct SetEntry *set) { struct GNUNET_HashCode hash; - GNUNET_assert(NULL != set->h); + GNUNET_assert (NULL != set->h); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Putting set %s\n", - debug_str_set_key(&set->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Putting set %s\n", + debug_str_set_key (&set->key)); - GNUNET_CRYPTO_hash(&set->key, sizeof(struct SetKey), &hash); - GNUNET_assert(GNUNET_SYSERR != - GNUNET_CONTAINER_multihashmap_put(session->setmap, &hash, set, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE)); + GNUNET_CRYPTO_hash (&set->key, sizeof(struct SetKey), &hash); + GNUNET_assert (GNUNET_SYSERR != + GNUNET_CONTAINER_multihashmap_put (session->setmap, &hash, set, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE)); } static void -put_rfn(struct ConsensusSession *session, - struct ReferendumEntry *rfn) +put_rfn (struct ConsensusSession *session, + struct ReferendumEntry *rfn) { struct GNUNET_HashCode hash; - GNUNET_CRYPTO_hash(&rfn->key, sizeof(struct RfnKey), &hash); - GNUNET_assert(GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put(session->rfnmap, &hash, rfn, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + GNUNET_CRYPTO_hash (&rfn->key, sizeof(struct RfnKey), &hash); + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multihashmap_put (session->rfnmap, &hash, rfn, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); } static void -task_cancel_reconcile(struct TaskEntry *task) +task_cancel_reconcile (struct TaskEntry *task) { /* not implemented yet */ - GNUNET_assert(0); + GNUNET_assert (0); } static void -apply_diff_to_rfn(struct DiffEntry *diff, - struct ReferendumEntry *rfn, - uint16_t voting_peer, - uint16_t num_peers) +apply_diff_to_rfn (struct DiffEntry *diff, + struct ReferendumEntry *rfn, + uint16_t voting_peer, + uint16_t num_peers) { struct GNUNET_CONTAINER_MultiHashMapIterator *iter; struct DiffElementInfo *di; - iter = GNUNET_CONTAINER_multihashmap_iterator_create(diff->changes); + iter = GNUNET_CONTAINER_multihashmap_iterator_create (diff->changes); while (GNUNET_YES == - GNUNET_CONTAINER_multihashmap_iterator_next(iter, - NULL, - (const void **)&di)) + GNUNET_CONTAINER_multihashmap_iterator_next (iter, + NULL, + (const void **) &di)) + { + if (di->weight > 0) { - if (di->weight > 0) - { - rfn_vote(rfn, voting_peer, VOTE_ADD, di->element); - } - if (di->weight < 0) - { - rfn_vote(rfn, voting_peer, VOTE_REMOVE, di->element); - } + rfn_vote (rfn, voting_peer, VOTE_ADD, di->element); } + if (di->weight < 0) + { + rfn_vote (rfn, voting_peer, VOTE_REMOVE, di->element); + } + } - GNUNET_CONTAINER_multihashmap_iterator_destroy(iter); + GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); } struct DiffEntry * -diff_create() +diff_create () { - struct DiffEntry *d = GNUNET_new(struct DiffEntry); + struct DiffEntry *d = GNUNET_new (struct DiffEntry); - d->changes = GNUNET_CONTAINER_multihashmap_create(8, GNUNET_NO); + d->changes = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO); return d; } struct DiffEntry * -diff_compose(struct DiffEntry *diff_1, - struct DiffEntry *diff_2) +diff_compose (struct DiffEntry *diff_1, + struct DiffEntry *diff_2) { struct DiffEntry *diff_new; struct GNUNET_CONTAINER_MultiHashMapIterator *iter; struct DiffElementInfo *di; - diff_new = diff_create(); + diff_new = diff_create (); - iter = GNUNET_CONTAINER_multihashmap_iterator_create(diff_1->changes); - while (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, (const void **)&di)) - { - diff_insert(diff_new, di->weight, di->element); - } - GNUNET_CONTAINER_multihashmap_iterator_destroy(iter); + iter = GNUNET_CONTAINER_multihashmap_iterator_create (diff_1->changes); + while (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL, + (const + void **) & + di)) + { + diff_insert (diff_new, di->weight, di->element); + } + GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); - iter = GNUNET_CONTAINER_multihashmap_iterator_create(diff_2->changes); - while (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next(iter, NULL, (const void **)&di)) - { - diff_insert(diff_new, di->weight, di->element); - } - GNUNET_CONTAINER_multihashmap_iterator_destroy(iter); + iter = GNUNET_CONTAINER_multihashmap_iterator_create (diff_2->changes); + while (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter, NULL, + (const + void **) & + di)) + { + diff_insert (diff_new, di->weight, di->element); + } + GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); return diff_new; } struct ReferendumEntry * -rfn_create(uint16_t size) +rfn_create (uint16_t size) { struct ReferendumEntry *rfn; - rfn = GNUNET_new(struct ReferendumEntry); - rfn->rfn_elements = GNUNET_CONTAINER_multihashmap_create(8, GNUNET_NO); - rfn->peer_commited = GNUNET_new_array(size, int); - rfn->peer_contested = GNUNET_new_array(size, int); + rfn = GNUNET_new (struct ReferendumEntry); + rfn->rfn_elements = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO); + rfn->peer_commited = GNUNET_new_array (size, int); + rfn->peer_contested = GNUNET_new_array (size, int); rfn->num_peers = size; return rfn; @@ -1622,10 +1671,10 @@ rfn_create(uint16_t size) #if UNUSED static void -diff_destroy(struct DiffEntry *diff) +diff_destroy (struct DiffEntry *diff) { - GNUNET_CONTAINER_multihashmap_destroy(diff->changes); - GNUNET_free(diff); + GNUNET_CONTAINER_multihashmap_destroy (diff->changes); + GNUNET_free (diff); } #endif @@ -1636,70 +1685,71 @@ diff_destroy(struct DiffEntry *diff) * of peers that voted for this outcome. */ static void -rfn_majority(const struct ReferendumEntry *rfn, - const struct RfnElementInfo *ri, - uint16_t *ret_majority, - enum ReferendumVote *ret_vote) +rfn_majority (const struct ReferendumEntry *rfn, + const struct RfnElementInfo *ri, + uint16_t *ret_majority, + enum ReferendumVote *ret_vote) { uint16_t votes_yes = 0; uint16_t num_commited = 0; uint16_t i; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Computing rfn majority for element %s of rfn {%s}\n", - debug_str_element(ri->element), - debug_str_rfn_key(&rfn->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Computing rfn majority for element %s of rfn {%s}\n", + debug_str_element (ri->element), + debug_str_rfn_key (&rfn->key)); for (i = 0; i < rfn->num_peers; i++) - { - if (GNUNET_NO == rfn->peer_commited[i]) - continue; - num_commited++; + { + if (GNUNET_NO == rfn->peer_commited[i]) + continue; + num_commited++; - if (GNUNET_YES == ri->votes[i]) - votes_yes++; - } + if (GNUNET_YES == ri->votes[i]) + votes_yes++; + } if (votes_yes > (num_commited) / 2) - { - *ret_vote = ri->proposal; - *ret_majority = votes_yes; - } + { + *ret_vote = ri->proposal; + *ret_majority = votes_yes; + } else - { - *ret_vote = VOTE_STAY; - *ret_majority = num_commited - votes_yes; - } + { + *ret_vote = VOTE_STAY; + *ret_majority = num_commited - votes_yes; + } } -struct SetCopyCls { +struct SetCopyCls +{ struct TaskEntry *task; struct SetKey dst_set_key; }; static void -set_copy_cb(void *cls, struct GNUNET_SET_Handle *copy) +set_copy_cb (void *cls, struct GNUNET_SET_Handle *copy) { struct SetCopyCls *scc = cls; struct TaskEntry *task = scc->task; struct SetKey dst_set_key = scc->dst_set_key; struct SetEntry *set; - struct SetHandle *sh = GNUNET_new(struct SetHandle); + struct SetHandle *sh = GNUNET_new (struct SetHandle); sh->h = copy; - GNUNET_CONTAINER_DLL_insert(task->step->session->set_handles_head, - task->step->session->set_handles_tail, - sh); + GNUNET_CONTAINER_DLL_insert (task->step->session->set_handles_head, + task->step->session->set_handles_tail, + sh); - GNUNET_free(scc); - set = GNUNET_new(struct SetEntry); + GNUNET_free (scc); + set = GNUNET_new (struct SetEntry); set->h = copy; set->key = dst_set_key; - put_set(task->step->session, set); + put_set (task->step->session, set); - task->start(task); + task->start (task); } @@ -1708,30 +1758,31 @@ set_copy_cb(void *cls, struct GNUNET_SET_Handle *copy) * task again after we created a copy of the given set. */ static void -create_set_copy_for_task(struct TaskEntry *task, - struct SetKey *src_set_key, - struct SetKey *dst_set_key) +create_set_copy_for_task (struct TaskEntry *task, + struct SetKey *src_set_key, + struct SetKey *dst_set_key) { struct SetEntry *src_set; - struct SetCopyCls *scc = GNUNET_new(struct SetCopyCls); + struct SetCopyCls *scc = GNUNET_new (struct SetCopyCls); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Copying set {%s} to {%s} for task {%s}\n", - debug_str_set_key(src_set_key), - debug_str_set_key(dst_set_key), - debug_str_task_key(&task->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Copying set {%s} to {%s} for task {%s}\n", + debug_str_set_key (src_set_key), + debug_str_set_key (dst_set_key), + debug_str_task_key (&task->key)); scc->task = task; scc->dst_set_key = *dst_set_key; - src_set = lookup_set(task->step->session, src_set_key); - GNUNET_assert(NULL != src_set); - GNUNET_SET_copy_lazy(src_set->h, - set_copy_cb, - scc); + src_set = lookup_set (task->step->session, src_set_key); + GNUNET_assert (NULL != src_set); + GNUNET_SET_copy_lazy (src_set->h, + set_copy_cb, + scc); } -struct SetMutationProgressCls { +struct SetMutationProgressCls +{ int num_pending; /** * Task to finish once all changes are through. @@ -1741,25 +1792,25 @@ struct SetMutationProgressCls { static void -set_mutation_done(void *cls) +set_mutation_done (void *cls) { struct SetMutationProgressCls *pc = cls; - GNUNET_assert(pc->num_pending > 0); + GNUNET_assert (pc->num_pending > 0); pc->num_pending--; if (0 == pc->num_pending) - { - struct TaskEntry *task = pc->task; - GNUNET_free(pc); - finish_task(task); - } + { + struct TaskEntry *task = pc->task; + GNUNET_free (pc); + finish_task (task); + } } static void -try_finish_step_early(struct Step *step) +try_finish_step_early (struct Step *step) { unsigned int i; @@ -1773,61 +1824,61 @@ try_finish_step_early(struct Step *step) step->is_finished = GNUNET_YES; #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Finishing step `%s' early.\n", - step->debug_name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Finishing step `%s' early.\n", + step->debug_name); #endif for (i = 0; i < step->subordinates_len; i++) - { - GNUNET_assert(step->subordinates[i]->pending_prereq > 0); - step->subordinates[i]->pending_prereq--; + { + GNUNET_assert (step->subordinates[i]->pending_prereq > 0); + step->subordinates[i]->pending_prereq--; #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Decreased pending_prereq to %u for step `%s'.\n", - (unsigned int)step->subordinates[i]->pending_prereq, - step->subordinates[i]->debug_name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Decreased pending_prereq to %u for step `%s'.\n", + (unsigned int) step->subordinates[i]->pending_prereq, + step->subordinates[i]->debug_name); #endif - try_finish_step_early(step->subordinates[i]); - } + try_finish_step_early (step->subordinates[i]); + } // XXX: maybe schedule as task to avoid recursion? - run_ready_steps(step->session); + run_ready_steps (step->session); } static void -finish_step(struct Step *step) +finish_step (struct Step *step) { unsigned int i; - GNUNET_assert(step->finished_tasks == step->tasks_len); - GNUNET_assert(GNUNET_YES == step->is_running); - GNUNET_assert(GNUNET_NO == step->is_finished); + GNUNET_assert (step->finished_tasks == step->tasks_len); + GNUNET_assert (GNUNET_YES == step->is_running); + GNUNET_assert (GNUNET_NO == step->is_finished); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "All tasks of step `%s' with %u subordinates finished.\n", - step->debug_name, - step->subordinates_len); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "All tasks of step `%s' with %u subordinates finished.\n", + step->debug_name, + step->subordinates_len); #endif for (i = 0; i < step->subordinates_len; i++) - { - GNUNET_assert(step->subordinates[i]->pending_prereq > 0); - step->subordinates[i]->pending_prereq--; + { + GNUNET_assert (step->subordinates[i]->pending_prereq > 0); + step->subordinates[i]->pending_prereq--; #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Decreased pending_prereq to %u for step `%s'.\n", - (unsigned int)step->subordinates[i]->pending_prereq, - step->subordinates[i]->debug_name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Decreased pending_prereq to %u for step `%s'.\n", + (unsigned int) step->subordinates[i]->pending_prereq, + step->subordinates[i]->debug_name); #endif - } + } step->is_finished = GNUNET_YES; // XXX: maybe schedule as task to avoid recursion? - run_ready_steps(step->session); + run_ready_steps (step->session); } @@ -1839,7 +1890,7 @@ finish_step(struct Step *step) * @param task the task with context information */ static void -task_start_apply_round(struct TaskEntry *task) +task_start_apply_round (struct TaskEntry *task) { struct ConsensusSession *session = task->step->session; struct SetKey sk_in; @@ -1856,136 +1907,138 @@ task_start_apply_round(struct TaskEntry *task) rk_in = (struct RfnKey) { RFN_KIND_GRADECAST_RESULT, task->key.repetition }; sk_out = (struct SetKey) { SET_KIND_CURRENT, task->key.repetition + 1 }; - set_out = lookup_set(session, &sk_out); + set_out = lookup_set (session, &sk_out); if (NULL == set_out) - { - create_set_copy_for_task(task, &sk_in, &sk_out); - return; - } + { + create_set_copy_for_task (task, &sk_in, &sk_out); + return; + } - rfn_in = lookup_rfn(session, &rk_in); - GNUNET_assert(NULL != rfn_in); + rfn_in = lookup_rfn (session, &rk_in); + GNUNET_assert (NULL != rfn_in); - progress_cls = GNUNET_new(struct SetMutationProgressCls); + progress_cls = GNUNET_new (struct SetMutationProgressCls); progress_cls->task = task; - iter = GNUNET_CONTAINER_multihashmap_iterator_create(rfn_in->rfn_elements); + iter = GNUNET_CONTAINER_multihashmap_iterator_create (rfn_in->rfn_elements); while (GNUNET_YES == - GNUNET_CONTAINER_multihashmap_iterator_next(iter, - NULL, - (const void **)&ri)) - { - uint16_t majority_num; - enum ReferendumVote majority_vote; + GNUNET_CONTAINER_multihashmap_iterator_next (iter, + NULL, + (const void **) &ri)) + { + uint16_t majority_num; + enum ReferendumVote majority_vote; + + rfn_majority (rfn_in, ri, &majority_num, &majority_vote); + + if (worst_majority > majority_num) + worst_majority = majority_num; + + switch (majority_vote) + { + case VOTE_ADD: + progress_cls->num_pending++; + GNUNET_assert (GNUNET_OK == + GNUNET_SET_add_element (set_out->h, + ri->element, + &set_mutation_done, + progress_cls)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: apply round: adding element %s with %u-majority.\n", + session->local_peer_idx, + debug_str_element (ri->element), majority_num); + break; - rfn_majority(rfn_in, ri, &majority_num, &majority_vote); + case VOTE_REMOVE: + progress_cls->num_pending++; + GNUNET_assert (GNUNET_OK == + GNUNET_SET_remove_element (set_out->h, + ri->element, + &set_mutation_done, + progress_cls)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: apply round: deleting element %s with %u-majority.\n", + session->local_peer_idx, + debug_str_element (ri->element), majority_num); + break; - if (worst_majority > majority_num) - worst_majority = majority_num; + case VOTE_STAY: + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: apply round: keeping element %s with %u-majority.\n", + session->local_peer_idx, + debug_str_element (ri->element), majority_num); + // do nothing + break; - switch (majority_vote) - { - case VOTE_ADD: - progress_cls->num_pending++; - GNUNET_assert(GNUNET_OK == - GNUNET_SET_add_element(set_out->h, - ri->element, - &set_mutation_done, - progress_cls)); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: apply round: adding element %s with %u-majority.\n", - session->local_peer_idx, - debug_str_element(ri->element), majority_num); - break; - - case VOTE_REMOVE: - progress_cls->num_pending++; - GNUNET_assert(GNUNET_OK == - GNUNET_SET_remove_element(set_out->h, - ri->element, - &set_mutation_done, - progress_cls)); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: apply round: deleting element %s with %u-majority.\n", - session->local_peer_idx, - debug_str_element(ri->element), majority_num); - break; - - case VOTE_STAY: - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: apply round: keeping element %s with %u-majority.\n", - session->local_peer_idx, - debug_str_element(ri->element), majority_num); - // do nothing - break; - - default: - GNUNET_assert(0); - break; - } + default: + GNUNET_assert (0); + break; } + } if (0 == progress_cls->num_pending) - { - // call closure right now, no pending ops - GNUNET_free(progress_cls); - finish_task(task); - } + { + // call closure right now, no pending ops + GNUNET_free (progress_cls); + finish_task (task); + } { uint16_t thresh = (session->num_peers / 3) * 2; if (worst_majority >= thresh) + { + switch (session->early_stopping) { - switch (session->early_stopping) - { - case EARLY_STOPPING_NONE: - session->early_stopping = EARLY_STOPPING_ONE_MORE; - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "P%u: Stopping early (after one more superround)\n", - session->local_peer_idx); - break; - - case EARLY_STOPPING_ONE_MORE: - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "P%u: finishing steps due to early finish\n", - session->local_peer_idx); - session->early_stopping = EARLY_STOPPING_DONE; - { - struct Step *step; - for (step = session->steps_head; NULL != step; step = step->next) - try_finish_step_early(step); - } - break; - - case EARLY_STOPPING_DONE: - /* We shouldn't be here anymore after early stopping */ - GNUNET_break(0); - break; - - default: - GNUNET_assert(0); - break; - } + case EARLY_STOPPING_NONE: + session->early_stopping = EARLY_STOPPING_ONE_MORE; + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "P%u: Stopping early (after one more superround)\n", + session->local_peer_idx); + break; + + case EARLY_STOPPING_ONE_MORE: + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "P%u: finishing steps due to early finish\n", + session->local_peer_idx); + session->early_stopping = EARLY_STOPPING_DONE; + { + struct Step *step; + for (step = session->steps_head; NULL != step; step = step->next) + try_finish_step_early (step); + } + break; + + case EARLY_STOPPING_DONE: + /* We shouldn't be here anymore after early stopping */ + GNUNET_break (0); + break; + + default: + GNUNET_assert (0); + break; } + } else if (EARLY_STOPPING_NONE != session->early_stopping) - { - // Our assumption about the number of bad peers - // has been broken. - GNUNET_break_op(0); - } + { + // Our assumption about the number of bad peers + // has been broken. + GNUNET_break_op (0); + } else - { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "P%u: NOT finishing early (majority not good enough)\n", - session->local_peer_idx); - } + { + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "P%u: NOT finishing early (majority not good enough)\n", + session->local_peer_idx); + } } - GNUNET_CONTAINER_multihashmap_iterator_destroy(iter); + GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); } static void -task_start_grade(struct TaskEntry *task) +task_start_grade (struct TaskEntry *task) { struct ConsensusSession *session = task->step->session; struct ReferendumEntry *output_rfn; @@ -1998,93 +2051,97 @@ task_start_grade(struct TaskEntry *task) unsigned int gradecast_confidence = 2; rfn_key = (struct RfnKey) { RFN_KIND_GRADECAST_RESULT, task->key.repetition }; - output_rfn = lookup_rfn(session, &rfn_key); + output_rfn = lookup_rfn (session, &rfn_key); if (NULL == output_rfn) - { - output_rfn = rfn_create(session->num_peers); - output_rfn->key = rfn_key; - put_rfn(session, output_rfn); - } + { + output_rfn = rfn_create (session->num_peers); + output_rfn->key = rfn_key; + put_rfn (session, output_rfn); + } - diff_key = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL, task->key.repetition, task->key.leader }; - input_diff = lookup_diff(session, &diff_key); - GNUNET_assert(NULL != input_diff); + diff_key = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL, task->key.repetition, + task->key.leader }; + input_diff = lookup_diff (session, &diff_key); + GNUNET_assert (NULL != input_diff); - rfn_key = (struct RfnKey) { RFN_KIND_ECHO, task->key.repetition, task->key.leader }; - input_rfn = lookup_rfn(session, &rfn_key); - GNUNET_assert(NULL != input_rfn); + rfn_key = (struct RfnKey) { RFN_KIND_ECHO, task->key.repetition, + task->key.leader }; + input_rfn = lookup_rfn (session, &rfn_key); + GNUNET_assert (NULL != input_rfn); - iter = GNUNET_CONTAINER_multihashmap_iterator_create(input_rfn->rfn_elements); + iter = GNUNET_CONTAINER_multihashmap_iterator_create ( + input_rfn->rfn_elements); - apply_diff_to_rfn(input_diff, output_rfn, task->key.leader, session->num_peers); + apply_diff_to_rfn (input_diff, output_rfn, task->key.leader, + session->num_peers); while (GNUNET_YES == - GNUNET_CONTAINER_multihashmap_iterator_next(iter, - NULL, - (const void **)&ri)) - { - uint16_t majority_num; - enum ReferendumVote majority_vote; + GNUNET_CONTAINER_multihashmap_iterator_next (iter, + NULL, + (const void **) &ri)) + { + uint16_t majority_num; + enum ReferendumVote majority_vote; - // XXX: we need contested votes and non-contested votes here - rfn_majority(input_rfn, ri, &majority_num, &majority_vote); + // XXX: we need contested votes and non-contested votes here + rfn_majority (input_rfn, ri, &majority_num, &majority_vote); - if (majority_num <= session->num_peers / 3) - majority_vote = VOTE_REMOVE; + if (majority_num <= session->num_peers / 3) + majority_vote = VOTE_REMOVE; - switch (majority_vote) - { - case VOTE_STAY: - break; + switch (majority_vote) + { + case VOTE_STAY: + break; - case VOTE_ADD: - rfn_vote(output_rfn, task->key.leader, VOTE_ADD, ri->element); - break; + case VOTE_ADD: + rfn_vote (output_rfn, task->key.leader, VOTE_ADD, ri->element); + break; - case VOTE_REMOVE: - rfn_vote(output_rfn, task->key.leader, VOTE_REMOVE, ri->element); - break; + case VOTE_REMOVE: + rfn_vote (output_rfn, task->key.leader, VOTE_REMOVE, ri->element); + break; - default: - GNUNET_assert(0); - break; - } + default: + GNUNET_assert (0); + break; } - GNUNET_CONTAINER_multihashmap_iterator_destroy(iter); + } + GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); { uint16_t noncontested; - noncontested = rfn_noncontested(input_rfn); + noncontested = rfn_noncontested (input_rfn); if (noncontested < (session->num_peers / 3) * 2) - { - gradecast_confidence = GNUNET_MIN(1, gradecast_confidence); - } + { + gradecast_confidence = GNUNET_MIN (1, gradecast_confidence); + } if (noncontested < (session->num_peers / 3) + 1) - { - gradecast_confidence = 0; - } + { + gradecast_confidence = 0; + } } if (gradecast_confidence >= 1) - rfn_commit(output_rfn, task->key.leader); + rfn_commit (output_rfn, task->key.leader); if (gradecast_confidence <= 1) session->peers_blacklisted[task->key.leader] = GNUNET_YES; - finish_task(task); + finish_task (task); } static void -task_start_reconcile(struct TaskEntry *task) +task_start_reconcile (struct TaskEntry *task) { struct SetEntry *input; struct SetOpCls *setop = &task->cls.setop; struct ConsensusSession *session = task->step->session; - input = lookup_set(session, &setop->input_set); - GNUNET_assert(NULL != input); - GNUNET_assert(NULL != input->h); + input = lookup_set (session, &setop->input_set); + GNUNET_assert (NULL != input); + GNUNET_assert (NULL != input->h); /* We create the outputs for the operation here (rather than in the set operation callback) @@ -2092,113 +2149,117 @@ task_start_reconcile(struct TaskEntry *task) if the other peer doesn't talk to us */ if (SET_KIND_NONE != setop->output_set.set_kind) + { + /* If we don't have an existing output set, + we clone the input set. */ + if (NULL == lookup_set (session, &setop->output_set)) { - /* If we don't have an existing output set, - we clone the input set. */ - if (NULL == lookup_set(session, &setop->output_set)) - { - create_set_copy_for_task(task, &setop->input_set, &setop->output_set); - return; - } + create_set_copy_for_task (task, &setop->input_set, &setop->output_set); + return; } + } if (RFN_KIND_NONE != setop->output_rfn.rfn_kind) + { + if (NULL == lookup_rfn (session, &setop->output_rfn)) { - if (NULL == lookup_rfn(session, &setop->output_rfn)) - { - struct ReferendumEntry *rfn; + struct ReferendumEntry *rfn; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: output rfn <%s> missing, creating.\n", - session->local_peer_idx, - debug_str_rfn_key(&setop->output_rfn)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: output rfn <%s> missing, creating.\n", + session->local_peer_idx, + debug_str_rfn_key (&setop->output_rfn)); - rfn = rfn_create(session->num_peers); - rfn->key = setop->output_rfn; - put_rfn(session, rfn); - } + rfn = rfn_create (session->num_peers); + rfn->key = setop->output_rfn; + put_rfn (session, rfn); } + } if (DIFF_KIND_NONE != setop->output_diff.diff_kind) + { + if (NULL == lookup_diff (session, &setop->output_diff)) { - if (NULL == lookup_diff(session, &setop->output_diff)) - { - struct DiffEntry *diff; + struct DiffEntry *diff; - diff = diff_create(); - diff->key = setop->output_diff; - put_diff(session, diff); - } + diff = diff_create (); + diff->key = setop->output_diff; + put_diff (session, diff); } + } - if ((task->key.peer1 == session->local_peer_idx) && (task->key.peer2 == session->local_peer_idx)) - { - /* XXX: mark the corresponding rfn as commited if necessary */ - finish_task(task); - return; - } + if ((task->key.peer1 == session->local_peer_idx) && (task->key.peer2 == + session->local_peer_idx)) + { + /* XXX: mark the corresponding rfn as commited if necessary */ + finish_task (task); + return; + } if (task->key.peer1 == session->local_peer_idx) - { - struct GNUNET_CONSENSUS_RoundContextMessage rcm; - - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: Looking up set {%s} to run remote union\n", - session->local_peer_idx, - debug_str_set_key(&setop->input_set)); - - rcm.header.type = htons(GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT); - rcm.header.size = htons(sizeof(struct GNUNET_CONSENSUS_RoundContextMessage)); - - rcm.kind = htons(task->key.kind); - rcm.peer1 = htons(task->key.peer1); - rcm.peer2 = htons(task->key.peer2); - rcm.leader = htons(task->key.leader); - rcm.repetition = htons(task->key.repetition); - rcm.is_contested = htons(0); - - GNUNET_assert(NULL == setop->op); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "P%u: initiating set op with P%u, our set is %s\n", - session->local_peer_idx, task->key.peer2, debug_str_set_key(&setop->input_set)); - - struct GNUNET_SET_Option opts[] = { - { GNUNET_SET_OPTION_BYZANTINE, { .num = session->lower_bound } }, - { GNUNET_SET_OPTION_END }, - }; - - // XXX: maybe this should be done while - // setting up tasks alreays? - setop->op = GNUNET_SET_prepare(&session->peers[task->key.peer2], - &session->global_id, - &rcm.header, - GNUNET_SET_RESULT_SYMMETRIC, - opts, - set_result_cb, - task); - - commit_set(session, task); - } + { + struct GNUNET_CONSENSUS_RoundContextMessage rcm; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: Looking up set {%s} to run remote union\n", + session->local_peer_idx, + debug_str_set_key (&setop->input_set)); + + rcm.header.type = htons (GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT); + rcm.header.size = htons (sizeof(struct + GNUNET_CONSENSUS_RoundContextMessage)); + + rcm.kind = htons (task->key.kind); + rcm.peer1 = htons (task->key.peer1); + rcm.peer2 = htons (task->key.peer2); + rcm.leader = htons (task->key.leader); + rcm.repetition = htons (task->key.repetition); + rcm.is_contested = htons (0); + + GNUNET_assert (NULL == setop->op); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: initiating set op with P%u, our set is %s\n", + session->local_peer_idx, task->key.peer2, debug_str_set_key ( + &setop->input_set)); + + struct GNUNET_SET_Option opts[] = { + { GNUNET_SET_OPTION_BYZANTINE, { .num = session->lower_bound } }, + { GNUNET_SET_OPTION_END }, + }; + + // XXX: maybe this should be done while + // setting up tasks alreays? + setop->op = GNUNET_SET_prepare (&session->peers[task->key.peer2], + &session->global_id, + &rcm.header, + GNUNET_SET_RESULT_SYMMETRIC, + opts, + set_result_cb, + task); + + commit_set (session, task); + } else if (task->key.peer2 == session->local_peer_idx) - { - /* Wait for the other peer to contact us */ - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "P%u: waiting set op with P%u\n", - session->local_peer_idx, task->key.peer1); + { + /* Wait for the other peer to contact us */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: waiting set op with P%u\n", + session->local_peer_idx, task->key.peer1); - if (NULL != setop->op) - { - commit_set(session, task); - } - } - else + if (NULL != setop->op) { - /* We made an error while constructing the task graph. */ - GNUNET_assert(0); + commit_set (session, task); } + } + else + { + /* We made an error while constructing the task graph. */ + GNUNET_assert (0); + } } static void -task_start_eval_echo(struct TaskEntry *task) +task_start_eval_echo (struct TaskEntry *task) { struct GNUNET_CONTAINER_MultiHashMapIterator *iter; struct ReferendumEntry *input_rfn; @@ -2210,128 +2271,133 @@ task_start_eval_echo(struct TaskEntry *task) struct SetKey sk_out; struct RfnKey rk_in; - sk_in = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, task->key.repetition, task->key.leader }; - sk_out = (struct SetKey) { SET_KIND_ECHO_RESULT, task->key.repetition, task->key.leader }; - output_set = lookup_set(session, &sk_out); + sk_in = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, task->key.repetition, + task->key.leader }; + sk_out = (struct SetKey) { SET_KIND_ECHO_RESULT, task->key.repetition, + task->key.leader }; + output_set = lookup_set (session, &sk_out); if (NULL == output_set) - { - create_set_copy_for_task(task, &sk_in, &sk_out); - return; - } + { + create_set_copy_for_task (task, &sk_in, &sk_out); + return; + } { // FIXME: should be marked as a shallow copy, so // we can destroy everything correctly - struct SetEntry *last_set = GNUNET_new(struct SetEntry); + struct SetEntry *last_set = GNUNET_new (struct SetEntry); last_set->h = output_set->h; last_set->key = (struct SetKey) { SET_KIND_LAST_GRADECAST }; - put_set(session, last_set); + put_set (session, last_set); } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Evaluating referendum in Task {%s}\n", - debug_str_task_key(&task->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Evaluating referendum in Task {%s}\n", + debug_str_task_key (&task->key)); - progress_cls = GNUNET_new(struct SetMutationProgressCls); + progress_cls = GNUNET_new (struct SetMutationProgressCls); progress_cls->task = task; - rk_in = (struct RfnKey) { RFN_KIND_ECHO, task->key.repetition, task->key.leader }; - input_rfn = lookup_rfn(session, &rk_in); + rk_in = (struct RfnKey) { RFN_KIND_ECHO, task->key.repetition, + task->key.leader }; + input_rfn = lookup_rfn (session, &rk_in); - GNUNET_assert(NULL != input_rfn); + GNUNET_assert (NULL != input_rfn); - iter = GNUNET_CONTAINER_multihashmap_iterator_create(input_rfn->rfn_elements); - GNUNET_assert(NULL != iter); + iter = GNUNET_CONTAINER_multihashmap_iterator_create ( + input_rfn->rfn_elements); + GNUNET_assert (NULL != iter); while (GNUNET_YES == - GNUNET_CONTAINER_multihashmap_iterator_next(iter, - NULL, - (const void **)&ri)) + GNUNET_CONTAINER_multihashmap_iterator_next (iter, + NULL, + (const void **) &ri)) + { + enum ReferendumVote majority_vote; + uint16_t majority_num; + + rfn_majority (input_rfn, ri, &majority_num, &majority_vote); + + if (majority_num < session->num_peers / 3) { - enum ReferendumVote majority_vote; - uint16_t majority_num; + /* It is not the case that all nonfaulty peers + echoed the same value. Since we're doing a set reconciliation, we + can't simply send "nothing" for the value. Thus we mark our 'confirm' + reconciliation as contested. Other peers might not know that the + leader is faulty, thus we still re-distribute in the confirmation + round. */ + output_set->is_contested = GNUNET_YES; + } - rfn_majority(input_rfn, ri, &majority_num, &majority_vote); + switch (majority_vote) + { + case VOTE_ADD: + progress_cls->num_pending++; + GNUNET_assert (GNUNET_OK == + GNUNET_SET_add_element (output_set->h, + ri->element, + set_mutation_done, + progress_cls)); + break; - if (majority_num < session->num_peers / 3) - { - /* It is not the case that all nonfaulty peers - echoed the same value. Since we're doing a set reconciliation, we - can't simply send "nothing" for the value. Thus we mark our 'confirm' - reconciliation as contested. Other peers might not know that the - leader is faulty, thus we still re-distribute in the confirmation - round. */ - output_set->is_contested = GNUNET_YES; - } + case VOTE_REMOVE: + progress_cls->num_pending++; + GNUNET_assert (GNUNET_OK == + GNUNET_SET_remove_element (output_set->h, + ri->element, + set_mutation_done, + progress_cls)); + break; - switch (majority_vote) - { - case VOTE_ADD: - progress_cls->num_pending++; - GNUNET_assert(GNUNET_OK == - GNUNET_SET_add_element(output_set->h, - ri->element, - set_mutation_done, - progress_cls)); - break; - - case VOTE_REMOVE: - progress_cls->num_pending++; - GNUNET_assert(GNUNET_OK == - GNUNET_SET_remove_element(output_set->h, - ri->element, - set_mutation_done, - progress_cls)); - break; - - case VOTE_STAY: - /* Nothing to do. */ - break; - - default: - /* not reached */ - GNUNET_assert(0); - } + case VOTE_STAY: + /* Nothing to do. */ + break; + + default: + /* not reached */ + GNUNET_assert (0); } + } - GNUNET_CONTAINER_multihashmap_iterator_destroy(iter); + GNUNET_CONTAINER_multihashmap_iterator_destroy (iter); if (0 == progress_cls->num_pending) - { - // call closure right now, no pending ops - GNUNET_free(progress_cls); - finish_task(task); - } + { + // call closure right now, no pending ops + GNUNET_free (progress_cls); + finish_task (task); + } } static void -task_start_finish(struct TaskEntry *task) +task_start_finish (struct TaskEntry *task) { struct SetEntry *final_set; struct ConsensusSession *session = task->step->session; - final_set = lookup_set(session, &task->cls.finish.input_set); + final_set = lookup_set (session, &task->cls.finish.input_set); - GNUNET_assert(NULL != final_set); + GNUNET_assert (NULL != final_set); - GNUNET_SET_iterate(final_set->h, - send_to_client_iter, - task); + GNUNET_SET_iterate (final_set->h, + send_to_client_iter, + task); } static void -start_task(struct ConsensusSession *session, struct TaskEntry *task) +start_task (struct ConsensusSession *session, struct TaskEntry *task) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "P%u: starting task {%s}\n", session->local_peer_idx, debug_str_task_key(&task->key)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: starting task {%s}\n", + session->local_peer_idx, debug_str_task_key (&task->key)); - GNUNET_assert(GNUNET_NO == task->is_started); - GNUNET_assert(GNUNET_NO == task->is_finished); - GNUNET_assert(NULL != task->start); + GNUNET_assert (GNUNET_NO == task->is_started); + GNUNET_assert (GNUNET_NO == task->is_finished); + GNUNET_assert (NULL != task->start); - task->start(task); + task->start (task); task->is_started = GNUNET_YES; } @@ -2344,40 +2410,43 @@ start_task(struct ConsensusSession *session, struct TaskEntry *task) * more dependencies. */ static void -run_ready_steps(struct ConsensusSession *session) +run_ready_steps (struct ConsensusSession *session) { struct Step *step; step = session->steps_head; while (NULL != step) + { + if ((GNUNET_NO == step->is_running) && (0 == step->pending_prereq) && + (GNUNET_NO == step->is_finished)) { - if ((GNUNET_NO == step->is_running) && (0 == step->pending_prereq) && (GNUNET_NO == step->is_finished)) - { - size_t i; + size_t i; - GNUNET_assert(0 == step->finished_tasks); + GNUNET_assert (0 == step->finished_tasks); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "P%u: Running step `%s' of round %d with %d tasks and %d subordinates\n", - session->local_peer_idx, - step->debug_name, - step->round, step->tasks_len, step->subordinates_len); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: Running step `%s' of round %d with %d tasks and %d subordinates\n", + session->local_peer_idx, + step->debug_name, + step->round, step->tasks_len, step->subordinates_len); #endif - step->is_running = GNUNET_YES; - for (i = 0; i < step->tasks_len; i++) - start_task(session, step->tasks[i]); + step->is_running = GNUNET_YES; + for (i = 0; i < step->tasks_len; i++) + start_task (session, step->tasks[i]); - /* Sometimes there is no task to trigger finishing the step, so we have to do it here. */ - if ((step->finished_tasks == step->tasks_len) && (GNUNET_NO == step->is_finished)) - finish_step(step); + /* Sometimes there is no task to trigger finishing the step, so we have to do it here. */ + if ((step->finished_tasks == step->tasks_len) && (GNUNET_NO == + step->is_finished)) + finish_step (step); - /* Running the next ready steps will be triggered by task completion */ - return; - } - step = step->next; + /* Running the next ready steps will be triggered by task completion */ + return; } + step = step->next; + } return; } @@ -2385,22 +2454,22 @@ run_ready_steps(struct ConsensusSession *session) static void -finish_task(struct TaskEntry *task) +finish_task (struct TaskEntry *task) { - GNUNET_assert(GNUNET_NO == task->is_finished); + GNUNET_assert (GNUNET_NO == task->is_finished); task->is_finished = GNUNET_YES; task->step->finished_tasks++; - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "P%u: Finishing Task {%s} (now %u/%u tasks finished in step)\n", - task->step->session->local_peer_idx, - debug_str_task_key(&task->key), - (unsigned int)task->step->finished_tasks, - (unsigned int)task->step->tasks_len); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "P%u: Finishing Task {%s} (now %u/%u tasks finished in step)\n", + task->step->session->local_peer_idx, + debug_str_task_key (&task->key), + (unsigned int) task->step->finished_tasks, + (unsigned int) task->step->tasks_len); if (task->step->finished_tasks == task->step->tasks_len) - finish_step(task->step); + finish_step (task->step); } @@ -2412,12 +2481,13 @@ finish_task(struct TaskEntry *task) * @return index of peer, -1 if peer is not in session */ static int -get_peer_idx(const struct GNUNET_PeerIdentity *peer, const struct ConsensusSession *session) +get_peer_idx (const struct GNUNET_PeerIdentity *peer, const struct + ConsensusSession *session) { int i; for (i = 0; i < session->num_peers; i++) - if (0 == GNUNET_memcmp(peer, &session->peers[i])) + if (0 == GNUNET_memcmp (peer, &session->peers[i])) return i; return -1; } @@ -2433,21 +2503,22 @@ get_peer_idx(const struct GNUNET_PeerIdentity *peer, const struct ConsensusSessi * @param local_session_id local id of the consensus session */ static void -compute_global_id(struct ConsensusSession *session, - const struct GNUNET_HashCode *local_session_id) +compute_global_id (struct ConsensusSession *session, + const struct GNUNET_HashCode *local_session_id) { const char *salt = "gnunet-service-consensus/session_id"; - GNUNET_assert(GNUNET_YES == - GNUNET_CRYPTO_kdf(&session->global_id, - sizeof(struct GNUNET_HashCode), - salt, - strlen(salt), - session->peers, - session->num_peers * sizeof(struct GNUNET_PeerIdentity), - local_session_id, - sizeof(struct GNUNET_HashCode), - NULL)); + GNUNET_assert (GNUNET_YES == + GNUNET_CRYPTO_kdf (&session->global_id, + sizeof(struct GNUNET_HashCode), + salt, + strlen (salt), + session->peers, + session->num_peers * sizeof(struct + GNUNET_PeerIdentity), + local_session_id, + sizeof(struct GNUNET_HashCode), + NULL)); } @@ -2459,9 +2530,9 @@ compute_global_id(struct ConsensusSession *session, * @return 1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2. */ static int -peer_id_cmp(const void *h1, const void *h2) +peer_id_cmp (const void *h1, const void *h2) { - return memcmp(h1, h2, sizeof(struct GNUNET_PeerIdentity)); + return memcmp (h1, h2, sizeof(struct GNUNET_PeerIdentity)); } @@ -2473,56 +2544,58 @@ peer_id_cmp(const void *h1, const void *h2) * @param join_msg join message with the list of peers participating at the end */ static void -initialize_session_peer_list(struct ConsensusSession *session, - const struct GNUNET_CONSENSUS_JoinMessage *join_msg) +initialize_session_peer_list (struct ConsensusSession *session, + const struct + GNUNET_CONSENSUS_JoinMessage *join_msg) { const struct GNUNET_PeerIdentity *msg_peers - = (const struct GNUNET_PeerIdentity *)&join_msg[1]; + = (const struct GNUNET_PeerIdentity *) &join_msg[1]; int local_peer_in_list; - session->num_peers = ntohl(join_msg->num_peers); + session->num_peers = ntohl (join_msg->num_peers); /* Peers in the join message, may or may not include the local peer, Add it if it is missing. */ local_peer_in_list = GNUNET_NO; for (unsigned int i = 0; i < session->num_peers; i++) + { + if (0 == GNUNET_memcmp (&msg_peers[i], + &my_peer)) { - if (0 == GNUNET_memcmp(&msg_peers[i], - &my_peer)) - { - local_peer_in_list = GNUNET_YES; - break; - } + local_peer_in_list = GNUNET_YES; + break; } + } if (GNUNET_NO == local_peer_in_list) session->num_peers++; - session->peers = GNUNET_new_array(session->num_peers, - struct GNUNET_PeerIdentity); + session->peers = GNUNET_new_array (session->num_peers, + struct GNUNET_PeerIdentity); if (GNUNET_NO == local_peer_in_list) session->peers[session->num_peers - 1] = my_peer; - GNUNET_memcpy(session->peers, - msg_peers, - ntohl(join_msg->num_peers) * sizeof(struct GNUNET_PeerIdentity)); - qsort(session->peers, - session->num_peers, - sizeof(struct GNUNET_PeerIdentity), - &peer_id_cmp); + GNUNET_memcpy (session->peers, + msg_peers, + ntohl (join_msg->num_peers) * sizeof(struct + GNUNET_PeerIdentity)); + qsort (session->peers, + session->num_peers, + sizeof(struct GNUNET_PeerIdentity), + &peer_id_cmp); } static struct TaskEntry * -lookup_task(struct ConsensusSession *session, - struct TaskKey *key) +lookup_task (struct ConsensusSession *session, + struct TaskKey *key) { struct GNUNET_HashCode hash; - GNUNET_CRYPTO_hash(key, sizeof(struct TaskKey), &hash); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Looking up task hash %s\n", - GNUNET_h2s(&hash)); - return GNUNET_CONTAINER_multihashmap_get(session->taskmap, &hash); + GNUNET_CRYPTO_hash (key, sizeof(struct TaskKey), &hash); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking up task hash %s\n", + GNUNET_h2s (&hash)); + return GNUNET_CONTAINER_multihashmap_get (session->taskmap, &hash); } @@ -2542,10 +2615,10 @@ lookup_task(struct ConsensusSession *session, * Also necessary to specify the timeout. */ static void -set_listen_cb(void *cls, - const struct GNUNET_PeerIdentity *other_peer, - const struct GNUNET_MessageHeader *context_msg, - struct GNUNET_SET_Request *request) +set_listen_cb (void *cls, + const struct GNUNET_PeerIdentity *other_peer, + const struct GNUNET_MessageHeader *context_msg, + struct GNUNET_SET_Request *request) { struct ConsensusSession *session = cls; struct TaskKey tk; @@ -2553,122 +2626,124 @@ set_listen_cb(void *cls, struct GNUNET_CONSENSUS_RoundContextMessage *cm; if (NULL == context_msg) - { - GNUNET_break_op(0); - return; - } + { + GNUNET_break_op (0); + return; + } - if (GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT != ntohs(context_msg->type)) - { - GNUNET_break_op(0); - return; - } + if (GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT != ntohs ( + context_msg->type)) + { + GNUNET_break_op (0); + return; + } - if (sizeof(struct GNUNET_CONSENSUS_RoundContextMessage) != ntohs(context_msg->size)) - { - GNUNET_break_op(0); - return; - } + if (sizeof(struct GNUNET_CONSENSUS_RoundContextMessage) != ntohs ( + context_msg->size)) + { + GNUNET_break_op (0); + return; + } - cm = (struct GNUNET_CONSENSUS_RoundContextMessage *)context_msg; + cm = (struct GNUNET_CONSENSUS_RoundContextMessage *) context_msg; tk = ((struct TaskKey) { - .kind = ntohs(cm->kind), - .peer1 = ntohs(cm->peer1), - .peer2 = ntohs(cm->peer2), - .repetition = ntohs(cm->repetition), - .leader = ntohs(cm->leader), + .kind = ntohs (cm->kind), + .peer1 = ntohs (cm->peer1), + .peer2 = ntohs (cm->peer2), + .repetition = ntohs (cm->repetition), + .leader = ntohs (cm->leader), }); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "P%u: got req for task %s\n", - session->local_peer_idx, debug_str_task_key(&tk)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: got req for task %s\n", + session->local_peer_idx, debug_str_task_key (&tk)); - task = lookup_task(session, &tk); + task = lookup_task (session, &tk); if (NULL == task) - { - GNUNET_break_op(0); - return; - } + { + GNUNET_break_op (0); + return; + } if (GNUNET_YES == task->is_finished) - { - GNUNET_break_op(0); - return; - } + { + GNUNET_break_op (0); + return; + } if (task->key.peer2 != session->local_peer_idx) - { - /* We're being asked, so we must be thne 2nd peer. */ - GNUNET_break_op(0); - return; - } + { + /* We're being asked, so we must be thne 2nd peer. */ + GNUNET_break_op (0); + return; + } - GNUNET_assert(!((task->key.peer1 == session->local_peer_idx) && - (task->key.peer2 == session->local_peer_idx))); + GNUNET_assert (! ((task->key.peer1 == session->local_peer_idx) && + (task->key.peer2 == session->local_peer_idx))); struct GNUNET_SET_Option opts[] = { { GNUNET_SET_OPTION_BYZANTINE, { .num = session->lower_bound } }, { GNUNET_SET_OPTION_END }, }; - task->cls.setop.op = GNUNET_SET_accept(request, - GNUNET_SET_RESULT_SYMMETRIC, - opts, - set_result_cb, - task); + task->cls.setop.op = GNUNET_SET_accept (request, + GNUNET_SET_RESULT_SYMMETRIC, + opts, + set_result_cb, + task); /* If the task hasn't been started yet, we wait for that until we commit. */ if (GNUNET_YES == task->is_started) - { - commit_set(session, task); - } + { + commit_set (session, task); + } } static void -put_task(struct GNUNET_CONTAINER_MultiHashMap *taskmap, - struct TaskEntry *t) +put_task (struct GNUNET_CONTAINER_MultiHashMap *taskmap, + struct TaskEntry *t) { struct GNUNET_HashCode round_hash; struct Step *s; - GNUNET_assert(NULL != t->step); + GNUNET_assert (NULL != t->step); - t = GNUNET_memdup(t, sizeof(struct TaskEntry)); + t = GNUNET_memdup (t, sizeof(struct TaskEntry)); s = t->step; if (s->tasks_len == s->tasks_cap) - { - unsigned int target_size = 3 * (s->tasks_cap + 1) / 2; - GNUNET_array_grow(s->tasks, - s->tasks_cap, - target_size); - } + { + unsigned int target_size = 3 * (s->tasks_cap + 1) / 2; + GNUNET_array_grow (s->tasks, + s->tasks_cap, + target_size); + } #ifdef GNUNET_EXTRA_LOGGING - GNUNET_assert(NULL != s->debug_name); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Putting task <%s> into step `%s'\n", - debug_str_task_key(&t->key), - s->debug_name); + GNUNET_assert (NULL != s->debug_name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Putting task <%s> into step `%s'\n", + debug_str_task_key (&t->key), + s->debug_name); #endif s->tasks[s->tasks_len] = t; s->tasks_len++; - GNUNET_CRYPTO_hash(&t->key, sizeof(struct TaskKey), &round_hash); - GNUNET_assert(GNUNET_OK == - GNUNET_CONTAINER_multihashmap_put(taskmap, &round_hash, t, - GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); + GNUNET_CRYPTO_hash (&t->key, sizeof(struct TaskKey), &round_hash); + GNUNET_assert (GNUNET_OK == + GNUNET_CONTAINER_multihashmap_put (taskmap, &round_hash, t, + GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); } static void -install_step_timeouts(struct ConsensusSession *session) +install_step_timeouts (struct ConsensusSession *session) { /* Given the fully constructed task graph with rounds for tasks, we can give the tasks timeouts. */ @@ -2684,37 +2759,37 @@ install_step_timeouts(struct ConsensusSession *session) * Arrange two peers in some canonical order. */ static void -arrange_peers(uint16_t *p1, uint16_t *p2, uint16_t n) +arrange_peers (uint16_t *p1, uint16_t *p2, uint16_t n) { uint16_t a; uint16_t b; - GNUNET_assert(*p1 < n); - GNUNET_assert(*p2 < n); + GNUNET_assert (*p1 < n); + GNUNET_assert (*p2 < n); if (*p1 < *p2) - { - a = *p1; - b = *p2; - } + { + a = *p1; + b = *p2; + } else - { - a = *p2; - b = *p1; - } + { + a = *p2; + b = *p1; + } /* For uniformly random *p1, *p2, this condition is true with 50% chance */ if (((b - a) + n) % n <= n / 2) - { - *p1 = a; - *p2 = b; - } + { + *p1 = a; + *p2 = b; + } else - { - *p1 = b; - *p2 = a; - } + { + *p1 = b; + *p2 = a; + } } @@ -2722,36 +2797,36 @@ arrange_peers(uint16_t *p1, uint16_t *p2, uint16_t n) * Record @a dep as a dependency of @a step. */ static void -step_depend_on(struct Step *step, struct Step *dep) +step_depend_on (struct Step *step, struct Step *dep) { /* We're not checking for cyclic dependencies, but this is a cheap sanity check. */ - GNUNET_assert(step != dep); - GNUNET_assert(NULL != step); - GNUNET_assert(NULL != dep); - GNUNET_assert(dep->round <= step->round); + GNUNET_assert (step != dep); + GNUNET_assert (NULL != step); + GNUNET_assert (NULL != dep); + GNUNET_assert (dep->round <= step->round); #ifdef GNUNET_EXTRA_LOGGING /* Make sure we have complete debugging information. Also checks that we don't screw up too badly constructing the task graph. */ - GNUNET_assert(NULL != step->debug_name); - GNUNET_assert(NULL != dep->debug_name); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Making step `%s' depend on `%s'\n", - step->debug_name, - dep->debug_name); + GNUNET_assert (NULL != step->debug_name); + GNUNET_assert (NULL != dep->debug_name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Making step `%s' depend on `%s'\n", + step->debug_name, + dep->debug_name); #endif if (dep->subordinates_cap == dep->subordinates_len) - { - unsigned int target_size = 3 * (dep->subordinates_cap + 1) / 2; - GNUNET_array_grow(dep->subordinates, - dep->subordinates_cap, - target_size); - } + { + unsigned int target_size = 3 * (dep->subordinates_cap + 1) / 2; + GNUNET_array_grow (dep->subordinates, + dep->subordinates_cap, + target_size); + } - GNUNET_assert(dep->subordinates_len <= dep->subordinates_cap); + GNUNET_assert (dep->subordinates_len <= dep->subordinates_cap); dep->subordinates[dep->subordinates_len] = step; dep->subordinates_len++; @@ -2761,17 +2836,17 @@ step_depend_on(struct Step *step, struct Step *dep) static struct Step * -create_step(struct ConsensusSession *session, int round, int early_finishable) +create_step (struct ConsensusSession *session, int round, int early_finishable) { struct Step *step; - step = GNUNET_new(struct Step); + step = GNUNET_new (struct Step); step->session = session; step->round = round; step->early_finishable = early_finishable; - GNUNET_CONTAINER_DLL_insert_tail(session->steps_head, - session->steps_tail, - step); + GNUNET_CONTAINER_DLL_insert_tail (session->steps_head, + session->steps_tail, + step); return step; } @@ -2781,11 +2856,11 @@ create_step(struct ConsensusSession *session, int round, int early_finishable) * gradecast. */ static void -construct_task_graph_gradecast(struct ConsensusSession *session, - uint16_t rep, - uint16_t lead, - struct Step *step_before, - struct Step *step_after) +construct_task_graph_gradecast (struct ConsensusSession *session, + uint16_t rep, + uint16_t lead, + struct Step *step_before, + struct Step *step_after) { uint16_t n = session->num_peers; uint16_t me = session->local_peer_idx; @@ -2807,155 +2882,168 @@ construct_task_graph_gradecast(struct ConsensusSession *session, /* gcast step 1: leader disseminates */ - step = create_step(session, round, GNUNET_YES); + step = create_step (session, round, GNUNET_YES); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_asprintf(&step->debug_name, "disseminate leader %u rep %u", lead, rep); + GNUNET_asprintf (&step->debug_name, "disseminate leader %u rep %u", lead, + rep); #endif - step_depend_on(step, step_before); + step_depend_on (step, step_before); if (lead == me) + { + for (k = 0; k < n; k++) { - for (k = 0; k < n; k++) - { - if (k == me) - continue; - p1 = me; - p2 = k; - arrange_peers(&p1, &p2, n); - task = ((struct TaskEntry) { + if (k == me) + continue; + p1 = me; + p2 = k; + arrange_peers (&p1, &p2, n); + task = ((struct TaskEntry) { .step = step, .start = task_start_reconcile, .cancel = task_cancel_reconcile, - .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, p1, p2, rep, me }, + .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, p1, p2, rep, + me }, }); - task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep }; - put_task(session->taskmap, &task); - } - /* We run this task to make sure that the leader - has the stored the SET_KIND_LEADER set of himself, - so it can participate in the rest of the gradecast - without the code having to handle any special cases. */ - task = ((struct TaskEntry) { + task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep }; + put_task (session->taskmap, &task); + } + /* We run this task to make sure that the leader + has the stored the SET_KIND_LEADER set of himself, + so it can participate in the rest of the gradecast + without the code having to handle any special cases. */ + task = ((struct TaskEntry) { .step = step, .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, me, me, rep, me }, .start = task_start_reconcile, .cancel = task_cancel_reconcile, }); - task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep }; - task.cls.setop.output_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep, me }; - task.cls.setop.output_diff = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL, rep, me }; - put_task(session->taskmap, &task); - } + task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep }; + task.cls.setop.output_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep, + me }; + task.cls.setop.output_diff = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL, + rep, me }; + put_task (session->taskmap, &task); + } else - { - p1 = me; - p2 = lead; - arrange_peers(&p1, &p2, n); - task = ((struct TaskEntry) { + { + p1 = me; + p2 = lead; + arrange_peers (&p1, &p2, n); + task = ((struct TaskEntry) { .step = step, - .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, p1, p2, rep, lead }, + .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, p1, p2, rep, + lead }, .start = task_start_reconcile, .cancel = task_cancel_reconcile, }); - task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep }; - task.cls.setop.output_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep, lead }; - task.cls.setop.output_diff = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL, rep, lead }; - put_task(session->taskmap, &task); - } + task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep }; + task.cls.setop.output_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep, + lead }; + task.cls.setop.output_diff = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL, + rep, lead }; + put_task (session->taskmap, &task); + } /* gcast phase 2: echo */ prev_step = step; round += 1; - step = create_step(session, round, GNUNET_YES); + step = create_step (session, round, GNUNET_YES); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_asprintf(&step->debug_name, "echo leader %u rep %u", lead, rep); + GNUNET_asprintf (&step->debug_name, "echo leader %u rep %u", lead, rep); #endif - step_depend_on(step, prev_step); + step_depend_on (step, prev_step); for (k = 0; k < n; k++) - { - p1 = k; - p2 = me; - arrange_peers(&p1, &p2, n); - task = ((struct TaskEntry) { + { + p1 = k; + p2 = me; + arrange_peers (&p1, &p2, n); + task = ((struct TaskEntry) { .step = step, .key = (struct TaskKey) { PHASE_KIND_GRADECAST_ECHO, p1, p2, rep, lead }, .start = task_start_reconcile, .cancel = task_cancel_reconcile, }); - task.cls.setop.input_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep, lead }; - task.cls.setop.output_rfn = (struct RfnKey) { RFN_KIND_ECHO, rep, lead }; - put_task(session->taskmap, &task); - } + task.cls.setop.input_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep, + lead }; + task.cls.setop.output_rfn = (struct RfnKey) { RFN_KIND_ECHO, rep, lead }; + put_task (session->taskmap, &task); + } prev_step = step; /* Same round, since step only has local tasks */ - step = create_step(session, round, GNUNET_YES); + step = create_step (session, round, GNUNET_YES); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_asprintf(&step->debug_name, "echo grade leader %u rep %u", lead, rep); + GNUNET_asprintf (&step->debug_name, "echo grade leader %u rep %u", lead, rep); #endif - step_depend_on(step, prev_step); + step_depend_on (step, prev_step); - arrange_peers(&p1, &p2, n); + arrange_peers (&p1, &p2, n); task = ((struct TaskEntry) { - .key = (struct TaskKey) { PHASE_KIND_GRADECAST_ECHO_GRADE, -1, -1, rep, lead }, + .key = (struct TaskKey) { PHASE_KIND_GRADECAST_ECHO_GRADE, -1, -1, rep, + lead }, .step = step, .start = task_start_eval_echo }); - put_task(session->taskmap, &task); + put_task (session->taskmap, &task); prev_step = step; round += 1; - step = create_step(session, round, GNUNET_YES); + step = create_step (session, round, GNUNET_YES); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_asprintf(&step->debug_name, "confirm leader %u rep %u", lead, rep); + GNUNET_asprintf (&step->debug_name, "confirm leader %u rep %u", lead, rep); #endif - step_depend_on(step, prev_step); + step_depend_on (step, prev_step); /* gcast phase 3: confirmation and grading */ for (k = 0; k < n; k++) - { - p1 = k; - p2 = me; - arrange_peers(&p1, &p2, n); - task = ((struct TaskEntry) { + { + p1 = k; + p2 = me; + arrange_peers (&p1, &p2, n); + task = ((struct TaskEntry) { .step = step, .start = task_start_reconcile, .cancel = task_cancel_reconcile, - .key = (struct TaskKey) { PHASE_KIND_GRADECAST_CONFIRM, p1, p2, rep, lead }, + .key = (struct TaskKey) { PHASE_KIND_GRADECAST_CONFIRM, p1, p2, rep, + lead }, }); - task.cls.setop.input_set = (struct SetKey) { SET_KIND_ECHO_RESULT, rep, lead }; - task.cls.setop.output_rfn = (struct RfnKey) { RFN_KIND_CONFIRM, rep, lead }; - /* If there was at least one element in the echo round that was - contested (i.e. it had no n-t majority), then we let the other peers - know, and other peers let us know. The contested flag for each peer is - stored in the rfn. */ - task.cls.setop.transceive_contested = GNUNET_YES; - put_task(session->taskmap, &task); - } + task.cls.setop.input_set = (struct SetKey) { SET_KIND_ECHO_RESULT, rep, + lead }; + task.cls.setop.output_rfn = (struct RfnKey) { RFN_KIND_CONFIRM, rep, lead }; + /* If there was at least one element in the echo round that was + contested (i.e. it had no n-t majority), then we let the other peers + know, and other peers let us know. The contested flag for each peer is + stored in the rfn. */ + task.cls.setop.transceive_contested = GNUNET_YES; + put_task (session->taskmap, &task); + } prev_step = step; /* Same round, since step only has local tasks */ - step = create_step(session, round, GNUNET_YES); + step = create_step (session, round, GNUNET_YES); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_asprintf(&step->debug_name, "confirm grade leader %u rep %u", lead, rep); + GNUNET_asprintf (&step->debug_name, "confirm grade leader %u rep %u", lead, + rep); #endif - step_depend_on(step, prev_step); + step_depend_on (step, prev_step); task = ((struct TaskEntry) { .step = step, - .key = (struct TaskKey) { PHASE_KIND_GRADECAST_CONFIRM_GRADE, -1, -1, rep, lead }, + .key = (struct TaskKey) { PHASE_KIND_GRADECAST_CONFIRM_GRADE, -1, -1, rep, + lead }, .start = task_start_grade, }); - put_task(session->taskmap, &task); + put_task (session->taskmap, &task); - step_depend_on(step_after, step); + step_depend_on (step_after, step); } static void -construct_task_graph(struct ConsensusSession *session) +construct_task_graph (struct ConsensusSession *session) { uint16_t n = session->num_peers; uint16_t t = n / 3; @@ -2985,60 +3073,60 @@ construct_task_graph(struct ConsensusSession *session) /* all-to-all step */ - step = create_step(session, round, GNUNET_NO); + step = create_step (session, round, GNUNET_NO); #ifdef GNUNET_EXTRA_LOGGING - step->debug_name = GNUNET_strdup("all to all"); + step->debug_name = GNUNET_strdup ("all to all"); #endif for (i = 0; i < n; i++) - { - uint16_t p1; - uint16_t p2; + { + uint16_t p1; + uint16_t p2; - p1 = me; - p2 = i; - arrange_peers(&p1, &p2, n); - task = ((struct TaskEntry) { + p1 = me; + p2 = i; + arrange_peers (&p1, &p2, n); + task = ((struct TaskEntry) { .key = (struct TaskKey) { PHASE_KIND_ALL_TO_ALL, p1, p2, -1, -1 }, .step = step, .start = task_start_reconcile, .cancel = task_cancel_reconcile, }); - task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, 0 }; - task.cls.setop.output_set = task.cls.setop.input_set; - task.cls.setop.do_not_remove = GNUNET_YES; - put_task(session->taskmap, &task); - } + task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, 0 }; + task.cls.setop.output_set = task.cls.setop.input_set; + task.cls.setop.do_not_remove = GNUNET_YES; + put_task (session->taskmap, &task); + } round += 1; prev_step = step; - step = create_step(session, round, GNUNET_NO);; + step = create_step (session, round, GNUNET_NO);; #ifdef GNUNET_EXTRA_LOGGING - step->debug_name = GNUNET_strdup("all to all 2"); + step->debug_name = GNUNET_strdup ("all to all 2"); #endif - step_depend_on(step, prev_step); + step_depend_on (step, prev_step); for (i = 0; i < n; i++) - { - uint16_t p1; - uint16_t p2; + { + uint16_t p1; + uint16_t p2; - p1 = me; - p2 = i; - arrange_peers(&p1, &p2, n); - task = ((struct TaskEntry) { + p1 = me; + p2 = i; + arrange_peers (&p1, &p2, n); + task = ((struct TaskEntry) { .key = (struct TaskKey) { PHASE_KIND_ALL_TO_ALL_2, p1, p2, -1, -1 }, .step = step, .start = task_start_reconcile, .cancel = task_cancel_reconcile, }); - task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, 0 }; - task.cls.setop.output_set = task.cls.setop.input_set; - task.cls.setop.do_not_remove = GNUNET_YES; - put_task(session->taskmap, &task); - } + task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, 0 }; + task.cls.setop.output_set = task.cls.setop.input_set; + task.cls.setop.do_not_remove = GNUNET_YES; + put_task (session->taskmap, &task); + } round += 1; @@ -3051,47 +3139,48 @@ construct_task_graph(struct ConsensusSession *session) /* sequential repetitions of the gradecasts */ for (i = 0; i < t + 1; i++) - { - struct Step *step_rep_start; - struct Step *step_rep_end; + { + struct Step *step_rep_start; + struct Step *step_rep_end; - /* Every repetition is in a separate round. */ - step_rep_start = create_step(session, round, GNUNET_YES); + /* Every repetition is in a separate round. */ + step_rep_start = create_step (session, round, GNUNET_YES); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_asprintf(&step_rep_start->debug_name, "gradecast start rep %u", i); + GNUNET_asprintf (&step_rep_start->debug_name, "gradecast start rep %u", i); #endif - step_depend_on(step_rep_start, prev_step); + step_depend_on (step_rep_start, prev_step); - /* gradecast has three rounds */ - round += 3; - step_rep_end = create_step(session, round, GNUNET_YES); + /* gradecast has three rounds */ + round += 3; + step_rep_end = create_step (session, round, GNUNET_YES); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_asprintf(&step_rep_end->debug_name, "gradecast end rep %u", i); + GNUNET_asprintf (&step_rep_end->debug_name, "gradecast end rep %u", i); #endif - /* parallel gradecasts */ - for (lead = 0; lead < n; lead++) - construct_task_graph_gradecast(session, i, lead, step_rep_start, step_rep_end); + /* parallel gradecasts */ + for (lead = 0; lead < n; lead++) + construct_task_graph_gradecast (session, i, lead, step_rep_start, + step_rep_end); - task = ((struct TaskEntry) { + task = ((struct TaskEntry) { .step = step_rep_end, .key = (struct TaskKey) { PHASE_KIND_APPLY_REP, -1, -1, i, -1 }, .start = task_start_apply_round, }); - put_task(session->taskmap, &task); + put_task (session->taskmap, &task); - prev_step = step_rep_end; - } + prev_step = step_rep_end; + } /* There is no next gradecast round, thus the final start step is the overall end step of the gradecasts */ round += 1; - step = create_step(session, round, GNUNET_NO); + step = create_step (session, round, GNUNET_NO); #ifdef GNUNET_EXTRA_LOGGING - GNUNET_asprintf(&step->debug_name, "finish"); + GNUNET_asprintf (&step->debug_name, "finish"); #endif - step_depend_on(step, prev_step); + step_depend_on (step, prev_step); task = ((struct TaskEntry) { .step = step, @@ -3100,7 +3189,7 @@ construct_task_graph(struct ConsensusSession *session) }); task.cls.finish.input_set = (struct SetKey) { SET_KIND_LAST_GRADECAST }; - put_task(session->taskmap, &task); + put_task (session->taskmap, &task); } @@ -3113,17 +3202,17 @@ construct_task_graph(struct ConsensusSession *session) * @return #GNUNET_OK if @a m is well-formed */ static int -check_client_join(void *cls, - const struct GNUNET_CONSENSUS_JoinMessage *m) +check_client_join (void *cls, + const struct GNUNET_CONSENSUS_JoinMessage *m) { - uint32_t listed_peers = ntohl(m->num_peers); + uint32_t listed_peers = ntohl (m->num_peers); - if ((ntohs(m->header.size) - sizeof(*m)) != + if ((ntohs (m->header.size) - sizeof(*m)) != listed_peers * sizeof(struct GNUNET_PeerIdentity)) - { - GNUNET_break(0); - return GNUNET_SYSERR; - } + { + GNUNET_break (0); + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -3135,16 +3224,16 @@ check_client_join(void *cls, * @param m message sent by the client */ static void -handle_client_join(void *cls, - const struct GNUNET_CONSENSUS_JoinMessage *m) +handle_client_join (void *cls, + const struct GNUNET_CONSENSUS_JoinMessage *m) { struct ConsensusSession *session = cls; struct ConsensusSession *other_session; - initialize_session_peer_list(session, - m); - compute_global_id(session, - &m->session_id); + initialize_session_peer_list (session, + m); + compute_global_id (session, + &m->session_id); /* Check if some local client already owns the session. It is only legal to have a session with an existing global id @@ -3152,75 +3241,75 @@ handle_client_join(void *cls, for (other_session = sessions_head; NULL != other_session; other_session = other_session->next) - { - if ((other_session != session) && - (0 == GNUNET_CRYPTO_hash_cmp(&session->global_id, - &other_session->global_id))) - break; - } + { + if ((other_session != session) && + (0 == GNUNET_CRYPTO_hash_cmp (&session->global_id, + &other_session->global_id))) + break; + } session->conclude_deadline - = GNUNET_TIME_absolute_ntoh(m->deadline); + = GNUNET_TIME_absolute_ntoh (m->deadline); session->conclude_start - = GNUNET_TIME_absolute_ntoh(m->start); - session->local_peer_idx = get_peer_idx(&my_peer, - session); - GNUNET_assert(-1 != session->local_peer_idx); - - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Joining consensus session %s containing %u peers as %u with timeout %s\n", - GNUNET_h2s(&m->session_id), - session->num_peers, - session->local_peer_idx, - GNUNET_STRINGS_relative_time_to_string - (GNUNET_TIME_absolute_get_difference(session->conclude_start, - session->conclude_deadline), - GNUNET_YES)); + = GNUNET_TIME_absolute_ntoh (m->start); + session->local_peer_idx = get_peer_idx (&my_peer, + session); + GNUNET_assert (-1 != session->local_peer_idx); + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Joining consensus session %s containing %u peers as %u with timeout %s\n", + GNUNET_h2s (&m->session_id), + session->num_peers, + session->local_peer_idx, + GNUNET_STRINGS_relative_time_to_string + (GNUNET_TIME_absolute_get_difference (session->conclude_start, + session->conclude_deadline), + GNUNET_YES)); session->set_listener - = GNUNET_SET_listen(cfg, - GNUNET_SET_OPERATION_UNION, - &session->global_id, - &set_listen_cb, - session); - - session->setmap = GNUNET_CONTAINER_multihashmap_create(1, - GNUNET_NO); - session->taskmap = GNUNET_CONTAINER_multihashmap_create(1, + = GNUNET_SET_listen (cfg, + GNUNET_SET_OPERATION_UNION, + &session->global_id, + &set_listen_cb, + session); + + session->setmap = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO); - session->diffmap = GNUNET_CONTAINER_multihashmap_create(1, + session->taskmap = GNUNET_CONTAINER_multihashmap_create (1, + GNUNET_NO); + session->diffmap = GNUNET_CONTAINER_multihashmap_create (1, + GNUNET_NO); + session->rfnmap = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO); - session->rfnmap = GNUNET_CONTAINER_multihashmap_create(1, - GNUNET_NO); { struct SetEntry *client_set; - client_set = GNUNET_new(struct SetEntry); - client_set->h = GNUNET_SET_create(cfg, - GNUNET_SET_OPERATION_UNION); - struct SetHandle *sh = GNUNET_new(struct SetHandle); + client_set = GNUNET_new (struct SetEntry); + client_set->h = GNUNET_SET_create (cfg, + GNUNET_SET_OPERATION_UNION); + struct SetHandle *sh = GNUNET_new (struct SetHandle); sh->h = client_set->h; - GNUNET_CONTAINER_DLL_insert(session->set_handles_head, - session->set_handles_tail, - sh); + GNUNET_CONTAINER_DLL_insert (session->set_handles_head, + session->set_handles_tail, + sh); client_set->key = ((struct SetKey) { SET_KIND_CURRENT, 0, 0 }); - put_set(session, - client_set); + put_set (session, + client_set); } - session->peers_blacklisted = GNUNET_new_array(session->num_peers, - int); + session->peers_blacklisted = GNUNET_new_array (session->num_peers, + int); /* Just construct the task graph, but don't run anything until the client calls conclude. */ - construct_task_graph(session); - GNUNET_SERVICE_client_continue(session->client); + construct_task_graph (session); + GNUNET_SERVICE_client_continue (session->client); } static void -client_insert_done(void *cls) +client_insert_done (void *cls) { // FIXME: implement } @@ -3234,8 +3323,8 @@ client_insert_done(void *cls) * @return #GNUNET_OK (always well-formed) */ static int -check_client_insert(void *cls, - const struct GNUNET_CONSENSUS_ElementMessage *msg) +check_client_insert (void *cls, + const struct GNUNET_CONSENSUS_ElementMessage *msg) { return GNUNET_OK; } @@ -3248,8 +3337,8 @@ check_client_insert(void *cls, * @param msg message sent by the client */ static void -handle_client_insert(void *cls, - const struct GNUNET_CONSENSUS_ElementMessage *msg) +handle_client_insert (void *cls, + const struct GNUNET_CONSENSUS_ElementMessage *msg) { struct ConsensusSession *session = cls; ssize_t element_size; @@ -3257,15 +3346,16 @@ handle_client_insert(void *cls, struct ConsensusElement *ce; if (GNUNET_YES == session->conclude_started) - { - GNUNET_break(0); - GNUNET_SERVICE_client_drop(session->client); - return; - } + { + GNUNET_break (0); + GNUNET_SERVICE_client_drop (session->client); + return; + } - element_size = ntohs(msg->header.size) - sizeof(struct GNUNET_CONSENSUS_ElementMessage); - ce = GNUNET_malloc(sizeof(struct ConsensusElement) + element_size); - GNUNET_memcpy(&ce[1], &msg[1], element_size); + element_size = ntohs (msg->header.size) - sizeof(struct + GNUNET_CONSENSUS_ElementMessage); + ce = GNUNET_malloc (sizeof(struct ConsensusElement) + element_size); + GNUNET_memcpy (&ce[1], &msg[1], element_size); ce->payload_type = msg->element_type; struct GNUNET_SET_Element element = { @@ -3278,28 +3368,28 @@ handle_client_insert(void *cls, struct SetKey key = { SET_KIND_CURRENT, 0, 0 }; struct SetEntry *entry; - entry = lookup_set(session, - &key); - GNUNET_assert(NULL != entry); + entry = lookup_set (session, + &key); + GNUNET_assert (NULL != entry); initial_set = entry->h; } session->num_client_insert_pending++; - GNUNET_SET_add_element(initial_set, - &element, - &client_insert_done, - session); + GNUNET_SET_add_element (initial_set, + &element, + &client_insert_done, + session); #ifdef GNUNET_EXTRA_LOGGING { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "P%u: element %s added\n", - session->local_peer_idx, - debug_str_element(&element)); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "P%u: element %s added\n", + session->local_peer_idx, + debug_str_element (&element)); } #endif - GNUNET_free(ce); - GNUNET_SERVICE_client_continue(session->client); + GNUNET_free (ce); + GNUNET_SERVICE_client_continue (session->client); } @@ -3310,24 +3400,24 @@ handle_client_insert(void *cls, * @param message message sent by the client */ static void -handle_client_conclude(void *cls, - const struct GNUNET_MessageHeader *message) +handle_client_conclude (void *cls, + const struct GNUNET_MessageHeader *message) { struct ConsensusSession *session = cls; if (GNUNET_YES == session->conclude_started) - { - /* conclude started twice */ - GNUNET_break(0); - GNUNET_SERVICE_client_drop(session->client); - return; - } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "conclude requested\n"); + { + /* conclude started twice */ + GNUNET_break (0); + GNUNET_SERVICE_client_drop (session->client); + return; + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "conclude requested\n"); session->conclude_started = GNUNET_YES; - install_step_timeouts(session); - run_ready_steps(session); - GNUNET_SERVICE_client_continue(session->client); + install_step_timeouts (session); + run_ready_steps (session); + GNUNET_SERVICE_client_continue (session->client); } @@ -3337,12 +3427,12 @@ handle_client_conclude(void *cls, * @param cls closure */ static void -shutdown_task(void *cls) +shutdown_task (void *cls) { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, - "shutting down\n"); - GNUNET_STATISTICS_destroy(statistics, - GNUNET_NO); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, + "shutting down\n"); + GNUNET_STATISTICS_destroy (statistics, + GNUNET_NO); statistics = NULL; } @@ -3355,24 +3445,24 @@ shutdown_task(void *cls) * @param service the initialized service */ static void -run(void *cls, - const struct GNUNET_CONFIGURATION_Handle *c, - struct GNUNET_SERVICE_Handle *service) +run (void *cls, + const struct GNUNET_CONFIGURATION_Handle *c, + struct GNUNET_SERVICE_Handle *service) { cfg = c; if (GNUNET_OK != - GNUNET_CRYPTO_get_peer_identity(cfg, - &my_peer)) - { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Could not retrieve host identity\n"); - GNUNET_SCHEDULER_shutdown(); - return; - } - statistics = GNUNET_STATISTICS_create("consensus", - cfg); - GNUNET_SCHEDULER_add_shutdown(&shutdown_task, - NULL); + GNUNET_CRYPTO_get_peer_identity (cfg, + &my_peer)) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Could not retrieve host identity\n"); + GNUNET_SCHEDULER_shutdown (); + return; + } + statistics = GNUNET_STATISTICS_create ("consensus", + cfg); + GNUNET_SCHEDULER_add_shutdown (&shutdown_task, + NULL); } @@ -3385,17 +3475,17 @@ run(void *cls, * @return @a c */ static void * -client_connect_cb(void *cls, - struct GNUNET_SERVICE_Client *c, - struct GNUNET_MQ_Handle *mq) +client_connect_cb (void *cls, + struct GNUNET_SERVICE_Client *c, + struct GNUNET_MQ_Handle *mq) { - struct ConsensusSession *session = GNUNET_new(struct ConsensusSession); + struct ConsensusSession *session = GNUNET_new (struct ConsensusSession); session->client = c; session->client_mq = mq; - GNUNET_CONTAINER_DLL_insert(sessions_head, - sessions_tail, - session); + GNUNET_CONTAINER_DLL_insert (sessions_head, + sessions_tail, + session); return session; } @@ -3408,29 +3498,29 @@ client_connect_cb(void *cls, * @param internal_cls should be equal to @a c */ static void -client_disconnect_cb(void *cls, - struct GNUNET_SERVICE_Client *c, - void *internal_cls) +client_disconnect_cb (void *cls, + struct GNUNET_SERVICE_Client *c, + void *internal_cls) { struct ConsensusSession *session = internal_cls; if (NULL != session->set_listener) - { - GNUNET_SET_listen_cancel(session->set_listener); - session->set_listener = NULL; - } - GNUNET_CONTAINER_DLL_remove(sessions_head, - sessions_tail, - session); + { + GNUNET_SET_listen_cancel (session->set_listener); + session->set_listener = NULL; + } + GNUNET_CONTAINER_DLL_remove (sessions_head, + sessions_tail, + session); while (session->set_handles_head) - { - struct SetHandle *sh = session->set_handles_head; - session->set_handles_head = sh->next; - GNUNET_SET_destroy(sh->h); - GNUNET_free(sh); - } - GNUNET_free(session); + { + struct SetHandle *sh = session->set_handles_head; + session->set_handles_head = sh->next; + GNUNET_SET_destroy (sh->h); + GNUNET_free (sh); + } + GNUNET_free (session); } @@ -3444,18 +3534,18 @@ GNUNET_SERVICE_MAIN &client_connect_cb, &client_disconnect_cb, NULL, - GNUNET_MQ_hd_fixed_size(client_conclude, - GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE, - struct GNUNET_MessageHeader, - NULL), - GNUNET_MQ_hd_var_size(client_insert, - GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT, - struct GNUNET_CONSENSUS_ElementMessage, - NULL), - GNUNET_MQ_hd_var_size(client_join, - GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN, - struct GNUNET_CONSENSUS_JoinMessage, - NULL), - GNUNET_MQ_handler_end()); + GNUNET_MQ_hd_fixed_size (client_conclude, + GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE, + struct GNUNET_MessageHeader, + NULL), + GNUNET_MQ_hd_var_size (client_insert, + GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT, + struct GNUNET_CONSENSUS_ElementMessage, + NULL), + GNUNET_MQ_hd_var_size (client_join, + GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN, + struct GNUNET_CONSENSUS_JoinMessage, + NULL), + GNUNET_MQ_handler_end ()); /* end of gnunet-service-consensus.c */ diff --git a/src/consensus/plugin_block_consensus.c b/src/consensus/plugin_block_consensus.c index a90b451d2..1caf4fc39 100644 --- a/src/consensus/plugin_block_consensus.c +++ b/src/consensus/plugin_block_consensus.c @@ -47,16 +47,16 @@ * @return characterization of result */ static enum GNUNET_BLOCK_EvaluationResult -block_plugin_consensus_evaluate(void *cls, - struct GNUNET_BLOCK_Context *ctx, - enum GNUNET_BLOCK_Type type, - struct GNUNET_BLOCK_Group *group, - enum GNUNET_BLOCK_EvaluationOptions eo, - const struct GNUNET_HashCode *query, - const void *xquery, - size_t xquery_size, - const void *reply_block, - size_t reply_block_size) +block_plugin_consensus_evaluate (void *cls, + struct GNUNET_BLOCK_Context *ctx, + enum GNUNET_BLOCK_Type type, + struct GNUNET_BLOCK_Group *group, + enum GNUNET_BLOCK_EvaluationOptions eo, + const struct GNUNET_HashCode *query, + const void *xquery, + size_t xquery_size, + const void *reply_block, + size_t reply_block_size) { if (reply_block_size < sizeof(struct ConsensusElement)) return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; @@ -67,15 +67,16 @@ block_plugin_consensus_evaluate(void *cls, (0 == ce->payload_type)) return GNUNET_BLOCK_EVALUATION_OK_MORE; - return GNUNET_BLOCK_evaluate(ctx, - type, - group, - eo, - query, - xquery, - xquery_size, - &ce[1], - reply_block_size - sizeof(struct ConsensusElement)); + return GNUNET_BLOCK_evaluate (ctx, + type, + group, + eo, + query, + xquery, + xquery_size, + &ce[1], + reply_block_size - sizeof(struct + ConsensusElement)); } @@ -91,11 +92,11 @@ block_plugin_consensus_evaluate(void *cls, * (or if extracting a key from a block of this type does not work) */ static int -block_plugin_consensus_get_key(void *cls, - enum GNUNET_BLOCK_Type type, - const void *block, - size_t block_size, - struct GNUNET_HashCode *key) +block_plugin_consensus_get_key (void *cls, + enum GNUNET_BLOCK_Type type, + const void *block, + size_t block_size, + struct GNUNET_HashCode *key) { return GNUNET_SYSERR; } @@ -105,16 +106,15 @@ block_plugin_consensus_get_key(void *cls, * Entry point for the plugin. */ void * -libgnunet_plugin_block_consensus_init(void *cls) +libgnunet_plugin_block_consensus_init (void *cls) { - static enum GNUNET_BLOCK_Type types[] = - { + static enum GNUNET_BLOCK_Type types[] = { GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT, GNUNET_BLOCK_TYPE_ANY /* end of list */ }; struct GNUNET_BLOCK_PluginFunctions *api; - api = GNUNET_new(struct GNUNET_BLOCK_PluginFunctions); + api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions); api->evaluate = &block_plugin_consensus_evaluate; api->get_key = &block_plugin_consensus_get_key; api->types = types; @@ -126,11 +126,11 @@ libgnunet_plugin_block_consensus_init(void *cls) * Exit point from the plugin. */ void * -libgnunet_plugin_block_consensus_done(void *cls) +libgnunet_plugin_block_consensus_done (void *cls) { struct GNUNET_BLOCK_PluginFunctions *api = cls; - GNUNET_free(api); + GNUNET_free (api); return NULL; } diff --git a/src/consensus/test_consensus_api.c b/src/consensus/test_consensus_api.c index a2ae36222..d32bc06ed 100644 --- a/src/consensus/test_consensus_api.c +++ b/src/consensus/test_consensus_api.c @@ -36,31 +36,31 @@ static unsigned int elements_received; static void -conclude_done(void *cls) +conclude_done (void *cls) { - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "conclude over\n"); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "conclude over\n"); if (2 != elements_received) - GNUNET_assert(0); - GNUNET_SCHEDULER_shutdown(); + GNUNET_assert (0); + GNUNET_SCHEDULER_shutdown (); } static void -on_new_element(void *cls, - const struct GNUNET_SET_Element *element) +on_new_element (void *cls, + const struct GNUNET_SET_Element *element) { elements_received++; } static void -insert_done(void *cls, int success) +insert_done (void *cls, int success) { /* make sure cb is only called once */ static int called = GNUNET_NO; - GNUNET_assert(GNUNET_NO == called); + GNUNET_assert (GNUNET_NO == called); called = GNUNET_YES; - GNUNET_log(GNUNET_ERROR_TYPE_INFO, "insert done\n"); - GNUNET_CONSENSUS_conclude(consensus, &conclude_done, NULL); + GNUNET_log (GNUNET_ERROR_TYPE_INFO, "insert done\n"); + GNUNET_CONSENSUS_conclude (consensus, &conclude_done, NULL); } @@ -70,47 +70,49 @@ insert_done(void *cls, int success) * @param cls closure */ static void -on_shutdown(void *cls) +on_shutdown (void *cls) { if (NULL != consensus) - { - GNUNET_CONSENSUS_destroy(consensus); - consensus = NULL; - } + { + GNUNET_CONSENSUS_destroy (consensus); + consensus = NULL; + } } static void -run(void *cls, - const struct GNUNET_CONFIGURATION_Handle *cfg, - struct GNUNET_TESTING_Peer *peer) +run (void *cls, + const struct GNUNET_CONFIGURATION_Handle *cfg, + struct GNUNET_TESTING_Peer *peer) { char *str = "foo"; struct GNUNET_SET_Element el1 = { 4, 0, "foo" }; struct GNUNET_SET_Element el2 = { 5, 0, "quux" }; - GNUNET_log_setup("test_consensus_api", - "INFO", - NULL); - GNUNET_SCHEDULER_add_shutdown(&on_shutdown, NULL); - - GNUNET_CRYPTO_hash(str, strlen(str), &session_id); - consensus = GNUNET_CONSENSUS_create(cfg, 0, NULL, &session_id, - GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_SECONDS), - GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES), - on_new_element, &consensus); - GNUNET_assert(consensus != NULL); - - GNUNET_CONSENSUS_insert(consensus, &el1, NULL, &consensus); - GNUNET_CONSENSUS_insert(consensus, &el2, &insert_done, &consensus); + GNUNET_log_setup ("test_consensus_api", + "INFO", + NULL); + GNUNET_SCHEDULER_add_shutdown (&on_shutdown, NULL); + + GNUNET_CRYPTO_hash (str, strlen (str), &session_id); + consensus = GNUNET_CONSENSUS_create (cfg, 0, NULL, &session_id, + GNUNET_TIME_relative_to_absolute ( + GNUNET_TIME_UNIT_SECONDS), + GNUNET_TIME_relative_to_absolute ( + GNUNET_TIME_UNIT_MINUTES), + on_new_element, &consensus); + GNUNET_assert (consensus != NULL); + + GNUNET_CONSENSUS_insert (consensus, &el1, NULL, &consensus); + GNUNET_CONSENSUS_insert (consensus, &el2, &insert_done, &consensus); } int -main(int argc, char **argv) +main (int argc, char **argv) { - return GNUNET_TESTING_peer_run("test_consensus_api", - "test_consensus.conf", - &run, NULL); + return GNUNET_TESTING_peer_run ("test_consensus_api", + "test_consensus.conf", + &run, NULL); } |