From d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb Mon Sep 17 00:00:00 2001 From: ng0 Date: Sun, 8 Sep 2019 12:33:09 +0000 Subject: uncrustify as demanded. --- src/consensus/consensus.h | 11 +- src/consensus/consensus_api.c | 183 +- src/consensus/consensus_protocol.h | 16 +- src/consensus/gnunet-consensus-profiler.c | 536 +++--- src/consensus/gnunet-service-consensus.c | 2974 +++++++++++++++-------------- src/consensus/plugin_block_consensus.c | 60 +- src/consensus/test_consensus_api.c | 77 +- 7 files changed, 1931 insertions(+), 1926 deletions(-) (limited to 'src/consensus') diff --git a/src/consensus/consensus.h b/src/consensus/consensus.h index 683e16104..f110b23b2 100644 --- a/src/consensus/consensus.h +++ b/src/consensus/consensus.h @@ -11,12 +11,12 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . SPDX-License-Identifier: AGPL3.0-or-later -*/ + */ /** * @author Florian Dold @@ -34,8 +34,7 @@ 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 */ @@ -69,9 +68,7 @@ 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 4a584a410..2da145932 100644 --- a/src/consensus/consensus_api.c +++ b/src/consensus/consensus_api.c @@ -11,12 +11,12 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . SPDX-License-Identifier: AGPL3.0-or-later -*/ + */ /** * @file consensus/consensus_api.c @@ -31,14 +31,13 @@ #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. */ @@ -90,8 +89,7 @@ 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; }; @@ -104,8 +102,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; @@ -119,19 +117,19 @@ 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); } @@ -143,17 +141,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); } @@ -167,11 +165,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"); } @@ -193,27 +191,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; @@ -222,39 +220,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); + 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)); + peers, + num_peers * sizeof(struct GNUNET_PeerIdentity)); - GNUNET_MQ_send (consensus->mq, ev); + 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); } /** @@ -268,30 +267,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); } @@ -308,20 +307,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); } @@ -332,14 +331,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 77641e2b4..fc8ae7533 100644 --- a/src/consensus/consensus_protocol.h +++ b/src/consensus/consensus_protocol.h @@ -11,12 +11,12 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . SPDX-License-Identifier: AGPL3.0-or-later -*/ + */ /** @@ -42,8 +42,7 @@ 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 */ @@ -98,8 +97,7 @@ enum { /** * Consensus element, either marker or payload. */ -struct ConsensusElement -{ +struct ConsensusElement { /** * Payload element_type, only valid * if this is not a marker element. @@ -115,16 +113,14 @@ 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 e088904aa..9feee87cd 100644 --- a/src/consensus/gnunet-consensus-profiler.c +++ b/src/consensus/gnunet-consensus-profiler.c @@ -11,7 +11,7 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . @@ -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,47 @@ 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,43 +179,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; @@ -224,49 +225,48 @@ do_consensus () struct GNUNET_SET_Element element; if (dist_static) - { - 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); - } + 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); + } + } } - } else - { - 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); - } + 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); + } + } } - } - 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,51 +280,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)); + } } @@ -339,23 +338,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; } @@ -371,8 +371,8 @@ static void 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 +386,34 @@ 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 +431,144 @@ 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_END + 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_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 912d3de6a..98fd551b2 100644 --- a/src/consensus/gnunet-service-consensus.c +++ b/src/consensus/gnunet-service-consensus.c @@ -11,12 +11,12 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . SPDX-License-Identifier: AGPL3.0-or-later -*/ + */ /** * @file consensus/gnunet-service-consensus.c @@ -36,8 +36,7 @@ #include "consensus.h" -enum ReferendumVote -{ +enum ReferendumVote { /** * Vote that nothing should change. * This option is never voted explicitly. @@ -54,8 +53,7 @@ enum ReferendumVote }; -enum EarlyStoppingPhase -{ +enum EarlyStoppingPhase { EARLY_STOPPING_NONE = 0, EARLY_STOPPING_ONE_MORE = 1, EARLY_STOPPING_DONE = 2, @@ -100,16 +98,14 @@ 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; /** @@ -121,15 +117,13 @@ 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; @@ -138,8 +132,7 @@ 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, @@ -156,8 +149,7 @@ enum PhaseKind }; -enum SetKind -{ +enum SetKind { SET_KIND_NONE = 0, SET_KIND_CURRENT, /** @@ -168,16 +160,14 @@ 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, @@ -185,8 +175,7 @@ enum RfnKind }; -struct SetOpCls -{ +struct SetOpCls { struct SetKey input_set; struct SetKey output_set; @@ -201,8 +190,7 @@ struct SetOpCls }; -struct FinishCls -{ +struct FinishCls { struct SetKey input_set; }; @@ -210,8 +198,7 @@ struct FinishCls * Closure for both @a start_task * and @a cancel_task. */ -union TaskFuncCls -{ +union TaskFuncCls { struct SetOpCls setop; struct FinishCls finish; }; @@ -223,8 +210,7 @@ typedef void (*TaskFunc) (struct TaskEntry *task); /* * Node in the consensus task graph. */ -struct TaskEntry -{ +struct TaskEntry { struct TaskKey key; struct Step *step; @@ -240,8 +226,7 @@ struct TaskEntry }; -struct Step -{ +struct Step { /** * All steps of one session are in a * linked list for easier deallocation. @@ -319,8 +304,7 @@ struct Step }; -struct RfnElementInfo -{ +struct RfnElementInfo { const struct GNUNET_SET_Element *element; /* @@ -336,8 +320,7 @@ struct RfnElementInfo }; -struct ReferendumEntry -{ +struct ReferendumEntry { struct RfnKey key; /* @@ -372,8 +355,7 @@ struct ReferendumEntry }; -struct DiffElementInfo -{ +struct DiffElementInfo { const struct GNUNET_SET_Element *element; /** @@ -387,14 +369,12 @@ 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; @@ -406,8 +386,7 @@ 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. */ @@ -446,9 +425,9 @@ struct ConsensusSession int conclude_done; /** - * Global consensus identification, computed - * from the session id and participating authorities. - */ + * Global consensus identification, computed + * from the session id and participating authorities. + */ struct GNUNET_HashCode global_id; /** @@ -539,128 +518,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_2: return "ALL_TO_ALL_2"; + case PHASE_KIND_FINISH: return "FINISH"; + case PHASE_KIND_GRADECAST_LEADER: return "GRADECAST_LEADER"; + case PHASE_KIND_GRADECAST_ECHO: return "GRADECAST_ECHO"; + case PHASE_KIND_GRADECAST_ECHO_GRADE: return "GRADECAST_ECHO_GRADE"; + case PHASE_KIND_GRADECAST_CONFIRM: return "GRADECAST_CONFIRM"; + case PHASE_KIND_GRADECAST_CONFIRM_GRADE: return "GRADECAST_CONFIRM_GRADE"; + case PHASE_KIND_APPLY_REP: return "APPLY_REP"; + 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_LEADER_PROPOSAL: return "LEADER_PROPOSAL"; + case SET_KIND_NONE: return "NONE"; + 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_ECHO: return "ECHO"; + case RFN_KIND_CONFIRM: return "CONFIRM"; + 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_LEADER_CONSENSUS: return "LEADER_CONSENSUS"; + case DIFF_KIND_GRADECAST_RESULT: return "GRADECAST_RESULT"; + case DIFF_KIND_LEADER_PROPOSAL: return "LEADER_PROPOSAL"; + 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; } @@ -678,164 +676,164 @@ 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; + { + struct GNUNET_CONSENSUS_ElementMessage *m; + const struct ConsensusElement *ce; - GNUNET_assert (GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT == element->element_type); - ce = element->data; + 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); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "marker is %u\n", (unsigned)ce->marker); - if (0 != ce->marker) - return GNUNET_YES; + 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)); + 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); - } + 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; @@ -843,33 +841,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; @@ -877,9 +875,10 @@ 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; + if (task->key.peer1 == me) return task->key.peer2; return task->key.peer1; @@ -887,10 +886,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; @@ -910,10 +909,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; @@ -925,244 +924,246 @@ 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; - } - - 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; + { + /* 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 (CONSENSUS_MARKER_SIZE == consensus_element->marker) + 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; + } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "P%u: got size marker\n", - session->local_peer_idx); - - - struct ConsensusSizeElement *cse = (void *) consensus_element; + 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; + } - 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)); + 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); + { + // 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); + { + 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); + { + 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; + case GNUNET_SET_STATUS_ADD_REMOTE: - GNUNET_assert (NULL != consensus_element); + 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)); + 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); + { + // 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); + { + 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); + { + 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; + 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); + 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)); - } + { + 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); + { + session->first_size = current_size; + } + finish_task(task); break; + case GNUNET_SET_STATUS_FAILURE: // XXX: cleanup - GNUNET_break_op (0); - finish_task (task); + GNUNET_break_op(0); + finish_task(task); return; + default: /* not reached */ - GNUNET_assert (0); - } + GNUNET_assert(0); + } } #ifdef EVIL -enum EvilnessType -{ +enum EvilnessType { EVILNESS_NONE, EVILNESS_CRAM_ALL, EVILNESS_CRAM_LEAD, @@ -1171,15 +1172,13 @@ 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; @@ -1187,129 +1186,129 @@ 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; + 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; } - /* 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 @@ -1320,60 +1319,60 @@ 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); - } + { + /* 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: @@ -1382,236 +1381,239 @@ commit_set (struct ConsensusSession *session, 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; - } + { + 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); + GNUNET_SET_commit(setop->op, set->h); + break; } - else if (EVILNESS_SUB_NO_REPLACEMENT == evil.subtype) + if (EVILNESS_CRAM_ECHO == evil.type && (PHASE_KIND_GRADECAST_ECHO != task->key.kind)) { - /* Always cram the same elements, derived from counter. */ - GNUNET_CRYPTO_hash (&i, sizeof (i), &se.rand); + GNUNET_SET_commit(setop->op, set->h); + break; } - else + for (i = 0; i < evil.num; i++) { - GNUNET_assert (0); - } - GNUNET_SET_add_element (set->h, &element, NULL, NULL); + 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); + } + 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. */ + 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); - } + 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; + { + GNUNET_SET_commit(setop->op, set->h); + } + break; + case EVILNESS_NONE: - GNUNET_SET_commit (setop->op, set->h); + 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, +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)) - { - if (di->weight > 0) + GNUNET_CONTAINER_multihashmap_iterator_next(iter, + NULL, + (const void **)&di)) { - rfn_vote (rfn, voting_peer, VOTE_ADD, di->element); - } - if (di->weight < 0) - { - rfn_vote (rfn, voting_peer, VOTE_REMOVE, di->element); + 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); + } } - } - 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; @@ -1620,10 +1622,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 @@ -1634,71 +1636,70 @@ 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); } @@ -1707,31 +1708,30 @@ 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 +1741,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,63 +1773,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); } @@ -1841,7 +1839,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; @@ -1858,130 +1856,136 @@ 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); + rfn_majority(rfn_in, ri, &majority_num, &majority_vote); - if (worst_majority > majority_num) - worst_majority = majority_num; + 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, + 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, + 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; + 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; + } } - } 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) { - 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; + switch (session->early_stopping) { - struct Step *step; - for (step = session->steps_head; NULL != step; step = step->next) - try_finish_step_early (step); + 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; } - 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; @@ -1994,90 +1998,93 @@ 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); + 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); + 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; - 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; - default: - GNUNET_assert (0); - 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_REMOVE: + rfn_vote(output_rfn, task->key.leader, VOTE_REMOVE, ri->element); + 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) @@ -2085,113 +2092,113 @@ 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)) { - create_set_copy_for_task (task, &setop->input_set, &setop->output_set); - return; + /* 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; + } } - } if (RFN_KIND_NONE != setop->output_rfn.rfn_kind) - { - if (NULL == lookup_rfn (session, &setop->output_rfn)) { - struct ReferendumEntry *rfn; + if (NULL == lookup_rfn(session, &setop->output_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)) { - struct DiffEntry *diff; + if (NULL == lookup_diff(session, &setop->output_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); - - if (NULL != setop->op) { - commit_set (session, task); + /* 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 - { - /* We made an error while constructing the task graph. */ - GNUNET_assert (0); - } + { + /* 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; @@ -2205,123 +2212,126 @@ task_start_eval_echo (struct TaskEntry *task) 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); + 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); + 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)) - { - enum ReferendumVote majority_vote; - uint16_t majority_num; + 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); + rfn_majority(input_rfn, ri, &majority_num, &majority_vote); - 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; - } + 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; + } - switch (majority_vote) - { - case VOTE_ADD: - progress_cls->num_pending++; - GNUNET_assert (GNUNET_OK == - GNUNET_SET_add_element (output_set->h, + 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, + 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); + break; + + 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; } @@ -2334,40 +2344,40 @@ 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) ) { - size_t i; + if ((GNUNET_NO == step->is_running) && (0 == step->pending_prereq) && (GNUNET_NO == step->is_finished)) + { + 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; + /* Running the next ready steps will be triggered by task completion */ + return; + } + step = step->next; } - step = step->next; - } return; } @@ -2375,22 +2385,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); } @@ -2402,11 +2412,12 @@ 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; } @@ -2422,21 +2433,21 @@ get_peer_idx (const struct GNUNET_PeerIdentity *peer, const struct ConsensusSess * @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)); } @@ -2448,9 +2459,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)); } @@ -2462,56 +2473,56 @@ 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)) { - local_peer_in_list = GNUNET_YES; - break; + if (0 == GNUNET_memcmp(&msg_peers[i], + &my_peer)) + { + 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); } @@ -2531,10 +2542,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; @@ -2542,122 +2553,122 @@ 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. */ @@ -2673,37 +2684,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; + } } @@ -2711,36 +2722,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++; @@ -2750,16 +2761,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; } @@ -2769,11 +2781,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; @@ -2795,155 +2807,155 @@ 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++) { - if (k == me) - continue; - p1 = me; - p2 = k; - arrange_peers (&p1, &p2, n); - task = ((struct TaskEntry) { + for (k = 0; k < n; k++) + { + 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 }, }); - 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 }, .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 }, .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 }, .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; @@ -2973,60 +2985,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; @@ -3039,47 +3051,47 @@ 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}, + .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 */ + /* 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, @@ -3088,7 +3100,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); } @@ -3101,17 +3113,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)) != - listed_peers * sizeof (struct GNUNET_PeerIdentity)) - { - GNUNET_break (0); - return GNUNET_SYSERR; - } + if ((ntohs(m->header.size) - sizeof(*m)) != + listed_peers * sizeof(struct GNUNET_PeerIdentity)) + { + GNUNET_break(0); + return GNUNET_SYSERR; + } return GNUNET_OK; } @@ -3123,16 +3135,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 @@ -3140,75 +3152,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, + = 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_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_NO); - 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, + session->diffmap = 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 } @@ -3222,8 +3234,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; } @@ -3236,8 +3248,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; @@ -3245,20 +3257,20 @@ 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 = { .element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT, - .size = sizeof (struct ConsensusElement) + element_size, + .size = sizeof(struct ConsensusElement) + element_size, .data = ce, }; @@ -3266,28 +3278,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); } @@ -3298,24 +3310,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); } @@ -3325,12 +3337,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; } @@ -3343,24 +3355,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); } @@ -3373,17 +3385,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; } @@ -3396,29 +3408,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); } @@ -3426,24 +3438,24 @@ client_disconnect_cb (void *cls, * Define "main" method using service macro. */ GNUNET_SERVICE_MAIN -("consensus", - GNUNET_SERVICE_OPTION_NONE, - &run, - &client_connect_cb, - &client_disconnect_cb, - NULL, - GNUNET_MQ_hd_fixed_size (client_conclude, + ("consensus", + GNUNET_SERVICE_OPTION_NONE, + &run, + &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_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_MQ_hd_var_size(client_join, GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN, struct GNUNET_CONSENSUS_JoinMessage, NULL), - GNUNET_MQ_handler_end ()); + 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 ca19b7c8d..a90b451d2 100644 --- a/src/consensus/plugin_block_consensus.c +++ b/src/consensus/plugin_block_consensus.c @@ -11,12 +11,12 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . SPDX-License-Identifier: AGPL3.0-or-later -*/ + */ /** * @file consensus/plugin_block_consensus.c @@ -47,35 +47,35 @@ * @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)) + if (reply_block_size < sizeof(struct ConsensusElement)) return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; const struct ConsensusElement *ce = reply_block; - if ( (0 != ce->marker) || - (0 == ce->payload_type ) ) + if ((0 != ce->marker) || + (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 +91,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, +block_plugin_consensus_get_key(void *cls, enum GNUNET_BLOCK_Type type, const void *block, size_t block_size, - struct GNUNET_HashCode *key) + struct GNUNET_HashCode *key) { return GNUNET_SYSERR; } @@ -105,7 +105,7 @@ 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[] = { @@ -114,7 +114,7 @@ libgnunet_plugin_block_consensus_init (void *cls) }; 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 46e582afe..a2ae36222 100644 --- a/src/consensus/test_consensus_api.c +++ b/src/consensus/test_consensus_api.c @@ -11,12 +11,12 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . SPDX-License-Identifier: AGPL3.0-or-later -*/ + */ /** * @file consensus/test_consensus_api.c @@ -36,30 +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); } @@ -69,47 +70,47 @@ 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"}; + 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_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_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_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); } -- cgit v1.2.3