diff options
author | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
---|---|---|
committer | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
commit | d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch) | |
tree | 9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/consensus/consensus_api.c | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/consensus/consensus_api.c')
-rw-r--r-- | src/consensus/consensus_api.c | 183 |
1 files changed, 91 insertions, 92 deletions
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 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file consensus/consensus_api.c | 22 | * @file consensus/consensus_api.c |
@@ -31,14 +31,13 @@ | |||
31 | #include "consensus.h" | 31 | #include "consensus.h" |
32 | 32 | ||
33 | 33 | ||
34 | #define LOG(kind,...) GNUNET_log_from (kind, "consensus-api",__VA_ARGS__) | 34 | #define LOG(kind, ...) GNUNET_log_from(kind, "consensus-api", __VA_ARGS__) |
35 | 35 | ||
36 | 36 | ||
37 | /** | 37 | /** |
38 | * Handle for the service. | 38 | * Handle for the service. |
39 | */ | 39 | */ |
40 | struct GNUNET_CONSENSUS_Handle | 40 | struct GNUNET_CONSENSUS_Handle { |
41 | { | ||
42 | /** | 41 | /** |
43 | * Configuration to use. | 42 | * Configuration to use. |
44 | */ | 43 | */ |
@@ -90,8 +89,7 @@ struct GNUNET_CONSENSUS_Handle | |||
90 | * FIXME: this should not bee necessary when the API | 89 | * FIXME: this should not bee necessary when the API |
91 | * issue has been fixed | 90 | * issue has been fixed |
92 | */ | 91 | */ |
93 | struct InsertDoneInfo | 92 | struct InsertDoneInfo { |
94 | { | ||
95 | GNUNET_CONSENSUS_InsertDoneCallback idc; | 93 | GNUNET_CONSENSUS_InsertDoneCallback idc; |
96 | void *cls; | 94 | void *cls; |
97 | }; | 95 | }; |
@@ -104,8 +102,8 @@ struct InsertDoneInfo | |||
104 | * @param msg element message | 102 | * @param msg element message |
105 | */ | 103 | */ |
106 | static int | 104 | static int |
107 | check_new_element (void *cls, | 105 | check_new_element(void *cls, |
108 | const struct GNUNET_CONSENSUS_ElementMessage *msg) | 106 | const struct GNUNET_CONSENSUS_ElementMessage *msg) |
109 | { | 107 | { |
110 | /* any size is fine, elements are variable-size */ | 108 | /* any size is fine, elements are variable-size */ |
111 | return GNUNET_OK; | 109 | return GNUNET_OK; |
@@ -119,19 +117,19 @@ check_new_element (void *cls, | |||
119 | * @param msg element message | 117 | * @param msg element message |
120 | */ | 118 | */ |
121 | static void | 119 | static void |
122 | handle_new_element (void *cls, | 120 | handle_new_element(void *cls, |
123 | const struct GNUNET_CONSENSUS_ElementMessage *msg) | 121 | const struct GNUNET_CONSENSUS_ElementMessage *msg) |
124 | { | 122 | { |
125 | struct GNUNET_CONSENSUS_Handle *consensus = cls; | 123 | struct GNUNET_CONSENSUS_Handle *consensus = cls; |
126 | struct GNUNET_SET_Element element; | 124 | struct GNUNET_SET_Element element; |
127 | 125 | ||
128 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 126 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
129 | "received new element\n"); | 127 | "received new element\n"); |
130 | element.element_type = msg->element_type; | 128 | element.element_type = msg->element_type; |
131 | element.size = ntohs (msg->header.size) - sizeof (struct GNUNET_CONSENSUS_ElementMessage); | 129 | element.size = ntohs(msg->header.size) - sizeof(struct GNUNET_CONSENSUS_ElementMessage); |
132 | element.data = &msg[1]; | 130 | element.data = &msg[1]; |
133 | consensus->new_element_cb (consensus->new_element_cls, | 131 | consensus->new_element_cb(consensus->new_element_cls, |
134 | &element); | 132 | &element); |
135 | } | 133 | } |
136 | 134 | ||
137 | 135 | ||
@@ -143,17 +141,17 @@ handle_new_element (void *cls, | |||
143 | * @param msg conclude done message | 141 | * @param msg conclude done message |
144 | */ | 142 | */ |
145 | static void | 143 | static void |
146 | handle_conclude_done (void *cls, | 144 | handle_conclude_done(void *cls, |
147 | const struct GNUNET_MessageHeader *msg) | 145 | const struct GNUNET_MessageHeader *msg) |
148 | { | 146 | { |
149 | struct GNUNET_CONSENSUS_Handle *consensus = cls; | 147 | struct GNUNET_CONSENSUS_Handle *consensus = cls; |
150 | GNUNET_CONSENSUS_ConcludeCallback cc; | 148 | GNUNET_CONSENSUS_ConcludeCallback cc; |
151 | 149 | ||
152 | GNUNET_MQ_destroy (consensus->mq); | 150 | GNUNET_MQ_destroy(consensus->mq); |
153 | consensus->mq = NULL; | 151 | consensus->mq = NULL; |
154 | GNUNET_assert (NULL != (cc = consensus->conclude_cb)); | 152 | GNUNET_assert(NULL != (cc = consensus->conclude_cb)); |
155 | consensus->conclude_cb = NULL; | 153 | consensus->conclude_cb = NULL; |
156 | cc (consensus->conclude_cls); | 154 | cc(consensus->conclude_cls); |
157 | } | 155 | } |
158 | 156 | ||
159 | 157 | ||
@@ -167,11 +165,11 @@ handle_conclude_done (void *cls, | |||
167 | * @param error error code | 165 | * @param error error code |
168 | */ | 166 | */ |
169 | static void | 167 | static void |
170 | mq_error_handler (void *cls, | 168 | mq_error_handler(void *cls, |
171 | enum GNUNET_MQ_Error error) | 169 | enum GNUNET_MQ_Error error) |
172 | { | 170 | { |
173 | LOG (GNUNET_ERROR_TYPE_WARNING, | 171 | LOG(GNUNET_ERROR_TYPE_WARNING, |
174 | "consensus service disconnected us\n"); | 172 | "consensus service disconnected us\n"); |
175 | } | 173 | } |
176 | 174 | ||
177 | 175 | ||
@@ -193,27 +191,27 @@ mq_error_handler (void *cls, | |||
193 | * @return handle to use, NULL on error | 191 | * @return handle to use, NULL on error |
194 | */ | 192 | */ |
195 | struct GNUNET_CONSENSUS_Handle * | 193 | struct GNUNET_CONSENSUS_Handle * |
196 | GNUNET_CONSENSUS_create (const struct GNUNET_CONFIGURATION_Handle *cfg, | 194 | GNUNET_CONSENSUS_create(const struct GNUNET_CONFIGURATION_Handle *cfg, |
197 | unsigned int num_peers, | 195 | unsigned int num_peers, |
198 | const struct GNUNET_PeerIdentity *peers, | 196 | const struct GNUNET_PeerIdentity *peers, |
199 | const struct GNUNET_HashCode *session_id, | 197 | const struct GNUNET_HashCode *session_id, |
200 | struct GNUNET_TIME_Absolute start, | 198 | struct GNUNET_TIME_Absolute start, |
201 | struct GNUNET_TIME_Absolute deadline, | 199 | struct GNUNET_TIME_Absolute deadline, |
202 | GNUNET_CONSENSUS_ElementCallback new_element_cb, | 200 | GNUNET_CONSENSUS_ElementCallback new_element_cb, |
203 | void *new_element_cls) | 201 | void *new_element_cls) |
204 | { | 202 | { |
205 | struct GNUNET_CONSENSUS_Handle *consensus | 203 | struct GNUNET_CONSENSUS_Handle *consensus |
206 | = GNUNET_new (struct GNUNET_CONSENSUS_Handle); | 204 | = GNUNET_new(struct GNUNET_CONSENSUS_Handle); |
207 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { | 205 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { |
208 | GNUNET_MQ_hd_var_size (new_element, | 206 | GNUNET_MQ_hd_var_size(new_element, |
209 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT, | 207 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT, |
210 | struct GNUNET_CONSENSUS_ElementMessage, | 208 | struct GNUNET_CONSENSUS_ElementMessage, |
211 | consensus), | 209 | consensus), |
212 | GNUNET_MQ_hd_fixed_size (conclude_done, | 210 | GNUNET_MQ_hd_fixed_size(conclude_done, |
213 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE, | 211 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE, |
214 | struct GNUNET_MessageHeader, | 212 | struct GNUNET_MessageHeader, |
215 | consensus), | 213 | consensus), |
216 | GNUNET_MQ_handler_end () | 214 | GNUNET_MQ_handler_end() |
217 | }; | 215 | }; |
218 | struct GNUNET_CONSENSUS_JoinMessage *join_msg; | 216 | struct GNUNET_CONSENSUS_JoinMessage *join_msg; |
219 | struct GNUNET_MQ_Envelope *ev; | 217 | struct GNUNET_MQ_Envelope *ev; |
@@ -222,39 +220,40 @@ GNUNET_CONSENSUS_create (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
222 | consensus->new_element_cb = new_element_cb; | 220 | consensus->new_element_cb = new_element_cb; |
223 | consensus->new_element_cls = new_element_cls; | 221 | consensus->new_element_cls = new_element_cls; |
224 | consensus->session_id = *session_id; | 222 | consensus->session_id = *session_id; |
225 | consensus->mq = GNUNET_CLIENT_connect (cfg, | 223 | consensus->mq = GNUNET_CLIENT_connect(cfg, |
226 | "consensus", | 224 | "consensus", |
227 | mq_handlers, | 225 | mq_handlers, |
228 | &mq_error_handler, | 226 | &mq_error_handler, |
229 | consensus); | 227 | consensus); |
230 | if (NULL == consensus->mq) | 228 | if (NULL == consensus->mq) |
231 | { | 229 | { |
232 | GNUNET_free (consensus); | 230 | GNUNET_free(consensus); |
233 | return NULL; | 231 | return NULL; |
234 | } | 232 | } |
235 | ev = GNUNET_MQ_msg_extra (join_msg, | 233 | ev = GNUNET_MQ_msg_extra(join_msg, |
236 | (num_peers * sizeof (struct GNUNET_PeerIdentity)), | 234 | (num_peers * sizeof(struct GNUNET_PeerIdentity)), |
237 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN); | 235 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN); |
238 | 236 | ||
239 | join_msg->session_id = consensus->session_id; | 237 | join_msg->session_id = consensus->session_id; |
240 | join_msg->start = GNUNET_TIME_absolute_hton (start); | 238 | join_msg->start = GNUNET_TIME_absolute_hton(start); |
241 | join_msg->deadline = GNUNET_TIME_absolute_hton (deadline); | 239 | join_msg->deadline = GNUNET_TIME_absolute_hton(deadline); |
242 | join_msg->num_peers = htonl (num_peers); | 240 | join_msg->num_peers = htonl(num_peers); |
243 | GNUNET_memcpy(&join_msg[1], | 241 | GNUNET_memcpy(&join_msg[1], |
244 | peers, | 242 | peers, |
245 | num_peers * sizeof (struct GNUNET_PeerIdentity)); | 243 | num_peers * sizeof(struct GNUNET_PeerIdentity)); |
246 | 244 | ||
247 | GNUNET_MQ_send (consensus->mq, ev); | 245 | GNUNET_MQ_send(consensus->mq, ev); |
248 | return consensus; | 246 | return consensus; |
249 | } | 247 | } |
250 | 248 | ||
251 | 249 | ||
252 | static void | 250 | static void |
253 | idc_adapter (void *cls) | 251 | idc_adapter(void *cls) |
254 | { | 252 | { |
255 | struct InsertDoneInfo *i = cls; | 253 | struct InsertDoneInfo *i = cls; |
256 | i->idc (i->cls, GNUNET_OK); | 254 | |
257 | GNUNET_free (i); | 255 | i->idc(i->cls, GNUNET_OK); |
256 | GNUNET_free(i); | ||
258 | } | 257 | } |
259 | 258 | ||
260 | /** | 259 | /** |
@@ -268,30 +267,30 @@ idc_adapter (void *cls) | |||
268 | * @param idc_cls closure for 'idc' | 267 | * @param idc_cls closure for 'idc' |
269 | */ | 268 | */ |
270 | void | 269 | void |
271 | GNUNET_CONSENSUS_insert (struct GNUNET_CONSENSUS_Handle *consensus, | 270 | GNUNET_CONSENSUS_insert(struct GNUNET_CONSENSUS_Handle *consensus, |
272 | const struct GNUNET_SET_Element *element, | 271 | const struct GNUNET_SET_Element *element, |
273 | GNUNET_CONSENSUS_InsertDoneCallback idc, | 272 | GNUNET_CONSENSUS_InsertDoneCallback idc, |
274 | void *idc_cls) | 273 | void *idc_cls) |
275 | { | 274 | { |
276 | struct GNUNET_CONSENSUS_ElementMessage *element_msg; | 275 | struct GNUNET_CONSENSUS_ElementMessage *element_msg; |
277 | struct GNUNET_MQ_Envelope *ev; | 276 | struct GNUNET_MQ_Envelope *ev; |
278 | struct InsertDoneInfo *i; | 277 | struct InsertDoneInfo *i; |
279 | 278 | ||
280 | LOG (GNUNET_ERROR_TYPE_DEBUG, "inserting, size=%llu\n", element->size); | 279 | LOG(GNUNET_ERROR_TYPE_DEBUG, "inserting, size=%llu\n", element->size); |
281 | 280 | ||
282 | ev = GNUNET_MQ_msg_extra (element_msg, element->size, | 281 | ev = GNUNET_MQ_msg_extra(element_msg, element->size, |
283 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT); | 282 | GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT); |
284 | 283 | ||
285 | GNUNET_memcpy (&element_msg[1], element->data, element->size); | 284 | GNUNET_memcpy(&element_msg[1], element->data, element->size); |
286 | 285 | ||
287 | if (NULL != idc) | 286 | if (NULL != idc) |
288 | { | 287 | { |
289 | i = GNUNET_new (struct InsertDoneInfo); | 288 | i = GNUNET_new(struct InsertDoneInfo); |
290 | i->idc = idc; | 289 | i->idc = idc; |
291 | i->cls = idc_cls; | 290 | i->cls = idc_cls; |
292 | GNUNET_MQ_notify_sent (ev, idc_adapter, i); | 291 | GNUNET_MQ_notify_sent(ev, idc_adapter, i); |
293 | } | 292 | } |
294 | GNUNET_MQ_send (consensus->mq, ev); | 293 | GNUNET_MQ_send(consensus->mq, ev); |
295 | } | 294 | } |
296 | 295 | ||
297 | 296 | ||
@@ -308,20 +307,20 @@ GNUNET_CONSENSUS_insert (struct GNUNET_CONSENSUS_Handle *consensus, | |||
308 | * @param conclude_cls closure for the conclude callback | 307 | * @param conclude_cls closure for the conclude callback |
309 | */ | 308 | */ |
310 | void | 309 | void |
311 | GNUNET_CONSENSUS_conclude (struct GNUNET_CONSENSUS_Handle *consensus, | 310 | GNUNET_CONSENSUS_conclude(struct GNUNET_CONSENSUS_Handle *consensus, |
312 | GNUNET_CONSENSUS_ConcludeCallback conclude, | 311 | GNUNET_CONSENSUS_ConcludeCallback conclude, |
313 | void *conclude_cls) | 312 | void *conclude_cls) |
314 | { | 313 | { |
315 | struct GNUNET_MQ_Envelope *ev; | 314 | struct GNUNET_MQ_Envelope *ev; |
316 | 315 | ||
317 | GNUNET_assert (NULL != conclude); | 316 | GNUNET_assert(NULL != conclude); |
318 | GNUNET_assert (NULL == consensus->conclude_cb); | 317 | GNUNET_assert(NULL == consensus->conclude_cb); |
319 | 318 | ||
320 | consensus->conclude_cls = conclude_cls; | 319 | consensus->conclude_cls = conclude_cls; |
321 | consensus->conclude_cb = conclude; | 320 | consensus->conclude_cb = conclude; |
322 | 321 | ||
323 | ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE); | 322 | ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE); |
324 | GNUNET_MQ_send (consensus->mq, ev); | 323 | GNUNET_MQ_send(consensus->mq, ev); |
325 | } | 324 | } |
326 | 325 | ||
327 | 326 | ||
@@ -332,14 +331,14 @@ GNUNET_CONSENSUS_conclude (struct GNUNET_CONSENSUS_Handle *consensus, | |||
332 | * @param consensus handle to destroy | 331 | * @param consensus handle to destroy |
333 | */ | 332 | */ |
334 | void | 333 | void |
335 | GNUNET_CONSENSUS_destroy (struct GNUNET_CONSENSUS_Handle *consensus) | 334 | GNUNET_CONSENSUS_destroy(struct GNUNET_CONSENSUS_Handle *consensus) |
336 | { | 335 | { |
337 | if (NULL != consensus->mq) | 336 | if (NULL != consensus->mq) |
338 | { | 337 | { |
339 | GNUNET_MQ_destroy (consensus->mq); | 338 | GNUNET_MQ_destroy(consensus->mq); |
340 | consensus->mq = NULL; | 339 | consensus->mq = NULL; |
341 | } | 340 | } |
342 | GNUNET_free (consensus); | 341 | GNUNET_free(consensus); |
343 | } | 342 | } |
344 | 343 | ||
345 | /* end of consensus_api.c */ | 344 | /* end of consensus_api.c */ |