diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/testbed/testbed_api.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/testbed/testbed_api.c')
-rw-r--r-- | src/testbed/testbed_api.c | 1858 |
1 files changed, 933 insertions, 925 deletions
diff --git a/src/testbed/testbed_api.c b/src/testbed/testbed_api.c index 8ca96dcbe..38913509b 100644 --- a/src/testbed/testbed_api.c +++ b/src/testbed/testbed_api.c | |||
@@ -44,30 +44,31 @@ | |||
44 | /** | 44 | /** |
45 | * Generic logging shorthand | 45 | * Generic logging shorthand |
46 | */ | 46 | */ |
47 | #define LOG(kind, ...) GNUNET_log_from(kind, "testbed-api", __VA_ARGS__) | 47 | #define LOG(kind, ...) GNUNET_log_from (kind, "testbed-api", __VA_ARGS__) |
48 | 48 | ||
49 | /** | 49 | /** |
50 | * Debug logging | 50 | * Debug logging |
51 | */ | 51 | */ |
52 | #define LOG_DEBUG(...) LOG(GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__) | 52 | #define LOG_DEBUG(...) LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__) |
53 | 53 | ||
54 | /** | 54 | /** |
55 | * Relative time seconds shorthand | 55 | * Relative time seconds shorthand |
56 | */ | 56 | */ |
57 | #define TIME_REL_SECS(sec) \ | 57 | #define TIME_REL_SECS(sec) \ |
58 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, sec) | 58 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, sec) |
59 | 59 | ||
60 | 60 | ||
61 | /** | 61 | /** |
62 | * Default server message sending retry timeout | 62 | * Default server message sending retry timeout |
63 | */ | 63 | */ |
64 | #define TIMEOUT_REL TIME_REL_SECS(1) | 64 | #define TIMEOUT_REL TIME_REL_SECS (1) |
65 | 65 | ||
66 | 66 | ||
67 | /** | 67 | /** |
68 | * Context data for forwarded Operation | 68 | * Context data for forwarded Operation |
69 | */ | 69 | */ |
70 | struct ForwardedOperationData { | 70 | struct ForwardedOperationData |
71 | { | ||
71 | /** | 72 | /** |
72 | * The callback to call when reply is available | 73 | * The callback to call when reply is available |
73 | */ | 74 | */ |
@@ -83,7 +84,8 @@ struct ForwardedOperationData { | |||
83 | /** | 84 | /** |
84 | * Context data for get slave config operations | 85 | * Context data for get slave config operations |
85 | */ | 86 | */ |
86 | struct GetSlaveConfigData { | 87 | struct GetSlaveConfigData |
88 | { | ||
87 | /** | 89 | /** |
88 | * The id of the slave controller | 90 | * The id of the slave controller |
89 | */ | 91 | */ |
@@ -94,7 +96,8 @@ struct GetSlaveConfigData { | |||
94 | /** | 96 | /** |
95 | * Context data for controller link operations | 97 | * Context data for controller link operations |
96 | */ | 98 | */ |
97 | struct ControllerLinkData { | 99 | struct ControllerLinkData |
100 | { | ||
98 | /** | 101 | /** |
99 | * The controller link message | 102 | * The controller link message |
100 | */ | 103 | */ |
@@ -110,7 +113,8 @@ struct ControllerLinkData { | |||
110 | /** | 113 | /** |
111 | * Date context for OP_SHUTDOWN_PEERS operations | 114 | * Date context for OP_SHUTDOWN_PEERS operations |
112 | */ | 115 | */ |
113 | struct ShutdownPeersData { | 116 | struct ShutdownPeersData |
117 | { | ||
114 | /** | 118 | /** |
115 | * The operation completion callback to call | 119 | * The operation completion callback to call |
116 | */ | 120 | */ |
@@ -126,7 +130,8 @@ struct ShutdownPeersData { | |||
126 | /** | 130 | /** |
127 | * An entry in the stack for keeping operations which are about to expire | 131 | * An entry in the stack for keeping operations which are about to expire |
128 | */ | 132 | */ |
129 | struct ExpireOperationEntry { | 133 | struct ExpireOperationEntry |
134 | { | ||
130 | /** | 135 | /** |
131 | * DLL head; new entries are to be inserted here | 136 | * DLL head; new entries are to be inserted here |
132 | */ | 137 | */ |
@@ -161,13 +166,13 @@ static struct ExpireOperationEntry *exop_tail; | |||
161 | * @param op the operation to insert | 166 | * @param op the operation to insert |
162 | */ | 167 | */ |
163 | static void | 168 | static void |
164 | exop_insert(struct GNUNET_TESTBED_Operation *op) | 169 | exop_insert (struct GNUNET_TESTBED_Operation *op) |
165 | { | 170 | { |
166 | struct ExpireOperationEntry *entry; | 171 | struct ExpireOperationEntry *entry; |
167 | 172 | ||
168 | entry = GNUNET_new(struct ExpireOperationEntry); | 173 | entry = GNUNET_new (struct ExpireOperationEntry); |
169 | entry->op = op; | 174 | entry->op = op; |
170 | GNUNET_CONTAINER_DLL_insert_tail(exop_head, exop_tail, entry); | 175 | GNUNET_CONTAINER_DLL_insert_tail (exop_head, exop_tail, entry); |
171 | } | 176 | } |
172 | 177 | ||
173 | 178 | ||
@@ -183,7 +188,7 @@ exop_insert(struct GNUNET_TESTBED_Operation *op) | |||
183 | * paramenter will return GNUNET_NO) | 188 | * paramenter will return GNUNET_NO) |
184 | */ | 189 | */ |
185 | static int | 190 | static int |
186 | exop_check(const struct GNUNET_TESTBED_Operation *const op) | 191 | exop_check (const struct GNUNET_TESTBED_Operation *const op) |
187 | { | 192 | { |
188 | struct ExpireOperationEntry *entry; | 193 | struct ExpireOperationEntry *entry; |
189 | struct ExpireOperationEntry *entry2; | 194 | struct ExpireOperationEntry *entry2; |
@@ -192,24 +197,24 @@ exop_check(const struct GNUNET_TESTBED_Operation *const op) | |||
192 | found = GNUNET_NO; | 197 | found = GNUNET_NO; |
193 | entry = exop_head; | 198 | entry = exop_head; |
194 | while (NULL != entry) | 199 | while (NULL != entry) |
200 | { | ||
201 | if (op == entry->op) | ||
195 | { | 202 | { |
196 | if (op == entry->op) | 203 | found = GNUNET_YES; |
197 | { | 204 | break; |
198 | found = GNUNET_YES; | ||
199 | break; | ||
200 | } | ||
201 | entry = entry->next; | ||
202 | } | 205 | } |
206 | entry = entry->next; | ||
207 | } | ||
203 | if (GNUNET_NO == found) | 208 | if (GNUNET_NO == found) |
204 | return GNUNET_NO; | 209 | return GNUNET_NO; |
205 | /* Truncate the tail */ | 210 | /* Truncate the tail */ |
206 | while (NULL != entry) | 211 | while (NULL != entry) |
207 | { | 212 | { |
208 | entry2 = entry->next; | 213 | entry2 = entry->next; |
209 | GNUNET_CONTAINER_DLL_remove(exop_head, exop_tail, entry); | 214 | GNUNET_CONTAINER_DLL_remove (exop_head, exop_tail, entry); |
210 | GNUNET_free(entry); | 215 | GNUNET_free (entry); |
211 | entry = entry2; | 216 | entry = entry2; |
212 | } | 217 | } |
213 | return GNUNET_YES; | 218 | return GNUNET_YES; |
214 | } | 219 | } |
215 | 220 | ||
@@ -217,7 +222,8 @@ exop_check(const struct GNUNET_TESTBED_Operation *const op) | |||
217 | /** | 222 | /** |
218 | * Context information to be used while searching for operation contexts | 223 | * Context information to be used while searching for operation contexts |
219 | */ | 224 | */ |
220 | struct SearchContext { | 225 | struct SearchContext |
226 | { | ||
221 | /** | 227 | /** |
222 | * The result of the search | 228 | * The result of the search |
223 | */ | 229 | */ |
@@ -240,13 +246,13 @@ struct SearchContext { | |||
240 | * #GNUNET_NO if not. | 246 | * #GNUNET_NO if not. |
241 | */ | 247 | */ |
242 | static int | 248 | static int |
243 | opc_search_iterator(void *cls, uint32_t key, void *value) | 249 | opc_search_iterator (void *cls, uint32_t key, void *value) |
244 | { | 250 | { |
245 | struct SearchContext *sc = cls; | 251 | struct SearchContext *sc = cls; |
246 | struct OperationContext *opc = value; | 252 | struct OperationContext *opc = value; |
247 | 253 | ||
248 | GNUNET_assert(NULL != opc); | 254 | GNUNET_assert (NULL != opc); |
249 | GNUNET_assert(NULL == sc->opc); | 255 | GNUNET_assert (NULL == sc->opc); |
250 | if (opc->id != sc->id) | 256 | if (opc->id != sc->id) |
251 | return GNUNET_YES; | 257 | return GNUNET_YES; |
252 | sc->opc = opc; | 258 | sc->opc = opc; |
@@ -263,18 +269,18 @@ opc_search_iterator(void *cls, uint32_t key, void *value) | |||
263 | * @return the matching operation context; NULL if no match found | 269 | * @return the matching operation context; NULL if no match found |
264 | */ | 270 | */ |
265 | static struct OperationContext * | 271 | static struct OperationContext * |
266 | find_opc(const struct GNUNET_TESTBED_Controller *c, const uint64_t id) | 272 | find_opc (const struct GNUNET_TESTBED_Controller *c, const uint64_t id) |
267 | { | 273 | { |
268 | struct SearchContext sc; | 274 | struct SearchContext sc; |
269 | 275 | ||
270 | sc.id = id; | 276 | sc.id = id; |
271 | sc.opc = NULL; | 277 | sc.opc = NULL; |
272 | GNUNET_assert(NULL != c->opc_map); | 278 | GNUNET_assert (NULL != c->opc_map); |
273 | if (GNUNET_SYSERR != | 279 | if (GNUNET_SYSERR != |
274 | GNUNET_CONTAINER_multihashmap32_get_multiple(c->opc_map, | 280 | GNUNET_CONTAINER_multihashmap32_get_multiple (c->opc_map, |
275 | (uint32_t)id, | 281 | (uint32_t) id, |
276 | &opc_search_iterator, | 282 | &opc_search_iterator, |
277 | &sc)) | 283 | &sc)) |
278 | return NULL; | 284 | return NULL; |
279 | return sc.opc; | 285 | return sc.opc; |
280 | } | 286 | } |
@@ -289,16 +295,16 @@ find_opc(const struct GNUNET_TESTBED_Controller *c, const uint64_t id) | |||
289 | * @param opc the operation context to be inserted | 295 | * @param opc the operation context to be inserted |
290 | */ | 296 | */ |
291 | void | 297 | void |
292 | GNUNET_TESTBED_insert_opc_(struct GNUNET_TESTBED_Controller *c, | 298 | GNUNET_TESTBED_insert_opc_ (struct GNUNET_TESTBED_Controller *c, |
293 | struct OperationContext *opc) | 299 | struct OperationContext *opc) |
294 | { | 300 | { |
295 | if (NULL == c->opc_map) | 301 | if (NULL == c->opc_map) |
296 | c->opc_map = GNUNET_CONTAINER_multihashmap32_create(256); | 302 | c->opc_map = GNUNET_CONTAINER_multihashmap32_create (256); |
297 | GNUNET_assert(GNUNET_OK == GNUNET_CONTAINER_multihashmap32_put( | 303 | GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap32_put ( |
298 | c->opc_map, | 304 | c->opc_map, |
299 | (uint32_t)opc->id, | 305 | (uint32_t) opc->id, |
300 | opc, | 306 | opc, |
301 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); | 307 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); |
302 | } | 308 | } |
303 | 309 | ||
304 | 310 | ||
@@ -310,17 +316,17 @@ GNUNET_TESTBED_insert_opc_(struct GNUNET_TESTBED_Controller *c, | |||
310 | * @param opc the operation context to remove | 316 | * @param opc the operation context to remove |
311 | */ | 317 | */ |
312 | void | 318 | void |
313 | GNUNET_TESTBED_remove_opc_(const struct GNUNET_TESTBED_Controller *c, | 319 | GNUNET_TESTBED_remove_opc_ (const struct GNUNET_TESTBED_Controller *c, |
314 | struct OperationContext *opc) | 320 | struct OperationContext *opc) |
315 | { | 321 | { |
316 | GNUNET_assert(NULL != c->opc_map); | 322 | GNUNET_assert (NULL != c->opc_map); |
317 | GNUNET_assert(GNUNET_YES == | 323 | GNUNET_assert (GNUNET_YES == |
318 | GNUNET_CONTAINER_multihashmap32_remove(c->opc_map, | 324 | GNUNET_CONTAINER_multihashmap32_remove (c->opc_map, |
319 | (uint32_t)opc->id, | 325 | (uint32_t) opc->id, |
320 | opc)); | 326 | opc)); |
321 | if ((0 == GNUNET_CONTAINER_multihashmap32_size(c->opc_map)) && | 327 | if ((0 == GNUNET_CONTAINER_multihashmap32_size (c->opc_map)) && |
322 | (NULL != c->opcq_empty_cb)) | 328 | (NULL != c->opcq_empty_cb)) |
323 | c->opcq_empty_cb(c->opcq_empty_cls); | 329 | c->opcq_empty_cb (c->opcq_empty_cls); |
324 | } | 330 | } |
325 | 331 | ||
326 | 332 | ||
@@ -332,22 +338,22 @@ GNUNET_TESTBED_remove_opc_(const struct GNUNET_TESTBED_Controller *c, | |||
332 | * @return #GNUNET_OK if message is well-formed | 338 | * @return #GNUNET_OK if message is well-formed |
333 | */ | 339 | */ |
334 | static int | 340 | static int |
335 | check_add_host_confirm(void *cls, | 341 | check_add_host_confirm (void *cls, |
336 | const struct GNUNET_TESTBED_HostConfirmedMessage *msg) | 342 | const struct GNUNET_TESTBED_HostConfirmedMessage *msg) |
337 | { | 343 | { |
338 | const char *emsg; | 344 | const char *emsg; |
339 | uint16_t msg_size; | 345 | uint16_t msg_size; |
340 | 346 | ||
341 | msg_size = ntohs(msg->header.size) - sizeof(*msg); | 347 | msg_size = ntohs (msg->header.size) - sizeof(*msg); |
342 | if (0 == msg_size) | 348 | if (0 == msg_size) |
343 | return GNUNET_OK; | 349 | return GNUNET_OK; |
344 | /* We have an error message */ | 350 | /* We have an error message */ |
345 | emsg = (const char *)&msg[1]; | 351 | emsg = (const char *) &msg[1]; |
346 | if ('\0' != emsg[msg_size - 1]) | 352 | if ('\0' != emsg[msg_size - 1]) |
347 | { | 353 | { |
348 | GNUNET_break(0); | 354 | GNUNET_break (0); |
349 | return GNUNET_SYSERR; | 355 | return GNUNET_SYSERR; |
350 | } | 356 | } |
351 | return GNUNET_OK; | 357 | return GNUNET_OK; |
352 | } | 358 | } |
353 | 359 | ||
@@ -360,8 +366,8 @@ check_add_host_confirm(void *cls, | |||
360 | * @param msg message received | 366 | * @param msg message received |
361 | */ | 367 | */ |
362 | static void | 368 | static void |
363 | handle_add_host_confirm(void *cls, | 369 | handle_add_host_confirm (void *cls, |
364 | const struct GNUNET_TESTBED_HostConfirmedMessage *msg) | 370 | const struct GNUNET_TESTBED_HostConfirmedMessage *msg) |
365 | { | 371 | { |
366 | struct GNUNET_TESTBED_Controller *c = cls; | 372 | struct GNUNET_TESTBED_Controller *c = cls; |
367 | struct GNUNET_TESTBED_HostRegistrationHandle *rh = c->rh; | 373 | struct GNUNET_TESTBED_HostRegistrationHandle *rh = c->rh; |
@@ -370,31 +376,31 @@ handle_add_host_confirm(void *cls, | |||
370 | 376 | ||
371 | if (NULL == rh) | 377 | if (NULL == rh) |
372 | return; | 378 | return; |
373 | if (GNUNET_TESTBED_host_get_id_(rh->host) != ntohl(msg->host_id)) | 379 | if (GNUNET_TESTBED_host_get_id_ (rh->host) != ntohl (msg->host_id)) |
374 | { | 380 | { |
375 | LOG_DEBUG("Mismatch in host id's %u, %u of host confirm msg\n", | 381 | LOG_DEBUG ("Mismatch in host id's %u, %u of host confirm msg\n", |
376 | GNUNET_TESTBED_host_get_id_(rh->host), | 382 | GNUNET_TESTBED_host_get_id_ (rh->host), |
377 | ntohl(msg->host_id)); | 383 | ntohl (msg->host_id)); |
378 | return; | 384 | return; |
379 | } | 385 | } |
380 | c->rh = NULL; | 386 | c->rh = NULL; |
381 | msg_size = ntohs(msg->header.size) - sizeof(*msg); | 387 | msg_size = ntohs (msg->header.size) - sizeof(*msg); |
382 | if (0 == msg_size) | 388 | if (0 == msg_size) |
383 | { | 389 | { |
384 | LOG_DEBUG("Host %u successfully registered\n", ntohl(msg->host_id)); | 390 | LOG_DEBUG ("Host %u successfully registered\n", ntohl (msg->host_id)); |
385 | GNUNET_TESTBED_mark_host_registered_at_(rh->host, c); | 391 | GNUNET_TESTBED_mark_host_registered_at_ (rh->host, c); |
386 | rh->cc(rh->cc_cls, NULL); | 392 | rh->cc (rh->cc_cls, NULL); |
387 | GNUNET_free(rh); | 393 | GNUNET_free (rh); |
388 | return; | 394 | return; |
389 | } | 395 | } |
390 | /* We have an error message */ | 396 | /* We have an error message */ |
391 | emsg = (const char *)&msg[1]; | 397 | emsg = (const char *) &msg[1]; |
392 | LOG(GNUNET_ERROR_TYPE_ERROR, | 398 | LOG (GNUNET_ERROR_TYPE_ERROR, |
393 | _("Adding host %u failed with error: %s\n"), | 399 | _ ("Adding host %u failed with error: %s\n"), |
394 | ntohl(msg->host_id), | 400 | ntohl (msg->host_id), |
395 | emsg); | 401 | emsg); |
396 | rh->cc(rh->cc_cls, emsg); | 402 | rh->cc (rh->cc_cls, emsg); |
397 | GNUNET_free(rh); | 403 | GNUNET_free (rh); |
398 | } | 404 | } |
399 | 405 | ||
400 | 406 | ||
@@ -406,19 +412,19 @@ handle_add_host_confirm(void *cls, | |||
406 | * @param msg the message | 412 | * @param msg the message |
407 | */ | 413 | */ |
408 | static void | 414 | static void |
409 | handle_forwarded_operation_msg(void *cls, | 415 | handle_forwarded_operation_msg (void *cls, |
410 | struct OperationContext *opc, | 416 | struct OperationContext *opc, |
411 | const struct GNUNET_MessageHeader *msg) | 417 | const struct GNUNET_MessageHeader *msg) |
412 | { | 418 | { |
413 | struct GNUNET_TESTBED_Controller *c = cls; | 419 | struct GNUNET_TESTBED_Controller *c = cls; |
414 | struct ForwardedOperationData *fo_data; | 420 | struct ForwardedOperationData *fo_data; |
415 | 421 | ||
416 | fo_data = opc->data; | 422 | fo_data = opc->data; |
417 | if (NULL != fo_data->cc) | 423 | if (NULL != fo_data->cc) |
418 | fo_data->cc(fo_data->cc_cls, msg); | 424 | fo_data->cc (fo_data->cc_cls, msg); |
419 | GNUNET_TESTBED_remove_opc_(c, opc); | 425 | GNUNET_TESTBED_remove_opc_ (c, opc); |
420 | GNUNET_free(fo_data); | 426 | GNUNET_free (fo_data); |
421 | GNUNET_free(opc); | 427 | GNUNET_free (opc); |
422 | } | 428 | } |
423 | 429 | ||
424 | 430 | ||
@@ -430,7 +436,7 @@ handle_forwarded_operation_msg(void *cls, | |||
430 | * @param msg message received | 436 | * @param msg message received |
431 | */ | 437 | */ |
432 | static void | 438 | static void |
433 | handle_opsuccess( | 439 | handle_opsuccess ( |
434 | void *cls, | 440 | void *cls, |
435 | const struct GNUNET_TESTBED_GenericOperationSuccessEventMessage *msg) | 441 | const struct GNUNET_TESTBED_GenericOperationSuccessEventMessage *msg) |
436 | { | 442 | { |
@@ -441,13 +447,13 @@ handle_opsuccess( | |||
441 | struct GNUNET_TESTBED_EventInformation event; | 447 | struct GNUNET_TESTBED_EventInformation event; |
442 | uint64_t op_id; | 448 | uint64_t op_id; |
443 | 449 | ||
444 | op_id = GNUNET_ntohll(msg->operation_id); | 450 | op_id = GNUNET_ntohll (msg->operation_id); |
445 | LOG_DEBUG("Operation %lu successful\n", op_id); | 451 | LOG_DEBUG ("Operation %lu successful\n", op_id); |
446 | if (NULL == (opc = find_opc(c, op_id))) | 452 | if (NULL == (opc = find_opc (c, op_id))) |
447 | { | 453 | { |
448 | LOG_DEBUG("Operation not found\n"); | 454 | LOG_DEBUG ("Operation not found\n"); |
449 | return; | 455 | return; |
450 | } | 456 | } |
451 | event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED; | 457 | event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED; |
452 | event.op = opc->op; | 458 | event.op = opc->op; |
453 | event.op_cls = opc->op_cls; | 459 | event.op_cls = opc->op_cls; |
@@ -456,71 +462,72 @@ handle_opsuccess( | |||
456 | op_comp_cb = NULL; | 462 | op_comp_cb = NULL; |
457 | op_comp_cb_cls = NULL; | 463 | op_comp_cb_cls = NULL; |
458 | switch (opc->type) | 464 | switch (opc->type) |
459 | { | 465 | { |
460 | case OP_FORWARDED: { | 466 | case OP_FORWARDED: { |
461 | handle_forwarded_operation_msg(c, | 467 | handle_forwarded_operation_msg (c, |
462 | opc, | 468 | opc, |
463 | (const struct GNUNET_MessageHeader *)msg); | 469 | (const struct |
470 | GNUNET_MessageHeader *) msg); | ||
464 | return; | 471 | return; |
465 | } | 472 | } |
466 | break; | 473 | break; |
467 | 474 | ||
468 | case OP_PEER_DESTROY: { | 475 | case OP_PEER_DESTROY: { |
469 | struct GNUNET_TESTBED_Peer *peer; | 476 | struct GNUNET_TESTBED_Peer *peer; |
470 | 477 | ||
471 | peer = opc->data; | 478 | peer = opc->data; |
472 | GNUNET_TESTBED_peer_deregister_(peer); | 479 | GNUNET_TESTBED_peer_deregister_ (peer); |
473 | GNUNET_free(peer); | 480 | GNUNET_free (peer); |
474 | opc->data = NULL; | 481 | opc->data = NULL; |
475 | //PEERDESTROYDATA | 482 | // PEERDESTROYDATA |
476 | } | 483 | } |
477 | break; | 484 | break; |
478 | 485 | ||
479 | case OP_SHUTDOWN_PEERS: { | 486 | case OP_SHUTDOWN_PEERS: { |
480 | struct ShutdownPeersData *data; | 487 | struct ShutdownPeersData *data; |
481 | 488 | ||
482 | data = opc->data; | 489 | data = opc->data; |
483 | op_comp_cb = data->cb; | 490 | op_comp_cb = data->cb; |
484 | op_comp_cb_cls = data->cb_cls; | 491 | op_comp_cb_cls = data->cb_cls; |
485 | GNUNET_free(data); | 492 | GNUNET_free (data); |
486 | opc->data = NULL; | 493 | opc->data = NULL; |
487 | GNUNET_TESTBED_cleanup_peers_(); | 494 | GNUNET_TESTBED_cleanup_peers_ (); |
488 | } | 495 | } |
489 | break; | 496 | break; |
490 | 497 | ||
491 | case OP_MANAGE_SERVICE: { | 498 | case OP_MANAGE_SERVICE: { |
492 | struct ManageServiceData *data; | 499 | struct ManageServiceData *data; |
493 | 500 | ||
494 | GNUNET_assert(NULL != (data = opc->data)); | 501 | GNUNET_assert (NULL != (data = opc->data)); |
495 | op_comp_cb = data->cb; | 502 | op_comp_cb = data->cb; |
496 | op_comp_cb_cls = data->cb_cls; | 503 | op_comp_cb_cls = data->cb_cls; |
497 | GNUNET_free(data); | 504 | GNUNET_free (data); |
498 | opc->data = NULL; | 505 | opc->data = NULL; |
499 | } | 506 | } |
500 | break; | 507 | break; |
501 | 508 | ||
502 | case OP_PEER_RECONFIGURE: | 509 | case OP_PEER_RECONFIGURE: |
503 | break; | 510 | break; |
504 | 511 | ||
505 | default: | 512 | default: |
506 | GNUNET_assert(0); | 513 | GNUNET_assert (0); |
507 | } | 514 | } |
508 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 515 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
509 | opc->state = OPC_STATE_FINISHED; | 516 | opc->state = OPC_STATE_FINISHED; |
510 | exop_insert(event.op); | 517 | exop_insert (event.op); |
511 | if (0 != (c->event_mask & (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED))) | 518 | if (0 != (c->event_mask & (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED))) |
512 | { | 519 | { |
513 | if (NULL != c->cc) | 520 | if (NULL != c->cc) |
514 | c->cc(c->cc_cls, &event); | 521 | c->cc (c->cc_cls, &event); |
515 | if (GNUNET_NO == exop_check(event.op)) | 522 | if (GNUNET_NO == exop_check (event.op)) |
516 | return; | 523 | return; |
517 | } | 524 | } |
518 | else | 525 | else |
519 | LOG_DEBUG("Not calling callback\n"); | 526 | LOG_DEBUG ("Not calling callback\n"); |
520 | if (NULL != op_comp_cb) | 527 | if (NULL != op_comp_cb) |
521 | op_comp_cb(op_comp_cb_cls, event.op, NULL); | 528 | op_comp_cb (op_comp_cb_cls, event.op, NULL); |
522 | /* You could have marked the operation as done by now */ | 529 | /* You could have marked the operation as done by now */ |
523 | GNUNET_break(GNUNET_NO == exop_check(event.op)); | 530 | GNUNET_break (GNUNET_NO == exop_check (event.op)); |
524 | } | 531 | } |
525 | 532 | ||
526 | 533 | ||
@@ -532,7 +539,7 @@ handle_opsuccess( | |||
532 | * @param msg message received | 539 | * @param msg message received |
533 | */ | 540 | */ |
534 | static void | 541 | static void |
535 | handle_peer_create_success( | 542 | handle_peer_create_success ( |
536 | void *cls, | 543 | void *cls, |
537 | const struct GNUNET_TESTBED_PeerCreateSuccessEventMessage *msg) | 544 | const struct GNUNET_TESTBED_PeerCreateSuccessEventMessage *msg) |
538 | { | 545 | { |
@@ -545,40 +552,40 @@ handle_peer_create_success( | |||
545 | void *cb_cls; | 552 | void *cb_cls; |
546 | uint64_t op_id; | 553 | uint64_t op_id; |
547 | 554 | ||
548 | GNUNET_assert(sizeof(struct GNUNET_TESTBED_PeerCreateSuccessEventMessage) == | 555 | GNUNET_assert (sizeof(struct GNUNET_TESTBED_PeerCreateSuccessEventMessage) == |
549 | ntohs(msg->header.size)); | 556 | ntohs (msg->header.size)); |
550 | op_id = GNUNET_ntohll(msg->operation_id); | 557 | op_id = GNUNET_ntohll (msg->operation_id); |
551 | if (NULL == (opc = find_opc(c, op_id))) | 558 | if (NULL == (opc = find_opc (c, op_id))) |
552 | { | 559 | { |
553 | LOG_DEBUG("Operation context for PeerCreateSuccessEvent not found\n"); | 560 | LOG_DEBUG ("Operation context for PeerCreateSuccessEvent not found\n"); |
554 | return; | 561 | return; |
555 | } | 562 | } |
556 | if (OP_FORWARDED == opc->type) | 563 | if (OP_FORWARDED == opc->type) |
557 | { | 564 | { |
558 | handle_forwarded_operation_msg(c, | 565 | handle_forwarded_operation_msg (c, |
559 | opc, | 566 | opc, |
560 | (const struct GNUNET_MessageHeader *)msg); | 567 | (const struct GNUNET_MessageHeader *) msg); |
561 | return; | 568 | return; |
562 | } | 569 | } |
563 | GNUNET_assert(OP_PEER_CREATE == opc->type); | 570 | GNUNET_assert (OP_PEER_CREATE == opc->type); |
564 | GNUNET_assert(NULL != opc->data); | 571 | GNUNET_assert (NULL != opc->data); |
565 | data = opc->data; | 572 | data = opc->data; |
566 | GNUNET_assert(NULL != data->peer); | 573 | GNUNET_assert (NULL != data->peer); |
567 | peer = data->peer; | 574 | peer = data->peer; |
568 | GNUNET_assert(peer->unique_id == ntohl(msg->peer_id)); | 575 | GNUNET_assert (peer->unique_id == ntohl (msg->peer_id)); |
569 | peer->state = TESTBED_PS_CREATED; | 576 | peer->state = TESTBED_PS_CREATED; |
570 | GNUNET_TESTBED_peer_register_(peer); | 577 | GNUNET_TESTBED_peer_register_ (peer); |
571 | cb = data->cb; | 578 | cb = data->cb; |
572 | cb_cls = data->cls; | 579 | cb_cls = data->cls; |
573 | op = opc->op; | 580 | op = opc->op; |
574 | GNUNET_free(opc->data); | 581 | GNUNET_free (opc->data); |
575 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 582 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
576 | opc->state = OPC_STATE_FINISHED; | 583 | opc->state = OPC_STATE_FINISHED; |
577 | exop_insert(op); | 584 | exop_insert (op); |
578 | if (NULL != cb) | 585 | if (NULL != cb) |
579 | cb(cb_cls, peer, NULL); | 586 | cb (cb_cls, peer, NULL); |
580 | /* You could have marked the operation as done by now */ | 587 | /* You could have marked the operation as done by now */ |
581 | GNUNET_break(GNUNET_NO == exop_check(op)); | 588 | GNUNET_break (GNUNET_NO == exop_check (op)); |
582 | } | 589 | } |
583 | 590 | ||
584 | 591 | ||
@@ -590,7 +597,7 @@ handle_peer_create_success( | |||
590 | * @param msg message received | 597 | * @param msg message received |
591 | */ | 598 | */ |
592 | static void | 599 | static void |
593 | handle_peer_event(void *cls, const struct GNUNET_TESTBED_PeerEventMessage *msg) | 600 | handle_peer_event (void *cls, const struct GNUNET_TESTBED_PeerEventMessage *msg) |
594 | { | 601 | { |
595 | struct GNUNET_TESTBED_Controller *c = cls; | 602 | struct GNUNET_TESTBED_Controller *c = cls; |
596 | struct OperationContext *opc; | 603 | struct OperationContext *opc; |
@@ -602,64 +609,64 @@ handle_peer_event(void *cls, const struct GNUNET_TESTBED_PeerEventMessage *msg) | |||
602 | uint64_t op_id; | 609 | uint64_t op_id; |
603 | uint64_t mask; | 610 | uint64_t mask; |
604 | 611 | ||
605 | GNUNET_assert(sizeof(struct GNUNET_TESTBED_PeerEventMessage) == | 612 | GNUNET_assert (sizeof(struct GNUNET_TESTBED_PeerEventMessage) == |
606 | ntohs(msg->header.size)); | 613 | ntohs (msg->header.size)); |
607 | op_id = GNUNET_ntohll(msg->operation_id); | 614 | op_id = GNUNET_ntohll (msg->operation_id); |
608 | if (NULL == (opc = find_opc(c, op_id))) | 615 | if (NULL == (opc = find_opc (c, op_id))) |
609 | { | 616 | { |
610 | LOG_DEBUG("Operation not found\n"); | 617 | LOG_DEBUG ("Operation not found\n"); |
611 | return; | 618 | return; |
612 | } | 619 | } |
613 | if (OP_FORWARDED == opc->type) | 620 | if (OP_FORWARDED == opc->type) |
614 | { | 621 | { |
615 | handle_forwarded_operation_msg(c, | 622 | handle_forwarded_operation_msg (c, |
616 | opc, | 623 | opc, |
617 | (const struct GNUNET_MessageHeader *)msg); | 624 | (const struct GNUNET_MessageHeader *) msg); |
618 | return; | 625 | return; |
619 | } | 626 | } |
620 | GNUNET_assert((OP_PEER_START == opc->type) || (OP_PEER_STOP == opc->type)); | 627 | GNUNET_assert ((OP_PEER_START == opc->type) || (OP_PEER_STOP == opc->type)); |
621 | data = opc->data; | 628 | data = opc->data; |
622 | GNUNET_assert(NULL != data); | 629 | GNUNET_assert (NULL != data); |
623 | peer = data->peer; | 630 | peer = data->peer; |
624 | GNUNET_assert(NULL != peer); | 631 | GNUNET_assert (NULL != peer); |
625 | event.type = (enum GNUNET_TESTBED_EventType)ntohl(msg->event_type); | 632 | event.type = (enum GNUNET_TESTBED_EventType) ntohl (msg->event_type); |
626 | event.op = opc->op; | 633 | event.op = opc->op; |
627 | event.op_cls = opc->op_cls; | 634 | event.op_cls = opc->op_cls; |
628 | switch (event.type) | 635 | switch (event.type) |
629 | { | 636 | { |
630 | case GNUNET_TESTBED_ET_PEER_START: | 637 | case GNUNET_TESTBED_ET_PEER_START: |
631 | peer->state = TESTBED_PS_STARTED; | 638 | peer->state = TESTBED_PS_STARTED; |
632 | event.details.peer_start.host = peer->host; | 639 | event.details.peer_start.host = peer->host; |
633 | event.details.peer_start.peer = peer; | 640 | event.details.peer_start.peer = peer; |
634 | break; | 641 | break; |
635 | 642 | ||
636 | case GNUNET_TESTBED_ET_PEER_STOP: | 643 | case GNUNET_TESTBED_ET_PEER_STOP: |
637 | peer->state = TESTBED_PS_STOPPED; | 644 | peer->state = TESTBED_PS_STOPPED; |
638 | event.details.peer_stop.peer = peer; | 645 | event.details.peer_stop.peer = peer; |
639 | break; | 646 | break; |
640 | 647 | ||
641 | default: | 648 | default: |
642 | GNUNET_assert(0); /* We should never reach this state */ | 649 | GNUNET_assert (0); /* We should never reach this state */ |
643 | } | 650 | } |
644 | pcc = data->pcc; | 651 | pcc = data->pcc; |
645 | pcc_cls = data->pcc_cls; | 652 | pcc_cls = data->pcc_cls; |
646 | GNUNET_free(data); | 653 | GNUNET_free (data); |
647 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 654 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
648 | opc->state = OPC_STATE_FINISHED; | 655 | opc->state = OPC_STATE_FINISHED; |
649 | exop_insert(event.op); | 656 | exop_insert (event.op); |
650 | mask = 1LL << GNUNET_TESTBED_ET_PEER_START; | 657 | mask = 1LL << GNUNET_TESTBED_ET_PEER_START; |
651 | mask |= 1LL << GNUNET_TESTBED_ET_PEER_STOP; | 658 | mask |= 1LL << GNUNET_TESTBED_ET_PEER_STOP; |
652 | if (0 != (mask & c->event_mask)) | 659 | if (0 != (mask & c->event_mask)) |
653 | { | 660 | { |
654 | if (NULL != c->cc) | 661 | if (NULL != c->cc) |
655 | c->cc(c->cc_cls, &event); | 662 | c->cc (c->cc_cls, &event); |
656 | if (GNUNET_NO == exop_check(event.op)) | 663 | if (GNUNET_NO == exop_check (event.op)) |
657 | return; | 664 | return; |
658 | } | 665 | } |
659 | if (NULL != pcc) | 666 | if (NULL != pcc) |
660 | pcc(pcc_cls, NULL); | 667 | pcc (pcc_cls, NULL); |
661 | /* You could have marked the operation as done by now */ | 668 | /* You could have marked the operation as done by now */ |
662 | GNUNET_break(GNUNET_NO == exop_check(event.op)); | 669 | GNUNET_break (GNUNET_NO == exop_check (event.op)); |
663 | } | 670 | } |
664 | 671 | ||
665 | 672 | ||
@@ -671,8 +678,8 @@ handle_peer_event(void *cls, const struct GNUNET_TESTBED_PeerEventMessage *msg) | |||
671 | * @param msg message received | 678 | * @param msg message received |
672 | */ | 679 | */ |
673 | static void | 680 | static void |
674 | handle_peer_conevent(void *cls, | 681 | handle_peer_conevent (void *cls, |
675 | const struct GNUNET_TESTBED_ConnectionEventMessage *msg) | 682 | const struct GNUNET_TESTBED_ConnectionEventMessage *msg) |
676 | { | 683 | { |
677 | struct GNUNET_TESTBED_Controller *c = cls; | 684 | struct GNUNET_TESTBED_Controller *c = cls; |
678 | struct OperationContext *opc; | 685 | struct OperationContext *opc; |
@@ -683,59 +690,59 @@ handle_peer_conevent(void *cls, | |||
683 | uint64_t op_id; | 690 | uint64_t op_id; |
684 | uint64_t mask; | 691 | uint64_t mask; |
685 | 692 | ||
686 | op_id = GNUNET_ntohll(msg->operation_id); | 693 | op_id = GNUNET_ntohll (msg->operation_id); |
687 | if (NULL == (opc = find_opc(c, op_id))) | 694 | if (NULL == (opc = find_opc (c, op_id))) |
688 | { | 695 | { |
689 | LOG_DEBUG("Operation not found\n"); | 696 | LOG_DEBUG ("Operation not found\n"); |
690 | return; | 697 | return; |
691 | } | 698 | } |
692 | if (OP_FORWARDED == opc->type) | 699 | if (OP_FORWARDED == opc->type) |
693 | { | 700 | { |
694 | handle_forwarded_operation_msg(c, | 701 | handle_forwarded_operation_msg (c, |
695 | opc, | 702 | opc, |
696 | (const struct GNUNET_MessageHeader *)msg); | 703 | (const struct GNUNET_MessageHeader *) msg); |
697 | return; | 704 | return; |
698 | } | 705 | } |
699 | GNUNET_assert(OP_OVERLAY_CONNECT == opc->type); | 706 | GNUNET_assert (OP_OVERLAY_CONNECT == opc->type); |
700 | GNUNET_assert(NULL != (data = opc->data)); | 707 | GNUNET_assert (NULL != (data = opc->data)); |
701 | GNUNET_assert((ntohl(msg->peer1) == data->p1->unique_id) && | 708 | GNUNET_assert ((ntohl (msg->peer1) == data->p1->unique_id) && |
702 | (ntohl(msg->peer2) == data->p2->unique_id)); | 709 | (ntohl (msg->peer2) == data->p2->unique_id)); |
703 | event.type = (enum GNUNET_TESTBED_EventType)ntohl(msg->event_type); | 710 | event.type = (enum GNUNET_TESTBED_EventType) ntohl (msg->event_type); |
704 | event.op = opc->op; | 711 | event.op = opc->op; |
705 | event.op_cls = opc->op_cls; | 712 | event.op_cls = opc->op_cls; |
706 | switch (event.type) | 713 | switch (event.type) |
707 | { | 714 | { |
708 | case GNUNET_TESTBED_ET_CONNECT: | 715 | case GNUNET_TESTBED_ET_CONNECT: |
709 | event.details.peer_connect.peer1 = data->p1; | 716 | event.details.peer_connect.peer1 = data->p1; |
710 | event.details.peer_connect.peer2 = data->p2; | 717 | event.details.peer_connect.peer2 = data->p2; |
711 | break; | 718 | break; |
712 | 719 | ||
713 | case GNUNET_TESTBED_ET_DISCONNECT: | 720 | case GNUNET_TESTBED_ET_DISCONNECT: |
714 | GNUNET_assert(0); /* FIXME: implement */ | 721 | GNUNET_assert (0); /* FIXME: implement */ |
715 | break; | 722 | break; |
716 | 723 | ||
717 | default: | 724 | default: |
718 | GNUNET_assert(0); /* Should never reach here */ | 725 | GNUNET_assert (0); /* Should never reach here */ |
719 | break; | 726 | break; |
720 | } | 727 | } |
721 | cb = data->cb; | 728 | cb = data->cb; |
722 | cb_cls = data->cb_cls; | 729 | cb_cls = data->cb_cls; |
723 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 730 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
724 | opc->state = OPC_STATE_FINISHED; | 731 | opc->state = OPC_STATE_FINISHED; |
725 | exop_insert(event.op); | 732 | exop_insert (event.op); |
726 | mask = 1LL << GNUNET_TESTBED_ET_CONNECT; | 733 | mask = 1LL << GNUNET_TESTBED_ET_CONNECT; |
727 | mask |= 1LL << GNUNET_TESTBED_ET_DISCONNECT; | 734 | mask |= 1LL << GNUNET_TESTBED_ET_DISCONNECT; |
728 | if (0 != (mask & c->event_mask)) | 735 | if (0 != (mask & c->event_mask)) |
729 | { | 736 | { |
730 | if (NULL != c->cc) | 737 | if (NULL != c->cc) |
731 | c->cc(c->cc_cls, &event); | 738 | c->cc (c->cc_cls, &event); |
732 | if (GNUNET_NO == exop_check(event.op)) | 739 | if (GNUNET_NO == exop_check (event.op)) |
733 | return; | 740 | return; |
734 | } | 741 | } |
735 | if (NULL != cb) | 742 | if (NULL != cb) |
736 | cb(cb_cls, opc->op, NULL); | 743 | cb (cb_cls, opc->op, NULL); |
737 | /* You could have marked the operation as done by now */ | 744 | /* You could have marked the operation as done by now */ |
738 | GNUNET_break(GNUNET_NO == exop_check(event.op)); | 745 | GNUNET_break (GNUNET_NO == exop_check (event.op)); |
739 | } | 746 | } |
740 | 747 | ||
741 | 748 | ||
@@ -747,7 +754,7 @@ handle_peer_conevent(void *cls, | |||
747 | * @param msg message received | 754 | * @param msg message received |
748 | */ | 755 | */ |
749 | static int | 756 | static int |
750 | check_peer_config( | 757 | check_peer_config ( |
751 | void *cls, | 758 | void *cls, |
752 | const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *msg) | 759 | const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *msg) |
753 | { | 760 | { |
@@ -764,7 +771,7 @@ check_peer_config( | |||
764 | * @param msg message received | 771 | * @param msg message received |
765 | */ | 772 | */ |
766 | static void | 773 | static void |
767 | handle_peer_config( | 774 | handle_peer_config ( |
768 | void *cls, | 775 | void *cls, |
769 | const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *msg) | 776 | const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *msg) |
770 | { | 777 | { |
@@ -777,51 +784,51 @@ handle_peer_config( | |||
777 | void *cb_cls; | 784 | void *cb_cls; |
778 | uint64_t op_id; | 785 | uint64_t op_id; |
779 | 786 | ||
780 | op_id = GNUNET_ntohll(msg->operation_id); | 787 | op_id = GNUNET_ntohll (msg->operation_id); |
781 | if (NULL == (opc = find_opc(c, op_id))) | 788 | if (NULL == (opc = find_opc (c, op_id))) |
782 | { | 789 | { |
783 | LOG_DEBUG("Operation not found\n"); | 790 | LOG_DEBUG ("Operation not found\n"); |
784 | return; | 791 | return; |
785 | } | 792 | } |
786 | if (OP_FORWARDED == opc->type) | 793 | if (OP_FORWARDED == opc->type) |
787 | { | 794 | { |
788 | handle_forwarded_operation_msg(c, opc, &msg->header); | 795 | handle_forwarded_operation_msg (c, opc, &msg->header); |
789 | return; | 796 | return; |
790 | } | 797 | } |
791 | data = opc->data; | 798 | data = opc->data; |
792 | GNUNET_assert(NULL != data); | 799 | GNUNET_assert (NULL != data); |
793 | peer = data->peer; | 800 | peer = data->peer; |
794 | GNUNET_assert(NULL != peer); | 801 | GNUNET_assert (NULL != peer); |
795 | GNUNET_assert(ntohl(msg->peer_id) == peer->unique_id); | 802 | GNUNET_assert (ntohl (msg->peer_id) == peer->unique_id); |
796 | pinfo = GNUNET_new(struct GNUNET_TESTBED_PeerInformation); | 803 | pinfo = GNUNET_new (struct GNUNET_TESTBED_PeerInformation); |
797 | pinfo->pit = data->pit; | 804 | pinfo->pit = data->pit; |
798 | cb = data->cb; | 805 | cb = data->cb; |
799 | cb_cls = data->cb_cls; | 806 | cb_cls = data->cb_cls; |
800 | GNUNET_assert(NULL != cb); | 807 | GNUNET_assert (NULL != cb); |
801 | GNUNET_free(data); | 808 | GNUNET_free (data); |
802 | opc->data = NULL; | 809 | opc->data = NULL; |
803 | switch (pinfo->pit) | 810 | switch (pinfo->pit) |
804 | { | 811 | { |
805 | case GNUNET_TESTBED_PIT_IDENTITY: | 812 | case GNUNET_TESTBED_PIT_IDENTITY: |
806 | pinfo->result.id = GNUNET_new(struct GNUNET_PeerIdentity); | 813 | pinfo->result.id = GNUNET_new (struct GNUNET_PeerIdentity); |
807 | GNUNET_memcpy(pinfo->result.id, | 814 | GNUNET_memcpy (pinfo->result.id, |
808 | &msg->peer_identity, | 815 | &msg->peer_identity, |
809 | sizeof(struct GNUNET_PeerIdentity)); | 816 | sizeof(struct GNUNET_PeerIdentity)); |
810 | break; | 817 | break; |
811 | 818 | ||
812 | case GNUNET_TESTBED_PIT_CONFIGURATION: | 819 | case GNUNET_TESTBED_PIT_CONFIGURATION: |
813 | pinfo->result.cfg = /* Freed in oprelease_peer_getinfo */ | 820 | pinfo->result.cfg = /* Freed in oprelease_peer_getinfo */ |
814 | GNUNET_TESTBED_extract_config_(&msg->header); | 821 | GNUNET_TESTBED_extract_config_ (&msg->header); |
815 | break; | 822 | break; |
816 | 823 | ||
817 | case GNUNET_TESTBED_PIT_GENERIC: | 824 | case GNUNET_TESTBED_PIT_GENERIC: |
818 | GNUNET_assert(0); /* never reach here */ | 825 | GNUNET_assert (0); /* never reach here */ |
819 | break; | 826 | break; |
820 | } | 827 | } |
821 | opc->data = pinfo; | 828 | opc->data = pinfo; |
822 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 829 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
823 | opc->state = OPC_STATE_FINISHED; | 830 | opc->state = OPC_STATE_FINISHED; |
824 | cb(cb_cls, opc->op, pinfo, NULL); | 831 | cb (cb_cls, opc->op, pinfo, NULL); |
825 | /* We dont check whether the operation is marked as done here as the | 832 | /* We dont check whether the operation is marked as done here as the |
826 | operation contains data (cfg/identify) which will be freed at a later point | 833 | operation contains data (cfg/identify) which will be freed at a later point |
827 | */ | 834 | */ |
@@ -837,7 +844,7 @@ handle_peer_config( | |||
837 | * @return #GNUNET_OK if message is well-formed | 844 | * @return #GNUNET_OK if message is well-formed |
838 | */ | 845 | */ |
839 | static int | 846 | static int |
840 | check_op_fail_event( | 847 | check_op_fail_event ( |
841 | void *cls, | 848 | void *cls, |
842 | const struct GNUNET_TESTBED_OperationFailureEventMessage *msg) | 849 | const struct GNUNET_TESTBED_OperationFailureEventMessage *msg) |
843 | { | 850 | { |
@@ -854,7 +861,7 @@ check_op_fail_event( | |||
854 | * @param msg message received | 861 | * @param msg message received |
855 | */ | 862 | */ |
856 | static void | 863 | static void |
857 | handle_op_fail_event( | 864 | handle_op_fail_event ( |
858 | void *cls, | 865 | void *cls, |
859 | const struct GNUNET_TESTBED_OperationFailureEventMessage *msg) | 866 | const struct GNUNET_TESTBED_OperationFailureEventMessage *msg) |
860 | { | 867 | { |
@@ -865,34 +872,34 @@ handle_op_fail_event( | |||
865 | uint64_t mask; | 872 | uint64_t mask; |
866 | struct GNUNET_TESTBED_EventInformation event; | 873 | struct GNUNET_TESTBED_EventInformation event; |
867 | 874 | ||
868 | op_id = GNUNET_ntohll(msg->operation_id); | 875 | op_id = GNUNET_ntohll (msg->operation_id); |
869 | if (NULL == (opc = find_opc(c, op_id))) | 876 | if (NULL == (opc = find_opc (c, op_id))) |
870 | { | 877 | { |
871 | LOG_DEBUG("Operation not found\n"); | 878 | LOG_DEBUG ("Operation not found\n"); |
872 | return; | 879 | return; |
873 | } | 880 | } |
874 | if (OP_FORWARDED == opc->type) | 881 | if (OP_FORWARDED == opc->type) |
875 | { | 882 | { |
876 | handle_forwarded_operation_msg(c, | 883 | handle_forwarded_operation_msg (c, |
877 | opc, | 884 | opc, |
878 | (const struct GNUNET_MessageHeader *)msg); | 885 | (const struct GNUNET_MessageHeader *) msg); |
879 | return; | 886 | return; |
880 | } | 887 | } |
881 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 888 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
882 | opc->state = OPC_STATE_FINISHED; | 889 | opc->state = OPC_STATE_FINISHED; |
883 | emsg = GNUNET_TESTBED_parse_error_string_(msg); | 890 | emsg = GNUNET_TESTBED_parse_error_string_ (msg); |
884 | if (NULL == emsg) | 891 | if (NULL == emsg) |
885 | emsg = "Unknown error"; | 892 | emsg = "Unknown error"; |
886 | if (OP_PEER_INFO == opc->type) | 893 | if (OP_PEER_INFO == opc->type) |
887 | { | 894 | { |
888 | struct PeerInfoData *data; | 895 | struct PeerInfoData *data; |
889 | 896 | ||
890 | data = opc->data; | 897 | data = opc->data; |
891 | if (NULL != data->cb) | 898 | if (NULL != data->cb) |
892 | data->cb(data->cb_cls, opc->op, NULL, emsg); | 899 | data->cb (data->cb_cls, opc->op, NULL, emsg); |
893 | GNUNET_free(data); | 900 | GNUNET_free (data); |
894 | return; /* We do not call controller callback for peer info */ | 901 | return; /* We do not call controller callback for peer info */ |
895 | } | 902 | } |
896 | event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED; | 903 | event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED; |
897 | event.op = opc->op; | 904 | event.op = opc->op; |
898 | event.op_cls = opc->op_cls; | 905 | event.op_cls = opc->op_cls; |
@@ -900,88 +907,88 @@ handle_op_fail_event( | |||
900 | event.details.operation_finished.generic = NULL; | 907 | event.details.operation_finished.generic = NULL; |
901 | mask = (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED); | 908 | mask = (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED); |
902 | if ((0 != (mask & c->event_mask)) && (NULL != c->cc)) | 909 | if ((0 != (mask & c->event_mask)) && (NULL != c->cc)) |
903 | { | 910 | { |
904 | exop_insert(event.op); | 911 | exop_insert (event.op); |
905 | c->cc(c->cc_cls, &event); | 912 | c->cc (c->cc_cls, &event); |
906 | if (GNUNET_NO == exop_check(event.op)) | 913 | if (GNUNET_NO == exop_check (event.op)) |
907 | return; | 914 | return; |
908 | } | 915 | } |
909 | switch (opc->type) | 916 | switch (opc->type) |
910 | { | 917 | { |
911 | case OP_PEER_CREATE: { | 918 | case OP_PEER_CREATE: { |
912 | struct PeerCreateData *data; | 919 | struct PeerCreateData *data; |
913 | 920 | ||
914 | data = opc->data; | 921 | data = opc->data; |
915 | GNUNET_free(data->peer); | 922 | GNUNET_free (data->peer); |
916 | if (NULL != data->cb) | 923 | if (NULL != data->cb) |
917 | data->cb(data->cls, NULL, emsg); | 924 | data->cb (data->cls, NULL, emsg); |
918 | GNUNET_free(data); | 925 | GNUNET_free (data); |
919 | } | 926 | } |
920 | break; | 927 | break; |
921 | 928 | ||
922 | case OP_PEER_START: | 929 | case OP_PEER_START: |
923 | case OP_PEER_STOP: { | 930 | case OP_PEER_STOP: { |
924 | struct PeerEventData *data; | 931 | struct PeerEventData *data; |
925 | 932 | ||
926 | data = opc->data; | 933 | data = opc->data; |
927 | if (NULL != data->pcc) | 934 | if (NULL != data->pcc) |
928 | data->pcc(data->pcc_cls, emsg); | 935 | data->pcc (data->pcc_cls, emsg); |
929 | GNUNET_free(data); | 936 | GNUNET_free (data); |
930 | } | 937 | } |
931 | break; | 938 | break; |
932 | 939 | ||
933 | case OP_PEER_DESTROY: | 940 | case OP_PEER_DESTROY: |
934 | break; | 941 | break; |
935 | 942 | ||
936 | case OP_PEER_INFO: | 943 | case OP_PEER_INFO: |
937 | GNUNET_assert(0); | 944 | GNUNET_assert (0); |
938 | 945 | ||
939 | case OP_OVERLAY_CONNECT: { | 946 | case OP_OVERLAY_CONNECT: { |
940 | struct OverlayConnectData *data; | 947 | struct OverlayConnectData *data; |
941 | 948 | ||
942 | data = opc->data; | 949 | data = opc->data; |
943 | GNUNET_TESTBED_operation_mark_failed(opc->op); | 950 | GNUNET_TESTBED_operation_mark_failed (opc->op); |
944 | if (NULL != data->cb) | 951 | if (NULL != data->cb) |
945 | data->cb(data->cb_cls, opc->op, emsg); | 952 | data->cb (data->cb_cls, opc->op, emsg); |
946 | } | 953 | } |
947 | break; | 954 | break; |
948 | 955 | ||
949 | case OP_FORWARDED: | 956 | case OP_FORWARDED: |
950 | GNUNET_assert(0); | 957 | GNUNET_assert (0); |
951 | 958 | ||
952 | case OP_LINK_CONTROLLERS: /* No secondary callback */ | 959 | case OP_LINK_CONTROLLERS: /* No secondary callback */ |
953 | break; | 960 | break; |
954 | 961 | ||
955 | case OP_SHUTDOWN_PEERS: { | 962 | case OP_SHUTDOWN_PEERS: { |
956 | struct ShutdownPeersData *data; | 963 | struct ShutdownPeersData *data; |
957 | 964 | ||
958 | data = opc->data; | 965 | data = opc->data; |
959 | GNUNET_free(data); /* FIXME: Decide whether we call data->op_cb */ | 966 | GNUNET_free (data); /* FIXME: Decide whether we call data->op_cb */ |
960 | opc->data = NULL; | 967 | opc->data = NULL; |
961 | } | 968 | } |
962 | break; | 969 | break; |
963 | 970 | ||
964 | case OP_MANAGE_SERVICE: { | 971 | case OP_MANAGE_SERVICE: { |
965 | struct ManageServiceData *data = opc->data; | 972 | struct ManageServiceData *data = opc->data; |
966 | GNUNET_TESTBED_OperationCompletionCallback cb; | 973 | GNUNET_TESTBED_OperationCompletionCallback cb; |
967 | void *cb_cls; | 974 | void *cb_cls; |
968 | 975 | ||
969 | GNUNET_assert(NULL != data); | 976 | GNUNET_assert (NULL != data); |
970 | cb = data->cb; | 977 | cb = data->cb; |
971 | cb_cls = data->cb_cls; | 978 | cb_cls = data->cb_cls; |
972 | GNUNET_free(data); | 979 | GNUNET_free (data); |
973 | opc->data = NULL; | 980 | opc->data = NULL; |
974 | exop_insert(event.op); | 981 | exop_insert (event.op); |
975 | if (NULL != cb) | 982 | if (NULL != cb) |
976 | cb(cb_cls, opc->op, emsg); | 983 | cb (cb_cls, opc->op, emsg); |
977 | /* You could have marked the operation as done by now */ | 984 | /* You could have marked the operation as done by now */ |
978 | GNUNET_break(GNUNET_NO == exop_check(event.op)); | 985 | GNUNET_break (GNUNET_NO == exop_check (event.op)); |
979 | } | 986 | } |
980 | break; | 987 | break; |
981 | 988 | ||
982 | default: | 989 | default: |
983 | GNUNET_break(0); | 990 | GNUNET_break (0); |
984 | } | 991 | } |
985 | } | 992 | } |
986 | 993 | ||
987 | 994 | ||
@@ -993,18 +1000,18 @@ handle_op_fail_event( | |||
993 | * @return newly allocated SlaveGetConfigurationMessage | 1000 | * @return newly allocated SlaveGetConfigurationMessage |
994 | */ | 1001 | */ |
995 | static struct GNUNET_TESTBED_SlaveGetConfigurationMessage * | 1002 | static struct GNUNET_TESTBED_SlaveGetConfigurationMessage * |
996 | GNUNET_TESTBED_generate_slavegetconfig_msg_(uint64_t op_id, uint32_t slave_id) | 1003 | GNUNET_TESTBED_generate_slavegetconfig_msg_ (uint64_t op_id, uint32_t slave_id) |
997 | { | 1004 | { |
998 | struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg; | 1005 | struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg; |
999 | uint16_t msize; | 1006 | uint16_t msize; |
1000 | 1007 | ||
1001 | msize = sizeof(struct GNUNET_TESTBED_SlaveGetConfigurationMessage); | 1008 | msize = sizeof(struct GNUNET_TESTBED_SlaveGetConfigurationMessage); |
1002 | msg = GNUNET_malloc(msize); | 1009 | msg = GNUNET_malloc (msize); |
1003 | msg->header.size = htons(msize); | 1010 | msg->header.size = htons (msize); |
1004 | msg->header.type = | 1011 | msg->header.type = |
1005 | htons(GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION); | 1012 | htons (GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION); |
1006 | msg->operation_id = GNUNET_htonll(op_id); | 1013 | msg->operation_id = GNUNET_htonll (op_id); |
1007 | msg->slave_id = htonl(slave_id); | 1014 | msg->slave_id = htonl (slave_id); |
1008 | return msg; | 1015 | return msg; |
1009 | } | 1016 | } |
1010 | 1017 | ||
@@ -1017,8 +1024,8 @@ GNUNET_TESTBED_generate_slavegetconfig_msg_(uint64_t op_id, uint32_t slave_id) | |||
1017 | * @param msg message received | 1024 | * @param msg message received |
1018 | */ | 1025 | */ |
1019 | static int | 1026 | static int |
1020 | check_slave_config(void *cls, | 1027 | check_slave_config (void *cls, |
1021 | const struct GNUNET_TESTBED_SlaveConfiguration *msg) | 1028 | const struct GNUNET_TESTBED_SlaveConfiguration *msg) |
1022 | { | 1029 | { |
1023 | /* anything goes? */ | 1030 | /* anything goes? */ |
1024 | return GNUNET_OK; | 1031 | return GNUNET_OK; |
@@ -1033,8 +1040,8 @@ check_slave_config(void *cls, | |||
1033 | * @param msg message received | 1040 | * @param msg message received |
1034 | */ | 1041 | */ |
1035 | static void | 1042 | static void |
1036 | handle_slave_config(void *cls, | 1043 | handle_slave_config (void *cls, |
1037 | const struct GNUNET_TESTBED_SlaveConfiguration *msg) | 1044 | const struct GNUNET_TESTBED_SlaveConfiguration *msg) |
1038 | { | 1045 | { |
1039 | struct GNUNET_TESTBED_Controller *c = cls; | 1046 | struct GNUNET_TESTBED_Controller *c = cls; |
1040 | struct OperationContext *opc; | 1047 | struct OperationContext *opc; |
@@ -1042,30 +1049,30 @@ handle_slave_config(void *cls, | |||
1042 | uint64_t mask; | 1049 | uint64_t mask; |
1043 | struct GNUNET_TESTBED_EventInformation event; | 1050 | struct GNUNET_TESTBED_EventInformation event; |
1044 | 1051 | ||
1045 | op_id = GNUNET_ntohll(msg->operation_id); | 1052 | op_id = GNUNET_ntohll (msg->operation_id); |
1046 | if (NULL == (opc = find_opc(c, op_id))) | 1053 | if (NULL == (opc = find_opc (c, op_id))) |
1047 | { | 1054 | { |
1048 | LOG_DEBUG("Operation not found\n"); | 1055 | LOG_DEBUG ("Operation not found\n"); |
1049 | return; | 1056 | return; |
1050 | } | 1057 | } |
1051 | if (OP_GET_SLAVE_CONFIG != opc->type) | 1058 | if (OP_GET_SLAVE_CONFIG != opc->type) |
1052 | { | 1059 | { |
1053 | GNUNET_break(0); | 1060 | GNUNET_break (0); |
1054 | return; | 1061 | return; |
1055 | } | 1062 | } |
1056 | opc->state = OPC_STATE_FINISHED; | 1063 | opc->state = OPC_STATE_FINISHED; |
1057 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 1064 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
1058 | mask = 1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED; | 1065 | mask = 1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED; |
1059 | if ((0 != (mask & c->event_mask)) && (NULL != c->cc)) | 1066 | if ((0 != (mask & c->event_mask)) && (NULL != c->cc)) |
1060 | { | 1067 | { |
1061 | opc->data = GNUNET_TESTBED_extract_config_(&msg->header); | 1068 | opc->data = GNUNET_TESTBED_extract_config_ (&msg->header); |
1062 | event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED; | 1069 | event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED; |
1063 | event.op = opc->op; | 1070 | event.op = opc->op; |
1064 | event.op_cls = opc->op_cls; | 1071 | event.op_cls = opc->op_cls; |
1065 | event.details.operation_finished.generic = opc->data; | 1072 | event.details.operation_finished.generic = opc->data; |
1066 | event.details.operation_finished.emsg = NULL; | 1073 | event.details.operation_finished.emsg = NULL; |
1067 | c->cc(c->cc_cls, &event); | 1074 | c->cc (c->cc_cls, &event); |
1068 | } | 1075 | } |
1069 | } | 1076 | } |
1070 | 1077 | ||
1071 | 1078 | ||
@@ -1078,7 +1085,7 @@ handle_slave_config(void *cls, | |||
1078 | * @return #GNUNET_OK if @a msg is well-formed | 1085 | * @return #GNUNET_OK if @a msg is well-formed |
1079 | */ | 1086 | */ |
1080 | static int | 1087 | static int |
1081 | check_link_controllers_result( | 1088 | check_link_controllers_result ( |
1082 | void *cls, | 1089 | void *cls, |
1083 | const struct GNUNET_TESTBED_ControllerLinkResponse *msg) | 1090 | const struct GNUNET_TESTBED_ControllerLinkResponse *msg) |
1084 | { | 1091 | { |
@@ -1095,7 +1102,7 @@ check_link_controllers_result( | |||
1095 | * @param msg message received | 1102 | * @param msg message received |
1096 | */ | 1103 | */ |
1097 | static void | 1104 | static void |
1098 | handle_link_controllers_result( | 1105 | handle_link_controllers_result ( |
1099 | void *cls, | 1106 | void *cls, |
1100 | const struct GNUNET_TESTBED_ControllerLinkResponse *msg) | 1107 | const struct GNUNET_TESTBED_ControllerLinkResponse *msg) |
1101 | { | 1108 | { |
@@ -1108,31 +1115,31 @@ handle_link_controllers_result( | |||
1108 | uint64_t op_id; | 1115 | uint64_t op_id; |
1109 | struct GNUNET_TESTBED_EventInformation event; | 1116 | struct GNUNET_TESTBED_EventInformation event; |
1110 | 1117 | ||
1111 | op_id = GNUNET_ntohll(msg->operation_id); | 1118 | op_id = GNUNET_ntohll (msg->operation_id); |
1112 | if (NULL == (opc = find_opc(c, op_id))) | 1119 | if (NULL == (opc = find_opc (c, op_id))) |
1113 | { | 1120 | { |
1114 | LOG_DEBUG("Operation not found\n"); | 1121 | LOG_DEBUG ("Operation not found\n"); |
1115 | return; | 1122 | return; |
1116 | } | 1123 | } |
1117 | if (OP_FORWARDED == opc->type) | 1124 | if (OP_FORWARDED == opc->type) |
1118 | { | 1125 | { |
1119 | handle_forwarded_operation_msg(c, | 1126 | handle_forwarded_operation_msg (c, |
1120 | opc, | 1127 | opc, |
1121 | (const struct GNUNET_MessageHeader *)msg); | 1128 | (const struct GNUNET_MessageHeader *) msg); |
1122 | return; | 1129 | return; |
1123 | } | 1130 | } |
1124 | if (OP_LINK_CONTROLLERS != opc->type) | 1131 | if (OP_LINK_CONTROLLERS != opc->type) |
1125 | { | 1132 | { |
1126 | GNUNET_break(0); | 1133 | GNUNET_break (0); |
1127 | return; | 1134 | return; |
1128 | } | 1135 | } |
1129 | GNUNET_assert(NULL != (data = opc->data)); | 1136 | GNUNET_assert (NULL != (data = opc->data)); |
1130 | host = GNUNET_TESTBED_host_lookup_by_id_(data->host_id); | 1137 | host = GNUNET_TESTBED_host_lookup_by_id_ (data->host_id); |
1131 | GNUNET_assert(NULL != host); | 1138 | GNUNET_assert (NULL != host); |
1132 | GNUNET_free(data); | 1139 | GNUNET_free (data); |
1133 | opc->data = NULL; | 1140 | opc->data = NULL; |
1134 | opc->state = OPC_STATE_FINISHED; | 1141 | opc->state = OPC_STATE_FINISHED; |
1135 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 1142 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
1136 | event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED; | 1143 | event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED; |
1137 | event.op = opc->op; | 1144 | event.op = opc->op; |
1138 | event.op_cls = opc->op_cls; | 1145 | event.op_cls = opc->op_cls; |
@@ -1140,37 +1147,38 @@ handle_link_controllers_result( | |||
1140 | event.details.operation_finished.generic = NULL; | 1147 | event.details.operation_finished.generic = NULL; |
1141 | emsg = NULL; | 1148 | emsg = NULL; |
1142 | cfg = NULL; | 1149 | cfg = NULL; |
1143 | if (GNUNET_NO == ntohs(msg->success)) | 1150 | if (GNUNET_NO == ntohs (msg->success)) |
1144 | { | 1151 | { |
1145 | emsg = | 1152 | emsg = |
1146 | GNUNET_malloc(ntohs(msg->header.size) - | 1153 | GNUNET_malloc (ntohs (msg->header.size) |
1147 | sizeof(struct GNUNET_TESTBED_ControllerLinkResponse) + 1); | 1154 | - sizeof(struct GNUNET_TESTBED_ControllerLinkResponse) |
1148 | GNUNET_memcpy(emsg, | 1155 | + 1); |
1149 | &msg[1], | 1156 | GNUNET_memcpy (emsg, |
1150 | ntohs(msg->header.size) - | 1157 | &msg[1], |
1151 | sizeof(struct GNUNET_TESTBED_ControllerLinkResponse)); | 1158 | ntohs (msg->header.size) |
1152 | event.details.operation_finished.emsg = emsg; | 1159 | - sizeof(struct GNUNET_TESTBED_ControllerLinkResponse)); |
1153 | } | 1160 | event.details.operation_finished.emsg = emsg; |
1161 | } | ||
1154 | else | 1162 | else |
1163 | { | ||
1164 | if (0 != ntohs (msg->config_size)) | ||
1155 | { | 1165 | { |
1156 | if (0 != ntohs(msg->config_size)) | 1166 | cfg = GNUNET_TESTBED_extract_config_ ( |
1157 | { | 1167 | (const struct GNUNET_MessageHeader *) msg); |
1158 | cfg = GNUNET_TESTBED_extract_config_( | 1168 | GNUNET_assert (NULL != cfg); |
1159 | (const struct GNUNET_MessageHeader *)msg); | 1169 | GNUNET_TESTBED_host_replace_cfg_ (host, cfg); |
1160 | GNUNET_assert(NULL != cfg); | ||
1161 | GNUNET_TESTBED_host_replace_cfg_(host, cfg); | ||
1162 | } | ||
1163 | } | 1170 | } |
1171 | } | ||
1164 | if (0 != (c->event_mask & (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED))) | 1172 | if (0 != (c->event_mask & (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED))) |
1165 | { | 1173 | { |
1166 | if (NULL != c->cc) | 1174 | if (NULL != c->cc) |
1167 | c->cc(c->cc_cls, &event); | 1175 | c->cc (c->cc_cls, &event); |
1168 | } | 1176 | } |
1169 | else | 1177 | else |
1170 | LOG_DEBUG("Not calling callback\n"); | 1178 | LOG_DEBUG ("Not calling callback\n"); |
1171 | if (NULL != cfg) | 1179 | if (NULL != cfg) |
1172 | GNUNET_CONFIGURATION_destroy(cfg); | 1180 | GNUNET_CONFIGURATION_destroy (cfg); |
1173 | GNUNET_free_non_null(emsg); | 1181 | GNUNET_free_non_null (emsg); |
1174 | } | 1182 | } |
1175 | 1183 | ||
1176 | 1184 | ||
@@ -1184,8 +1192,8 @@ handle_link_controllers_result( | |||
1184 | * down signalling an error (message malformed) | 1192 | * down signalling an error (message malformed) |
1185 | */ | 1193 | */ |
1186 | static int | 1194 | static int |
1187 | check_barrier_status(void *cls, | 1195 | check_barrier_status (void *cls, |
1188 | const struct GNUNET_TESTBED_BarrierStatusMsg *msg) | 1196 | const struct GNUNET_TESTBED_BarrierStatusMsg *msg) |
1189 | { | 1197 | { |
1190 | uint16_t msize; | 1198 | uint16_t msize; |
1191 | uint16_t name_len; | 1199 | uint16_t name_len; |
@@ -1193,31 +1201,31 @@ check_barrier_status(void *cls, | |||
1193 | const char *name; | 1201 | const char *name; |
1194 | size_t emsg_len; | 1202 | size_t emsg_len; |
1195 | 1203 | ||
1196 | msize = ntohs(msg->header.size); | 1204 | msize = ntohs (msg->header.size); |
1197 | name = msg->data; | 1205 | name = msg->data; |
1198 | name_len = ntohs(msg->name_len); | 1206 | name_len = ntohs (msg->name_len); |
1199 | 1207 | ||
1200 | if (sizeof(struct GNUNET_TESTBED_BarrierStatusMsg) + name_len + 1 > msize) | 1208 | if (sizeof(struct GNUNET_TESTBED_BarrierStatusMsg) + name_len + 1 > msize) |
1201 | { | 1209 | { |
1202 | GNUNET_break_op(0); | 1210 | GNUNET_break_op (0); |
1203 | return GNUNET_SYSERR; | 1211 | return GNUNET_SYSERR; |
1204 | } | 1212 | } |
1205 | if ('\0' != name[name_len]) | 1213 | if ('\0' != name[name_len]) |
1206 | { | 1214 | { |
1207 | GNUNET_break_op(0); | 1215 | GNUNET_break_op (0); |
1208 | return GNUNET_SYSERR; | 1216 | return GNUNET_SYSERR; |
1209 | } | 1217 | } |
1210 | status = ntohs(msg->status); | 1218 | status = ntohs (msg->status); |
1211 | if (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status) | 1219 | if (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status) |
1220 | { | ||
1221 | emsg_len = msize - (sizeof(struct GNUNET_TESTBED_BarrierStatusMsg) | ||
1222 | + name_len + 1); /* +1!? */ | ||
1223 | if (0 == emsg_len) | ||
1212 | { | 1224 | { |
1213 | emsg_len = msize - (sizeof(struct GNUNET_TESTBED_BarrierStatusMsg) + | 1225 | GNUNET_break_op (0); |
1214 | name_len + 1); /* +1!? */ | 1226 | return GNUNET_SYSERR; |
1215 | if (0 == emsg_len) | ||
1216 | { | ||
1217 | GNUNET_break_op(0); | ||
1218 | return GNUNET_SYSERR; | ||
1219 | } | ||
1220 | } | 1227 | } |
1228 | } | ||
1221 | return GNUNET_OK; | 1229 | return GNUNET_OK; |
1222 | } | 1230 | } |
1223 | 1231 | ||
@@ -1230,8 +1238,8 @@ check_barrier_status(void *cls, | |||
1230 | * @param msg the barrier status message | 1238 | * @param msg the barrier status message |
1231 | */ | 1239 | */ |
1232 | static void | 1240 | static void |
1233 | handle_barrier_status(void *cls, | 1241 | handle_barrier_status (void *cls, |
1234 | const struct GNUNET_TESTBED_BarrierStatusMsg *msg) | 1242 | const struct GNUNET_TESTBED_BarrierStatusMsg *msg) |
1235 | { | 1243 | { |
1236 | struct GNUNET_TESTBED_Controller *c = cls; | 1244 | struct GNUNET_TESTBED_Controller *c = cls; |
1237 | struct GNUNET_TESTBED_Barrier *barrier; | 1245 | struct GNUNET_TESTBED_Barrier *barrier; |
@@ -1245,68 +1253,68 @@ handle_barrier_status(void *cls, | |||
1245 | 1253 | ||
1246 | emsg = NULL; | 1254 | emsg = NULL; |
1247 | barrier = NULL; | 1255 | barrier = NULL; |
1248 | msize = ntohs(msg->header.size); | 1256 | msize = ntohs (msg->header.size); |
1249 | if (msize <= sizeof(struct GNUNET_TESTBED_BarrierStatusMsg)) | 1257 | if (msize <= sizeof(struct GNUNET_TESTBED_BarrierStatusMsg)) |
1250 | { | 1258 | { |
1251 | GNUNET_break_op(0); | 1259 | GNUNET_break_op (0); |
1252 | goto cleanup; | 1260 | goto cleanup; |
1253 | } | 1261 | } |
1254 | name = msg->data; | 1262 | name = msg->data; |
1255 | name_len = ntohs(msg->name_len); | 1263 | name_len = ntohs (msg->name_len); |
1256 | if (name_len >= //name_len is strlen(barrier_name) | 1264 | if (name_len >= // name_len is strlen(barrier_name) |
1257 | (msize - ((sizeof msg->header) + sizeof(msg->status)))) | 1265 | (msize - ((sizeof msg->header) + sizeof(msg->status)))) |
1258 | { | 1266 | { |
1259 | GNUNET_break_op(0); | 1267 | GNUNET_break_op (0); |
1260 | goto cleanup; | 1268 | goto cleanup; |
1261 | } | 1269 | } |
1262 | if ('\0' != name[name_len]) | 1270 | if ('\0' != name[name_len]) |
1263 | { | 1271 | { |
1264 | GNUNET_break_op(0); | 1272 | GNUNET_break_op (0); |
1265 | goto cleanup; | 1273 | goto cleanup; |
1266 | } | 1274 | } |
1267 | LOG_DEBUG("Received BARRIER_STATUS msg\n"); | 1275 | LOG_DEBUG ("Received BARRIER_STATUS msg\n"); |
1268 | status = ntohs(msg->status); | 1276 | status = ntohs (msg->status); |
1269 | if (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status) | 1277 | if (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status) |
1278 | { | ||
1279 | status = -1; | ||
1280 | // unlike name_len, emsg_len includes the trailing zero | ||
1281 | emsg_len = msize - (sizeof(struct GNUNET_TESTBED_BarrierStatusMsg) | ||
1282 | + (name_len + 1)); | ||
1283 | if (0 == emsg_len) | ||
1270 | { | 1284 | { |
1271 | status = -1; | 1285 | GNUNET_break_op (0); |
1272 | //unlike name_len, emsg_len includes the trailing zero | ||
1273 | emsg_len = msize - (sizeof(struct GNUNET_TESTBED_BarrierStatusMsg) + | ||
1274 | (name_len + 1)); | ||
1275 | if (0 == emsg_len) | ||
1276 | { | ||
1277 | GNUNET_break_op(0); | ||
1278 | goto cleanup; | ||
1279 | } | ||
1280 | if ('\0' != (msg->data[(name_len + 1) + (emsg_len - 1)])) | ||
1281 | { | ||
1282 | GNUNET_break_op(0); | ||
1283 | goto cleanup; | ||
1284 | } | ||
1285 | emsg = GNUNET_malloc(emsg_len); | ||
1286 | GNUNET_memcpy(emsg, msg->data + name_len + 1, emsg_len); | ||
1287 | } | ||
1288 | if (NULL == c->barrier_map) | ||
1289 | { | ||
1290 | GNUNET_break_op(0); | ||
1291 | goto cleanup; | 1286 | goto cleanup; |
1292 | } | 1287 | } |
1293 | GNUNET_CRYPTO_hash(name, name_len, &key); | 1288 | if ('\0' != (msg->data[(name_len + 1) + (emsg_len - 1)])) |
1294 | barrier = GNUNET_CONTAINER_multihashmap_get(c->barrier_map, &key); | ||
1295 | if (NULL == barrier) | ||
1296 | { | 1289 | { |
1297 | GNUNET_break_op(0); | 1290 | GNUNET_break_op (0); |
1298 | goto cleanup; | 1291 | goto cleanup; |
1299 | } | 1292 | } |
1300 | GNUNET_assert(NULL != barrier->cb); | 1293 | emsg = GNUNET_malloc (emsg_len); |
1294 | GNUNET_memcpy (emsg, msg->data + name_len + 1, emsg_len); | ||
1295 | } | ||
1296 | if (NULL == c->barrier_map) | ||
1297 | { | ||
1298 | GNUNET_break_op (0); | ||
1299 | goto cleanup; | ||
1300 | } | ||
1301 | GNUNET_CRYPTO_hash (name, name_len, &key); | ||
1302 | barrier = GNUNET_CONTAINER_multihashmap_get (c->barrier_map, &key); | ||
1303 | if (NULL == barrier) | ||
1304 | { | ||
1305 | GNUNET_break_op (0); | ||
1306 | goto cleanup; | ||
1307 | } | ||
1308 | GNUNET_assert (NULL != barrier->cb); | ||
1301 | if ((GNUNET_YES == barrier->echo) && | 1309 | if ((GNUNET_YES == barrier->echo) && |
1302 | (GNUNET_TESTBED_BARRIERSTATUS_CROSSED == status)) | 1310 | (GNUNET_TESTBED_BARRIERSTATUS_CROSSED == status)) |
1303 | GNUNET_TESTBED_queue_message_(c, GNUNET_copy_message(&msg->header)); | 1311 | GNUNET_TESTBED_queue_message_ (c, GNUNET_copy_message (&msg->header)); |
1304 | barrier->cb(barrier->cls, name, barrier, status, emsg); | 1312 | barrier->cb (barrier->cls, name, barrier, status, emsg); |
1305 | if (GNUNET_TESTBED_BARRIERSTATUS_INITIALISED == status) | 1313 | if (GNUNET_TESTBED_BARRIERSTATUS_INITIALISED == status) |
1306 | return; /* just initialised; skip cleanup */ | 1314 | return; /* just initialised; skip cleanup */ |
1307 | 1315 | ||
1308 | cleanup: | 1316 | cleanup: |
1309 | GNUNET_free_non_null(emsg); | 1317 | GNUNET_free_non_null (emsg); |
1310 | /** | 1318 | /** |
1311 | * Do not remove the barrier if we did not echo the status back; this is | 1319 | * Do not remove the barrier if we did not echo the status back; this is |
1312 | * required at the chained testbed controller setup to ensure the only the | 1320 | * required at the chained testbed controller setup to ensure the only the |
@@ -1314,7 +1322,7 @@ cleanup: | |||
1314 | * propagates the status. | 1322 | * propagates the status. |
1315 | */ | 1323 | */ |
1316 | if ((NULL != barrier) && (GNUNET_YES == barrier->echo)) | 1324 | if ((NULL != barrier) && (GNUNET_YES == barrier->echo)) |
1317 | GNUNET_TESTBED_barrier_remove_(barrier); | 1325 | GNUNET_TESTBED_barrier_remove_ (barrier); |
1318 | } | 1326 | } |
1319 | 1327 | ||
1320 | 1328 | ||
@@ -1325,22 +1333,22 @@ cleanup: | |||
1325 | * @param msg the message to queue | 1333 | * @param msg the message to queue |
1326 | */ | 1334 | */ |
1327 | void | 1335 | void |
1328 | GNUNET_TESTBED_queue_message_(struct GNUNET_TESTBED_Controller *controller, | 1336 | GNUNET_TESTBED_queue_message_ (struct GNUNET_TESTBED_Controller *controller, |
1329 | struct GNUNET_MessageHeader *msg) | 1337 | struct GNUNET_MessageHeader *msg) |
1330 | { | 1338 | { |
1331 | struct GNUNET_MQ_Envelope *env; | 1339 | struct GNUNET_MQ_Envelope *env; |
1332 | struct GNUNET_MessageHeader *m2; | 1340 | struct GNUNET_MessageHeader *m2; |
1333 | uint16_t type; | 1341 | uint16_t type; |
1334 | uint16_t size; | 1342 | uint16_t size; |
1335 | 1343 | ||
1336 | type = ntohs(msg->type); | 1344 | type = ntohs (msg->type); |
1337 | size = ntohs(msg->size); | 1345 | size = ntohs (msg->size); |
1338 | GNUNET_assert((GNUNET_MESSAGE_TYPE_TESTBED_INIT <= type) && | 1346 | GNUNET_assert ((GNUNET_MESSAGE_TYPE_TESTBED_INIT <= type) && |
1339 | (GNUNET_MESSAGE_TYPE_TESTBED_MAX > type)); | 1347 | (GNUNET_MESSAGE_TYPE_TESTBED_MAX > type)); |
1340 | env = GNUNET_MQ_msg_extra(m2, size - sizeof(*m2), type); | 1348 | env = GNUNET_MQ_msg_extra (m2, size - sizeof(*m2), type); |
1341 | GNUNET_memcpy(m2, msg, size); | 1349 | GNUNET_memcpy (m2, msg, size); |
1342 | GNUNET_free(msg); | 1350 | GNUNET_free (msg); |
1343 | GNUNET_MQ_send(controller->mq, env); | 1351 | GNUNET_MQ_send (controller->mq, env); |
1344 | } | 1352 | } |
1345 | 1353 | ||
1346 | 1354 | ||
@@ -1359,7 +1367,7 @@ GNUNET_TESTBED_queue_message_(struct GNUNET_TESTBED_Controller *controller, | |||
1359 | * operation | 1367 | * operation |
1360 | */ | 1368 | */ |
1361 | struct OperationContext * | 1369 | struct OperationContext * |
1362 | GNUNET_TESTBED_forward_operation_msg_( | 1370 | GNUNET_TESTBED_forward_operation_msg_ ( |
1363 | struct GNUNET_TESTBED_Controller *controller, | 1371 | struct GNUNET_TESTBED_Controller *controller, |
1364 | uint64_t operation_id, | 1372 | uint64_t operation_id, |
1365 | const struct GNUNET_MessageHeader *msg, | 1373 | const struct GNUNET_MessageHeader *msg, |
@@ -1370,21 +1378,21 @@ GNUNET_TESTBED_forward_operation_msg_( | |||
1370 | struct ForwardedOperationData *data; | 1378 | struct ForwardedOperationData *data; |
1371 | struct GNUNET_MQ_Envelope *env; | 1379 | struct GNUNET_MQ_Envelope *env; |
1372 | struct GNUNET_MessageHeader *m2; | 1380 | struct GNUNET_MessageHeader *m2; |
1373 | uint16_t type = ntohs(msg->type); | 1381 | uint16_t type = ntohs (msg->type); |
1374 | uint16_t size = ntohs(msg->size); | 1382 | uint16_t size = ntohs (msg->size); |
1375 | 1383 | ||
1376 | env = GNUNET_MQ_msg_extra(m2, size - sizeof(*m2), type); | 1384 | env = GNUNET_MQ_msg_extra (m2, size - sizeof(*m2), type); |
1377 | GNUNET_memcpy(m2, msg, size); | 1385 | GNUNET_memcpy (m2, msg, size); |
1378 | GNUNET_MQ_send(controller->mq, env); | 1386 | GNUNET_MQ_send (controller->mq, env); |
1379 | data = GNUNET_new(struct ForwardedOperationData); | 1387 | data = GNUNET_new (struct ForwardedOperationData); |
1380 | data->cc = cc; | 1388 | data->cc = cc; |
1381 | data->cc_cls = cc_cls; | 1389 | data->cc_cls = cc_cls; |
1382 | opc = GNUNET_new(struct OperationContext); | 1390 | opc = GNUNET_new (struct OperationContext); |
1383 | opc->c = controller; | 1391 | opc->c = controller; |
1384 | opc->type = OP_FORWARDED; | 1392 | opc->type = OP_FORWARDED; |
1385 | opc->data = data; | 1393 | opc->data = data; |
1386 | opc->id = operation_id; | 1394 | opc->id = operation_id; |
1387 | GNUNET_TESTBED_insert_opc_(controller, opc); | 1395 | GNUNET_TESTBED_insert_opc_ (controller, opc); |
1388 | return opc; | 1396 | return opc; |
1389 | } | 1397 | } |
1390 | 1398 | ||
@@ -1396,11 +1404,11 @@ GNUNET_TESTBED_forward_operation_msg_( | |||
1396 | * @param opc the operation context from GNUNET_TESTBED_forward_operation_msg_() | 1404 | * @param opc the operation context from GNUNET_TESTBED_forward_operation_msg_() |
1397 | */ | 1405 | */ |
1398 | void | 1406 | void |
1399 | GNUNET_TESTBED_forward_operation_msg_cancel_(struct OperationContext *opc) | 1407 | GNUNET_TESTBED_forward_operation_msg_cancel_ (struct OperationContext *opc) |
1400 | { | 1408 | { |
1401 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 1409 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
1402 | GNUNET_free(opc->data); | 1410 | GNUNET_free (opc->data); |
1403 | GNUNET_free(opc); | 1411 | GNUNET_free (opc); |
1404 | } | 1412 | } |
1405 | 1413 | ||
1406 | 1414 | ||
@@ -1411,19 +1419,19 @@ GNUNET_TESTBED_forward_operation_msg_cancel_(struct OperationContext *opc) | |||
1411 | * @param cls the closure from GNUNET_TESTBED_operation_create_() | 1419 | * @param cls the closure from GNUNET_TESTBED_operation_create_() |
1412 | */ | 1420 | */ |
1413 | static void | 1421 | static void |
1414 | opstart_link_controllers(void *cls) | 1422 | opstart_link_controllers (void *cls) |
1415 | { | 1423 | { |
1416 | struct OperationContext *opc = cls; | 1424 | struct OperationContext *opc = cls; |
1417 | struct ControllerLinkData *data; | 1425 | struct ControllerLinkData *data; |
1418 | struct GNUNET_TESTBED_ControllerLinkRequest *msg; | 1426 | struct GNUNET_TESTBED_ControllerLinkRequest *msg; |
1419 | 1427 | ||
1420 | GNUNET_assert(NULL != opc->data); | 1428 | GNUNET_assert (NULL != opc->data); |
1421 | data = opc->data; | 1429 | data = opc->data; |
1422 | msg = data->msg; | 1430 | msg = data->msg; |
1423 | data->msg = NULL; | 1431 | data->msg = NULL; |
1424 | opc->state = OPC_STATE_STARTED; | 1432 | opc->state = OPC_STATE_STARTED; |
1425 | GNUNET_TESTBED_insert_opc_(opc->c, opc); | 1433 | GNUNET_TESTBED_insert_opc_ (opc->c, opc); |
1426 | GNUNET_TESTBED_queue_message_(opc->c, &msg->header); | 1434 | GNUNET_TESTBED_queue_message_ (opc->c, &msg->header); |
1427 | } | 1435 | } |
1428 | 1436 | ||
1429 | 1437 | ||
@@ -1433,27 +1441,27 @@ opstart_link_controllers(void *cls) | |||
1433 | * @param cls the closure from GNUNET_TESTBED_operation_create_() | 1441 | * @param cls the closure from GNUNET_TESTBED_operation_create_() |
1434 | */ | 1442 | */ |
1435 | static void | 1443 | static void |
1436 | oprelease_link_controllers(void *cls) | 1444 | oprelease_link_controllers (void *cls) |
1437 | { | 1445 | { |
1438 | struct OperationContext *opc = cls; | 1446 | struct OperationContext *opc = cls; |
1439 | struct ControllerLinkData *data; | 1447 | struct ControllerLinkData *data; |
1440 | 1448 | ||
1441 | data = opc->data; | 1449 | data = opc->data; |
1442 | switch (opc->state) | 1450 | switch (opc->state) |
1443 | { | 1451 | { |
1444 | case OPC_STATE_INIT: | 1452 | case OPC_STATE_INIT: |
1445 | GNUNET_free(data->msg); | 1453 | GNUNET_free (data->msg); |
1446 | break; | 1454 | break; |
1447 | 1455 | ||
1448 | case OPC_STATE_STARTED: | 1456 | case OPC_STATE_STARTED: |
1449 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 1457 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
1450 | break; | 1458 | break; |
1451 | 1459 | ||
1452 | case OPC_STATE_FINISHED: | 1460 | case OPC_STATE_FINISHED: |
1453 | break; | 1461 | break; |
1454 | } | 1462 | } |
1455 | GNUNET_free_non_null(data); | 1463 | GNUNET_free_non_null (data); |
1456 | GNUNET_free(opc); | 1464 | GNUNET_free (opc); |
1457 | } | 1465 | } |
1458 | 1466 | ||
1459 | 1467 | ||
@@ -1463,19 +1471,19 @@ oprelease_link_controllers(void *cls) | |||
1463 | * @param cls the OperationContext of type OP_GET_SLAVE_CONFIG | 1471 | * @param cls the OperationContext of type OP_GET_SLAVE_CONFIG |
1464 | */ | 1472 | */ |
1465 | static void | 1473 | static void |
1466 | opstart_get_slave_config(void *cls) | 1474 | opstart_get_slave_config (void *cls) |
1467 | { | 1475 | { |
1468 | struct OperationContext *opc = cls; | 1476 | struct OperationContext *opc = cls; |
1469 | struct GetSlaveConfigData *data = opc->data; | 1477 | struct GetSlaveConfigData *data = opc->data; |
1470 | struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg; | 1478 | struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg; |
1471 | 1479 | ||
1472 | GNUNET_assert(NULL != data); | 1480 | GNUNET_assert (NULL != data); |
1473 | msg = GNUNET_TESTBED_generate_slavegetconfig_msg_(opc->id, data->slave_id); | 1481 | msg = GNUNET_TESTBED_generate_slavegetconfig_msg_ (opc->id, data->slave_id); |
1474 | GNUNET_free(opc->data); | 1482 | GNUNET_free (opc->data); |
1475 | data = NULL; | 1483 | data = NULL; |
1476 | opc->data = NULL; | 1484 | opc->data = NULL; |
1477 | GNUNET_TESTBED_insert_opc_(opc->c, opc); | 1485 | GNUNET_TESTBED_insert_opc_ (opc->c, opc); |
1478 | GNUNET_TESTBED_queue_message_(opc->c, &msg->header); | 1486 | GNUNET_TESTBED_queue_message_ (opc->c, &msg->header); |
1479 | opc->state = OPC_STATE_STARTED; | 1487 | opc->state = OPC_STATE_STARTED; |
1480 | } | 1488 | } |
1481 | 1489 | ||
@@ -1486,26 +1494,26 @@ opstart_get_slave_config(void *cls) | |||
1486 | * @param cls the OperationContext of type OP_GET_SLAVE_CONFIG | 1494 | * @param cls the OperationContext of type OP_GET_SLAVE_CONFIG |
1487 | */ | 1495 | */ |
1488 | static void | 1496 | static void |
1489 | oprelease_get_slave_config(void *cls) | 1497 | oprelease_get_slave_config (void *cls) |
1490 | { | 1498 | { |
1491 | struct OperationContext *opc = cls; | 1499 | struct OperationContext *opc = cls; |
1492 | 1500 | ||
1493 | switch (opc->state) | 1501 | switch (opc->state) |
1494 | { | 1502 | { |
1495 | case OPC_STATE_INIT: | 1503 | case OPC_STATE_INIT: |
1496 | GNUNET_free(opc->data); | 1504 | GNUNET_free (opc->data); |
1497 | break; | 1505 | break; |
1498 | 1506 | ||
1499 | case OPC_STATE_STARTED: | 1507 | case OPC_STATE_STARTED: |
1500 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 1508 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
1501 | break; | 1509 | break; |
1502 | 1510 | ||
1503 | case OPC_STATE_FINISHED: | 1511 | case OPC_STATE_FINISHED: |
1504 | if (NULL != opc->data) | 1512 | if (NULL != opc->data) |
1505 | GNUNET_CONFIGURATION_destroy(opc->data); | 1513 | GNUNET_CONFIGURATION_destroy (opc->data); |
1506 | break; | 1514 | break; |
1507 | } | 1515 | } |
1508 | GNUNET_free(opc); | 1516 | GNUNET_free (opc); |
1509 | } | 1517 | } |
1510 | 1518 | ||
1511 | 1519 | ||
@@ -1518,13 +1526,13 @@ oprelease_get_slave_config(void *cls) | |||
1518 | * @param error error code | 1526 | * @param error error code |
1519 | */ | 1527 | */ |
1520 | static void | 1528 | static void |
1521 | mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | 1529 | mq_error_handler (void *cls, enum GNUNET_MQ_Error error) |
1522 | { | 1530 | { |
1523 | /* struct GNUNET_TESTBED_Controller *c = cls; */ | 1531 | /* struct GNUNET_TESTBED_Controller *c = cls; */ |
1524 | 1532 | ||
1525 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Encountered MQ error: %d\n", error); | 1533 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Encountered MQ error: %d\n", error); |
1526 | /* now what? */ | 1534 | /* now what? */ |
1527 | GNUNET_SCHEDULER_shutdown(); /* seems most reasonable */ | 1535 | GNUNET_SCHEDULER_shutdown (); /* seems most reasonable */ |
1528 | } | 1536 | } |
1529 | 1537 | ||
1530 | 1538 | ||
@@ -1544,58 +1552,58 @@ mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | |||
1544 | * @return handle to the controller | 1552 | * @return handle to the controller |
1545 | */ | 1553 | */ |
1546 | struct GNUNET_TESTBED_Controller * | 1554 | struct GNUNET_TESTBED_Controller * |
1547 | GNUNET_TESTBED_controller_connect(struct GNUNET_TESTBED_Host *host, | 1555 | GNUNET_TESTBED_controller_connect (struct GNUNET_TESTBED_Host *host, |
1548 | uint64_t event_mask, | 1556 | uint64_t event_mask, |
1549 | GNUNET_TESTBED_ControllerCallback cc, | 1557 | GNUNET_TESTBED_ControllerCallback cc, |
1550 | void *cc_cls) | 1558 | void *cc_cls) |
1551 | { | 1559 | { |
1552 | struct GNUNET_TESTBED_Controller *controller = | 1560 | struct GNUNET_TESTBED_Controller *controller = |
1553 | GNUNET_new(struct GNUNET_TESTBED_Controller); | 1561 | GNUNET_new (struct GNUNET_TESTBED_Controller); |
1554 | struct GNUNET_MQ_MessageHandler handlers[] = | 1562 | struct GNUNET_MQ_MessageHandler handlers[] = |
1555 | { GNUNET_MQ_hd_var_size(add_host_confirm, | 1563 | { GNUNET_MQ_hd_var_size (add_host_confirm, |
1556 | GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS, | 1564 | GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS, |
1557 | struct GNUNET_TESTBED_HostConfirmedMessage, | 1565 | struct GNUNET_TESTBED_HostConfirmedMessage, |
1558 | controller), | 1566 | controller), |
1559 | GNUNET_MQ_hd_fixed_size(peer_conevent, | 1567 | GNUNET_MQ_hd_fixed_size (peer_conevent, |
1560 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT, | 1568 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT, |
1561 | struct GNUNET_TESTBED_ConnectionEventMessage, | 1569 | struct GNUNET_TESTBED_ConnectionEventMessage, |
1562 | controller), | 1570 | controller), |
1563 | GNUNET_MQ_hd_fixed_size(opsuccess, | 1571 | GNUNET_MQ_hd_fixed_size (opsuccess, |
1564 | GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS, | 1572 | GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS, |
1565 | struct | 1573 | struct |
1566 | GNUNET_TESTBED_GenericOperationSuccessEventMessage, | 1574 | GNUNET_TESTBED_GenericOperationSuccessEventMessage, |
1567 | controller), | 1575 | controller), |
1568 | GNUNET_MQ_hd_var_size(op_fail_event, | 1576 | GNUNET_MQ_hd_var_size (op_fail_event, |
1569 | GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT, | 1577 | GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT, |
1570 | struct GNUNET_TESTBED_OperationFailureEventMessage, | 1578 | struct GNUNET_TESTBED_OperationFailureEventMessage, |
1571 | controller), | 1579 | controller), |
1572 | GNUNET_MQ_hd_fixed_size(peer_create_success, | 1580 | GNUNET_MQ_hd_fixed_size (peer_create_success, |
1573 | GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS, | 1581 | GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS, |
1574 | struct | 1582 | struct |
1575 | GNUNET_TESTBED_PeerCreateSuccessEventMessage, | 1583 | GNUNET_TESTBED_PeerCreateSuccessEventMessage, |
1576 | controller), | 1584 | controller), |
1577 | GNUNET_MQ_hd_fixed_size(peer_event, | 1585 | GNUNET_MQ_hd_fixed_size (peer_event, |
1578 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT, | 1586 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT, |
1579 | struct GNUNET_TESTBED_PeerEventMessage, | 1587 | struct GNUNET_TESTBED_PeerEventMessage, |
1580 | controller), | 1588 | controller), |
1581 | GNUNET_MQ_hd_var_size(peer_config, | 1589 | GNUNET_MQ_hd_var_size (peer_config, |
1582 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION, | 1590 | GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION, |
1583 | struct | 1591 | struct |
1584 | GNUNET_TESTBED_PeerConfigurationInformationMessage, | 1592 | GNUNET_TESTBED_PeerConfigurationInformationMessage, |
1585 | controller), | 1593 | controller), |
1586 | GNUNET_MQ_hd_var_size(slave_config, | 1594 | GNUNET_MQ_hd_var_size (slave_config, |
1587 | GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION, | 1595 | GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION, |
1588 | struct GNUNET_TESTBED_SlaveConfiguration, | 1596 | struct GNUNET_TESTBED_SlaveConfiguration, |
1589 | controller), | 1597 | controller), |
1590 | GNUNET_MQ_hd_var_size(link_controllers_result, | 1598 | GNUNET_MQ_hd_var_size (link_controllers_result, |
1591 | GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT, | 1599 | GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT, |
1592 | struct GNUNET_TESTBED_ControllerLinkResponse, | 1600 | struct GNUNET_TESTBED_ControllerLinkResponse, |
1593 | controller), | 1601 | controller), |
1594 | GNUNET_MQ_hd_var_size(barrier_status, | 1602 | GNUNET_MQ_hd_var_size (barrier_status, |
1595 | GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS, | 1603 | GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS, |
1596 | struct GNUNET_TESTBED_BarrierStatusMsg, | 1604 | struct GNUNET_TESTBED_BarrierStatusMsg, |
1597 | controller), | 1605 | controller), |
1598 | GNUNET_MQ_handler_end() }; | 1606 | GNUNET_MQ_handler_end () }; |
1599 | struct GNUNET_TESTBED_InitMessage *msg; | 1607 | struct GNUNET_TESTBED_InitMessage *msg; |
1600 | struct GNUNET_MQ_Envelope *env; | 1608 | struct GNUNET_MQ_Envelope *env; |
1601 | const struct GNUNET_CONFIGURATION_Handle *cfg; | 1609 | const struct GNUNET_CONFIGURATION_Handle *cfg; |
@@ -1605,75 +1613,75 @@ GNUNET_TESTBED_controller_connect(struct GNUNET_TESTBED_Host *host, | |||
1605 | unsigned long long max_parallel_topology_config_operations; | 1613 | unsigned long long max_parallel_topology_config_operations; |
1606 | size_t slen; | 1614 | size_t slen; |
1607 | 1615 | ||
1608 | GNUNET_assert(NULL != (cfg = GNUNET_TESTBED_host_get_cfg_(host))); | 1616 | GNUNET_assert (NULL != (cfg = GNUNET_TESTBED_host_get_cfg_ (host))); |
1609 | if (GNUNET_OK != | 1617 | if (GNUNET_OK != |
1610 | GNUNET_CONFIGURATION_get_value_number(cfg, | 1618 | GNUNET_CONFIGURATION_get_value_number (cfg, |
1611 | "testbed", | 1619 | "testbed", |
1612 | "MAX_PARALLEL_OPERATIONS", | 1620 | "MAX_PARALLEL_OPERATIONS", |
1613 | &max_parallel_operations)) | 1621 | &max_parallel_operations)) |
1614 | { | 1622 | { |
1615 | GNUNET_break(0); | 1623 | GNUNET_break (0); |
1616 | GNUNET_free(controller); | 1624 | GNUNET_free (controller); |
1617 | return NULL; | 1625 | return NULL; |
1618 | } | 1626 | } |
1619 | if (GNUNET_OK != | 1627 | if (GNUNET_OK != |
1620 | GNUNET_CONFIGURATION_get_value_number(cfg, | 1628 | GNUNET_CONFIGURATION_get_value_number (cfg, |
1621 | "testbed", | 1629 | "testbed", |
1622 | "MAX_PARALLEL_SERVICE_CONNECTIONS", | 1630 | "MAX_PARALLEL_SERVICE_CONNECTIONS", |
1623 | &max_parallel_service_connections)) | 1631 | &max_parallel_service_connections)) |
1624 | { | 1632 | { |
1625 | GNUNET_break(0); | 1633 | GNUNET_break (0); |
1626 | GNUNET_free(controller); | 1634 | GNUNET_free (controller); |
1627 | return NULL; | 1635 | return NULL; |
1628 | } | 1636 | } |
1629 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number( | 1637 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number ( |
1630 | cfg, | 1638 | cfg, |
1631 | "testbed", | 1639 | "testbed", |
1632 | "MAX_PARALLEL_TOPOLOGY_CONFIG_OPERATIONS", | 1640 | "MAX_PARALLEL_TOPOLOGY_CONFIG_OPERATIONS", |
1633 | &max_parallel_topology_config_operations)) | 1641 | &max_parallel_topology_config_operations)) |
1634 | { | 1642 | { |
1635 | GNUNET_break(0); | 1643 | GNUNET_break (0); |
1636 | GNUNET_free(controller); | 1644 | GNUNET_free (controller); |
1637 | return NULL; | 1645 | return NULL; |
1638 | } | 1646 | } |
1639 | controller->cc = cc; | 1647 | controller->cc = cc; |
1640 | controller->cc_cls = cc_cls; | 1648 | controller->cc_cls = cc_cls; |
1641 | controller->event_mask = event_mask; | 1649 | controller->event_mask = event_mask; |
1642 | controller->cfg = GNUNET_CONFIGURATION_dup(cfg); | 1650 | controller->cfg = GNUNET_CONFIGURATION_dup (cfg); |
1643 | controller->mq = GNUNET_CLIENT_connect(controller->cfg, | 1651 | controller->mq = GNUNET_CLIENT_connect (controller->cfg, |
1644 | "testbed", | 1652 | "testbed", |
1645 | handlers, | 1653 | handlers, |
1646 | &mq_error_handler, | 1654 | &mq_error_handler, |
1647 | controller); | 1655 | controller); |
1648 | if (NULL == controller->mq) | 1656 | if (NULL == controller->mq) |
1649 | { | 1657 | { |
1650 | GNUNET_break(0); | 1658 | GNUNET_break (0); |
1651 | GNUNET_TESTBED_controller_disconnect(controller); | 1659 | GNUNET_TESTBED_controller_disconnect (controller); |
1652 | return NULL; | 1660 | return NULL; |
1653 | } | 1661 | } |
1654 | GNUNET_TESTBED_mark_host_registered_at_(host, controller); | 1662 | GNUNET_TESTBED_mark_host_registered_at_ (host, controller); |
1655 | controller->host = host; | 1663 | controller->host = host; |
1656 | controller->opq_parallel_operations = | 1664 | controller->opq_parallel_operations = |
1657 | GNUNET_TESTBED_operation_queue_create_(OPERATION_QUEUE_TYPE_FIXED, | 1665 | GNUNET_TESTBED_operation_queue_create_ (OPERATION_QUEUE_TYPE_FIXED, |
1658 | (unsigned int) | 1666 | (unsigned int) |
1659 | max_parallel_operations); | 1667 | max_parallel_operations); |
1660 | controller->opq_parallel_service_connections = | 1668 | controller->opq_parallel_service_connections = |
1661 | GNUNET_TESTBED_operation_queue_create_(OPERATION_QUEUE_TYPE_FIXED, | 1669 | GNUNET_TESTBED_operation_queue_create_ (OPERATION_QUEUE_TYPE_FIXED, |
1662 | (unsigned int) | 1670 | (unsigned int) |
1663 | max_parallel_service_connections); | 1671 | max_parallel_service_connections); |
1664 | controller->opq_parallel_topology_config_operations = | 1672 | controller->opq_parallel_topology_config_operations = |
1665 | GNUNET_TESTBED_operation_queue_create_( | 1673 | GNUNET_TESTBED_operation_queue_create_ ( |
1666 | OPERATION_QUEUE_TYPE_FIXED, | 1674 | OPERATION_QUEUE_TYPE_FIXED, |
1667 | (unsigned int)max_parallel_topology_config_operations); | 1675 | (unsigned int) max_parallel_topology_config_operations); |
1668 | controller_hostname = GNUNET_TESTBED_host_get_hostname(host); | 1676 | controller_hostname = GNUNET_TESTBED_host_get_hostname (host); |
1669 | if (NULL == controller_hostname) | 1677 | if (NULL == controller_hostname) |
1670 | controller_hostname = "127.0.0.1"; | 1678 | controller_hostname = "127.0.0.1"; |
1671 | slen = strlen(controller_hostname) + 1; | 1679 | slen = strlen (controller_hostname) + 1; |
1672 | env = GNUNET_MQ_msg_extra(msg, slen, GNUNET_MESSAGE_TYPE_TESTBED_INIT); | 1680 | env = GNUNET_MQ_msg_extra (msg, slen, GNUNET_MESSAGE_TYPE_TESTBED_INIT); |
1673 | msg->host_id = htonl(GNUNET_TESTBED_host_get_id_(host)); | 1681 | msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (host)); |
1674 | msg->event_mask = GNUNET_htonll(controller->event_mask); | 1682 | msg->event_mask = GNUNET_htonll (controller->event_mask); |
1675 | GNUNET_memcpy(&msg[1], controller_hostname, slen); | 1683 | GNUNET_memcpy (&msg[1], controller_hostname, slen); |
1676 | GNUNET_MQ_send(controller->mq, env); | 1684 | GNUNET_MQ_send (controller->mq, env); |
1677 | return controller; | 1685 | return controller; |
1678 | } | 1686 | } |
1679 | 1687 | ||
@@ -1688,16 +1696,16 @@ GNUNET_TESTBED_controller_connect(struct GNUNET_TESTBED_Host *host, | |||
1688 | * #GNUNET_NO if not. | 1696 | * #GNUNET_NO if not. |
1689 | */ | 1697 | */ |
1690 | static int | 1698 | static int |
1691 | opc_free_iterator(void *cls, uint32_t key, void *value) | 1699 | opc_free_iterator (void *cls, uint32_t key, void *value) |
1692 | { | 1700 | { |
1693 | struct GNUNET_CONTAINER_MultiHashMap32 *map = cls; | 1701 | struct GNUNET_CONTAINER_MultiHashMap32 *map = cls; |
1694 | struct OperationContext *opc = value; | 1702 | struct OperationContext *opc = value; |
1695 | 1703 | ||
1696 | GNUNET_assert(NULL != opc); | 1704 | GNUNET_assert (NULL != opc); |
1697 | GNUNET_break(0); | 1705 | GNUNET_break (0); |
1698 | GNUNET_assert(GNUNET_YES == | 1706 | GNUNET_assert (GNUNET_YES == |
1699 | GNUNET_CONTAINER_multihashmap32_remove(map, key, value)); | 1707 | GNUNET_CONTAINER_multihashmap32_remove (map, key, value)); |
1700 | GNUNET_free(opc); | 1708 | GNUNET_free (opc); |
1701 | return GNUNET_YES; | 1709 | return GNUNET_YES; |
1702 | } | 1710 | } |
1703 | 1711 | ||
@@ -1710,30 +1718,30 @@ opc_free_iterator(void *cls, uint32_t key, void *value) | |||
1710 | * @param c handle to controller to stop | 1718 | * @param c handle to controller to stop |
1711 | */ | 1719 | */ |
1712 | void | 1720 | void |
1713 | GNUNET_TESTBED_controller_disconnect(struct GNUNET_TESTBED_Controller *c) | 1721 | GNUNET_TESTBED_controller_disconnect (struct GNUNET_TESTBED_Controller *c) |
1714 | { | 1722 | { |
1715 | if (NULL != c->mq) | 1723 | if (NULL != c->mq) |
1716 | { | 1724 | { |
1717 | GNUNET_MQ_destroy(c->mq); | 1725 | GNUNET_MQ_destroy (c->mq); |
1718 | c->mq = NULL; | 1726 | c->mq = NULL; |
1719 | } | 1727 | } |
1720 | if (NULL != c->host) | 1728 | if (NULL != c->host) |
1721 | GNUNET_TESTBED_deregister_host_at_(c->host, c); | 1729 | GNUNET_TESTBED_deregister_host_at_ (c->host, c); |
1722 | GNUNET_CONFIGURATION_destroy(c->cfg); | 1730 | GNUNET_CONFIGURATION_destroy (c->cfg); |
1723 | GNUNET_TESTBED_operation_queue_destroy_(c->opq_parallel_operations); | 1731 | GNUNET_TESTBED_operation_queue_destroy_ (c->opq_parallel_operations); |
1724 | GNUNET_TESTBED_operation_queue_destroy_(c->opq_parallel_service_connections); | 1732 | GNUNET_TESTBED_operation_queue_destroy_ (c->opq_parallel_service_connections); |
1725 | GNUNET_TESTBED_operation_queue_destroy_( | 1733 | GNUNET_TESTBED_operation_queue_destroy_ ( |
1726 | c->opq_parallel_topology_config_operations); | 1734 | c->opq_parallel_topology_config_operations); |
1727 | if (NULL != c->opc_map) | 1735 | if (NULL != c->opc_map) |
1728 | { | 1736 | { |
1729 | GNUNET_assert(GNUNET_SYSERR != | 1737 | GNUNET_assert (GNUNET_SYSERR != |
1730 | GNUNET_CONTAINER_multihashmap32_iterate(c->opc_map, | 1738 | GNUNET_CONTAINER_multihashmap32_iterate (c->opc_map, |
1731 | &opc_free_iterator, | 1739 | &opc_free_iterator, |
1732 | c->opc_map)); | 1740 | c->opc_map)); |
1733 | GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap32_size(c->opc_map)); | 1741 | GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap32_size (c->opc_map)); |
1734 | GNUNET_CONTAINER_multihashmap32_destroy(c->opc_map); | 1742 | GNUNET_CONTAINER_multihashmap32_destroy (c->opc_map); |
1735 | } | 1743 | } |
1736 | GNUNET_free(c); | 1744 | GNUNET_free (c); |
1737 | } | 1745 | } |
1738 | 1746 | ||
1739 | 1747 | ||
@@ -1747,19 +1755,19 @@ GNUNET_TESTBED_controller_disconnect(struct GNUNET_TESTBED_Controller *c) | |||
1747 | * @return the size of the xconfig | 1755 | * @return the size of the xconfig |
1748 | */ | 1756 | */ |
1749 | size_t | 1757 | size_t |
1750 | GNUNET_TESTBED_compress_config_(const char *config, | 1758 | GNUNET_TESTBED_compress_config_ (const char *config, |
1751 | size_t size, | 1759 | size_t size, |
1752 | char **xconfig) | 1760 | char **xconfig) |
1753 | { | 1761 | { |
1754 | size_t xsize; | 1762 | size_t xsize; |
1755 | 1763 | ||
1756 | xsize = compressBound((uLong)size); | 1764 | xsize = compressBound ((uLong) size); |
1757 | *xconfig = GNUNET_malloc(xsize); | 1765 | *xconfig = GNUNET_malloc (xsize); |
1758 | GNUNET_assert(Z_OK == compress2((Bytef *)*xconfig, | 1766 | GNUNET_assert (Z_OK == compress2 ((Bytef *) *xconfig, |
1759 | (uLongf *)&xsize, | 1767 | (uLongf *) &xsize, |
1760 | (const Bytef *)config, | 1768 | (const Bytef *) config, |
1761 | (uLongf)size, | 1769 | (uLongf) size, |
1762 | Z_BEST_SPEED)); | 1770 | Z_BEST_SPEED)); |
1763 | return xsize; | 1771 | return xsize; |
1764 | } | 1772 | } |
1765 | 1773 | ||
@@ -1774,18 +1782,18 @@ GNUNET_TESTBED_compress_config_(const char *config, | |||
1774 | * @return the serialized and compressed configuration | 1782 | * @return the serialized and compressed configuration |
1775 | */ | 1783 | */ |
1776 | char * | 1784 | char * |
1777 | GNUNET_TESTBED_compress_cfg_(const struct GNUNET_CONFIGURATION_Handle *cfg, | 1785 | GNUNET_TESTBED_compress_cfg_ (const struct GNUNET_CONFIGURATION_Handle *cfg, |
1778 | size_t *size, | 1786 | size_t *size, |
1779 | size_t *xsize) | 1787 | size_t *xsize) |
1780 | { | 1788 | { |
1781 | char *config; | 1789 | char *config; |
1782 | char *xconfig; | 1790 | char *xconfig; |
1783 | size_t size_; | 1791 | size_t size_; |
1784 | size_t xsize_; | 1792 | size_t xsize_; |
1785 | 1793 | ||
1786 | config = GNUNET_CONFIGURATION_serialize(cfg, &size_); | 1794 | config = GNUNET_CONFIGURATION_serialize (cfg, &size_); |
1787 | xsize_ = GNUNET_TESTBED_compress_config_(config, size_, &xconfig); | 1795 | xsize_ = GNUNET_TESTBED_compress_config_ (config, size_, &xconfig); |
1788 | GNUNET_free(config); | 1796 | GNUNET_free (config); |
1789 | *size = size_; | 1797 | *size = size_; |
1790 | *xsize = xsize_; | 1798 | *xsize = xsize_; |
1791 | return xconfig; | 1799 | return xconfig; |
@@ -1821,11 +1829,11 @@ GNUNET_TESTBED_compress_cfg_(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
1821 | * @return the operation handle | 1829 | * @return the operation handle |
1822 | */ | 1830 | */ |
1823 | struct GNUNET_TESTBED_Operation * | 1831 | struct GNUNET_TESTBED_Operation * |
1824 | GNUNET_TESTBED_controller_link(void *op_cls, | 1832 | GNUNET_TESTBED_controller_link (void *op_cls, |
1825 | struct GNUNET_TESTBED_Controller *master, | 1833 | struct GNUNET_TESTBED_Controller *master, |
1826 | struct GNUNET_TESTBED_Host *delegated_host, | 1834 | struct GNUNET_TESTBED_Host *delegated_host, |
1827 | struct GNUNET_TESTBED_Host *slave_host, | 1835 | struct GNUNET_TESTBED_Host *slave_host, |
1828 | int is_subordinate) | 1836 | int is_subordinate) |
1829 | { | 1837 | { |
1830 | struct OperationContext *opc; | 1838 | struct OperationContext *opc; |
1831 | struct GNUNET_TESTBED_ControllerLinkRequest *msg; | 1839 | struct GNUNET_TESTBED_ControllerLinkRequest *msg; |
@@ -1834,38 +1842,38 @@ GNUNET_TESTBED_controller_link(void *op_cls, | |||
1834 | uint32_t delegated_host_id; | 1842 | uint32_t delegated_host_id; |
1835 | uint16_t msg_size; | 1843 | uint16_t msg_size; |
1836 | 1844 | ||
1837 | GNUNET_assert(GNUNET_YES == | 1845 | GNUNET_assert (GNUNET_YES == |
1838 | GNUNET_TESTBED_is_host_registered_(delegated_host, master)); | 1846 | GNUNET_TESTBED_is_host_registered_ (delegated_host, master)); |
1839 | slave_host_id = GNUNET_TESTBED_host_get_id_( | 1847 | slave_host_id = GNUNET_TESTBED_host_get_id_ ( |
1840 | (NULL != slave_host) ? slave_host : master->host); | 1848 | (NULL != slave_host) ? slave_host : master->host); |
1841 | delegated_host_id = GNUNET_TESTBED_host_get_id_(delegated_host); | 1849 | delegated_host_id = GNUNET_TESTBED_host_get_id_ (delegated_host); |
1842 | if ((NULL != slave_host) && (0 != slave_host_id)) | 1850 | if ((NULL != slave_host) && (0 != slave_host_id)) |
1843 | GNUNET_assert(GNUNET_YES == | 1851 | GNUNET_assert (GNUNET_YES == |
1844 | GNUNET_TESTBED_is_host_registered_(slave_host, master)); | 1852 | GNUNET_TESTBED_is_host_registered_ (slave_host, master)); |
1845 | msg_size = sizeof(struct GNUNET_TESTBED_ControllerLinkRequest); | 1853 | msg_size = sizeof(struct GNUNET_TESTBED_ControllerLinkRequest); |
1846 | msg = GNUNET_malloc(msg_size); | 1854 | msg = GNUNET_malloc (msg_size); |
1847 | msg->header.type = htons(GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS); | 1855 | msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS); |
1848 | msg->header.size = htons(msg_size); | 1856 | msg->header.size = htons (msg_size); |
1849 | msg->delegated_host_id = htonl(delegated_host_id); | 1857 | msg->delegated_host_id = htonl (delegated_host_id); |
1850 | msg->slave_host_id = htonl(slave_host_id); | 1858 | msg->slave_host_id = htonl (slave_host_id); |
1851 | msg->is_subordinate = (GNUNET_YES == is_subordinate) ? 1 : 0; | 1859 | msg->is_subordinate = (GNUNET_YES == is_subordinate) ? 1 : 0; |
1852 | data = GNUNET_new(struct ControllerLinkData); | 1860 | data = GNUNET_new (struct ControllerLinkData); |
1853 | data->msg = msg; | 1861 | data->msg = msg; |
1854 | data->host_id = delegated_host_id; | 1862 | data->host_id = delegated_host_id; |
1855 | opc = GNUNET_new(struct OperationContext); | 1863 | opc = GNUNET_new (struct OperationContext); |
1856 | opc->c = master; | 1864 | opc->c = master; |
1857 | opc->data = data; | 1865 | opc->data = data; |
1858 | opc->type = OP_LINK_CONTROLLERS; | 1866 | opc->type = OP_LINK_CONTROLLERS; |
1859 | opc->id = GNUNET_TESTBED_get_next_op_id(opc->c); | 1867 | opc->id = GNUNET_TESTBED_get_next_op_id (opc->c); |
1860 | opc->state = OPC_STATE_INIT; | 1868 | opc->state = OPC_STATE_INIT; |
1861 | opc->op_cls = op_cls; | 1869 | opc->op_cls = op_cls; |
1862 | msg->operation_id = GNUNET_htonll(opc->id); | 1870 | msg->operation_id = GNUNET_htonll (opc->id); |
1863 | opc->op = GNUNET_TESTBED_operation_create_(opc, | 1871 | opc->op = GNUNET_TESTBED_operation_create_ (opc, |
1864 | &opstart_link_controllers, | 1872 | &opstart_link_controllers, |
1865 | &oprelease_link_controllers); | 1873 | &oprelease_link_controllers); |
1866 | GNUNET_TESTBED_operation_queue_insert_(master->opq_parallel_operations, | 1874 | GNUNET_TESTBED_operation_queue_insert_ (master->opq_parallel_operations, |
1867 | opc->op); | 1875 | opc->op); |
1868 | GNUNET_TESTBED_operation_begin_wait_(opc->op); | 1876 | GNUNET_TESTBED_operation_begin_wait_ (opc->op); |
1869 | return opc->op; | 1877 | return opc->op; |
1870 | } | 1878 | } |
1871 | 1879 | ||
@@ -1883,28 +1891,28 @@ GNUNET_TESTBED_controller_link(void *op_cls, | |||
1883 | * @return the operation handle; | 1891 | * @return the operation handle; |
1884 | */ | 1892 | */ |
1885 | struct GNUNET_TESTBED_Operation * | 1893 | struct GNUNET_TESTBED_Operation * |
1886 | GNUNET_TESTBED_get_slave_config_(void *op_cls, | 1894 | GNUNET_TESTBED_get_slave_config_ (void *op_cls, |
1887 | struct GNUNET_TESTBED_Controller *master, | 1895 | struct GNUNET_TESTBED_Controller *master, |
1888 | uint32_t slave_host_id) | 1896 | uint32_t slave_host_id) |
1889 | { | 1897 | { |
1890 | struct OperationContext *opc; | 1898 | struct OperationContext *opc; |
1891 | struct GetSlaveConfigData *data; | 1899 | struct GetSlaveConfigData *data; |
1892 | 1900 | ||
1893 | data = GNUNET_new(struct GetSlaveConfigData); | 1901 | data = GNUNET_new (struct GetSlaveConfigData); |
1894 | data->slave_id = slave_host_id; | 1902 | data->slave_id = slave_host_id; |
1895 | opc = GNUNET_new(struct OperationContext); | 1903 | opc = GNUNET_new (struct OperationContext); |
1896 | opc->state = OPC_STATE_INIT; | 1904 | opc->state = OPC_STATE_INIT; |
1897 | opc->c = master; | 1905 | opc->c = master; |
1898 | opc->id = GNUNET_TESTBED_get_next_op_id(master); | 1906 | opc->id = GNUNET_TESTBED_get_next_op_id (master); |
1899 | opc->type = OP_GET_SLAVE_CONFIG; | 1907 | opc->type = OP_GET_SLAVE_CONFIG; |
1900 | opc->data = data; | 1908 | opc->data = data; |
1901 | opc->op_cls = op_cls; | 1909 | opc->op_cls = op_cls; |
1902 | opc->op = GNUNET_TESTBED_operation_create_(opc, | 1910 | opc->op = GNUNET_TESTBED_operation_create_ (opc, |
1903 | &opstart_get_slave_config, | 1911 | &opstart_get_slave_config, |
1904 | &oprelease_get_slave_config); | 1912 | &oprelease_get_slave_config); |
1905 | GNUNET_TESTBED_operation_queue_insert_(master->opq_parallel_operations, | 1913 | GNUNET_TESTBED_operation_queue_insert_ (master->opq_parallel_operations, |
1906 | opc->op); | 1914 | opc->op); |
1907 | GNUNET_TESTBED_operation_begin_wait_(opc->op); | 1915 | GNUNET_TESTBED_operation_begin_wait_ (opc->op); |
1908 | return opc->op; | 1916 | return opc->op; |
1909 | } | 1917 | } |
1910 | 1918 | ||
@@ -1925,16 +1933,16 @@ GNUNET_TESTBED_get_slave_config_(void *op_cls, | |||
1925 | * master | 1933 | * master |
1926 | */ | 1934 | */ |
1927 | struct GNUNET_TESTBED_Operation * | 1935 | struct GNUNET_TESTBED_Operation * |
1928 | GNUNET_TESTBED_get_slave_config(void *op_cls, | 1936 | GNUNET_TESTBED_get_slave_config (void *op_cls, |
1929 | struct GNUNET_TESTBED_Controller *master, | 1937 | struct GNUNET_TESTBED_Controller *master, |
1930 | struct GNUNET_TESTBED_Host *slave_host) | 1938 | struct GNUNET_TESTBED_Host *slave_host) |
1931 | { | 1939 | { |
1932 | if (GNUNET_NO == GNUNET_TESTBED_is_host_registered_(slave_host, master)) | 1940 | if (GNUNET_NO == GNUNET_TESTBED_is_host_registered_ (slave_host, master)) |
1933 | return NULL; | 1941 | return NULL; |
1934 | return GNUNET_TESTBED_get_slave_config_(op_cls, | 1942 | return GNUNET_TESTBED_get_slave_config_ (op_cls, |
1935 | master, | 1943 | master, |
1936 | GNUNET_TESTBED_host_get_id_( | 1944 | GNUNET_TESTBED_host_get_id_ ( |
1937 | slave_host)); | 1945 | slave_host)); |
1938 | } | 1946 | } |
1939 | 1947 | ||
1940 | 1948 | ||
@@ -1948,11 +1956,11 @@ GNUNET_TESTBED_get_slave_config(void *op_cls, | |||
1948 | * be written to. | 1956 | * be written to. |
1949 | */ | 1957 | */ |
1950 | void | 1958 | void |
1951 | GNUNET_TESTBED_overlay_write_topology_to_file( | 1959 | GNUNET_TESTBED_overlay_write_topology_to_file ( |
1952 | struct GNUNET_TESTBED_Controller *controller, | 1960 | struct GNUNET_TESTBED_Controller *controller, |
1953 | const char *filename) | 1961 | const char *filename) |
1954 | { | 1962 | { |
1955 | GNUNET_break(0); | 1963 | GNUNET_break (0); |
1956 | } | 1964 | } |
1957 | 1965 | ||
1958 | 1966 | ||
@@ -1970,7 +1978,7 @@ GNUNET_TESTBED_overlay_write_topology_to_file( | |||
1970 | * @return the initialization message | 1978 | * @return the initialization message |
1971 | */ | 1979 | */ |
1972 | struct GNUNET_TESTBED_HelperInit * | 1980 | struct GNUNET_TESTBED_HelperInit * |
1973 | GNUNET_TESTBED_create_helper_init_msg_( | 1981 | GNUNET_TESTBED_create_helper_init_msg_ ( |
1974 | const char *trusted_ip, | 1982 | const char *trusted_ip, |
1975 | const char *hostname, | 1983 | const char *hostname, |
1976 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 1984 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
@@ -1984,30 +1992,30 @@ GNUNET_TESTBED_create_helper_init_msg_( | |||
1984 | uint16_t hostname_len; | 1992 | uint16_t hostname_len; |
1985 | uint16_t msg_size; | 1993 | uint16_t msg_size; |
1986 | 1994 | ||
1987 | config = GNUNET_CONFIGURATION_serialize(cfg, &config_size); | 1995 | config = GNUNET_CONFIGURATION_serialize (cfg, &config_size); |
1988 | GNUNET_assert(NULL != config); | 1996 | GNUNET_assert (NULL != config); |
1989 | xconfig_size = | 1997 | xconfig_size = |
1990 | GNUNET_TESTBED_compress_config_(config, config_size, &xconfig); | 1998 | GNUNET_TESTBED_compress_config_ (config, config_size, &xconfig); |
1991 | GNUNET_free(config); | 1999 | GNUNET_free (config); |
1992 | trusted_ip_len = strlen(trusted_ip); | 2000 | trusted_ip_len = strlen (trusted_ip); |
1993 | hostname_len = (NULL == hostname) ? 0 : strlen(hostname); | 2001 | hostname_len = (NULL == hostname) ? 0 : strlen (hostname); |
1994 | msg_size = xconfig_size + trusted_ip_len + 1 + | 2002 | msg_size = xconfig_size + trusted_ip_len + 1 |
1995 | sizeof(struct GNUNET_TESTBED_HelperInit); | 2003 | + sizeof(struct GNUNET_TESTBED_HelperInit); |
1996 | msg_size += hostname_len; | 2004 | msg_size += hostname_len; |
1997 | msg = GNUNET_realloc(xconfig, msg_size); | 2005 | msg = GNUNET_realloc (xconfig, msg_size); |
1998 | (void)memmove(((void *)&msg[1]) + trusted_ip_len + 1 + hostname_len, | 2006 | (void) memmove (((void *) &msg[1]) + trusted_ip_len + 1 + hostname_len, |
1999 | msg, | 2007 | msg, |
2000 | xconfig_size); | 2008 | xconfig_size); |
2001 | msg->header.size = htons(msg_size); | 2009 | msg->header.size = htons (msg_size); |
2002 | msg->header.type = htons(GNUNET_MESSAGE_TYPE_TESTBED_HELPER_INIT); | 2010 | msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_HELPER_INIT); |
2003 | msg->trusted_ip_size = htons(trusted_ip_len); | 2011 | msg->trusted_ip_size = htons (trusted_ip_len); |
2004 | msg->hostname_size = htons(hostname_len); | 2012 | msg->hostname_size = htons (hostname_len); |
2005 | msg->config_size = htons(config_size); | 2013 | msg->config_size = htons (config_size); |
2006 | (void)strcpy((char *)&msg[1], trusted_ip); | 2014 | (void) strcpy ((char *) &msg[1], trusted_ip); |
2007 | if (0 != hostname_len) | 2015 | if (0 != hostname_len) |
2008 | GNUNET_memcpy((char *)&msg[1] + trusted_ip_len + 1, | 2016 | GNUNET_memcpy ((char *) &msg[1] + trusted_ip_len + 1, |
2009 | hostname, | 2017 | hostname, |
2010 | hostname_len); | 2018 | hostname_len); |
2011 | return msg; | 2019 | return msg; |
2012 | } | 2020 | } |
2013 | 2021 | ||
@@ -2034,10 +2042,10 @@ GNUNET_TESTBED_create_helper_init_msg_( | |||
2034 | * @param operation operation to signal completion or cancellation | 2042 | * @param operation operation to signal completion or cancellation |
2035 | */ | 2043 | */ |
2036 | void | 2044 | void |
2037 | GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation) | 2045 | GNUNET_TESTBED_operation_done (struct GNUNET_TESTBED_Operation *operation) |
2038 | { | 2046 | { |
2039 | (void)exop_check(operation); | 2047 | (void) exop_check (operation); |
2040 | GNUNET_TESTBED_operation_release_(operation); | 2048 | GNUNET_TESTBED_operation_release_ (operation); |
2041 | } | 2049 | } |
2042 | 2050 | ||
2043 | 2051 | ||
@@ -2056,7 +2064,7 @@ GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation) | |||
2056 | * @return handle to the parsed configuration; NULL upon error while parsing the message | 2064 | * @return handle to the parsed configuration; NULL upon error while parsing the message |
2057 | */ | 2065 | */ |
2058 | struct GNUNET_CONFIGURATION_Handle * | 2066 | struct GNUNET_CONFIGURATION_Handle * |
2059 | GNUNET_TESTBED_extract_config_(const struct GNUNET_MessageHeader *msg) | 2067 | GNUNET_TESTBED_extract_config_ (const struct GNUNET_MessageHeader *msg) |
2060 | { | 2068 | { |
2061 | struct GNUNET_CONFIGURATION_Handle *cfg; | 2069 | struct GNUNET_CONFIGURATION_Handle *cfg; |
2062 | Bytef *data; | 2070 | Bytef *data; |
@@ -2065,99 +2073,99 @@ GNUNET_TESTBED_extract_config_(const struct GNUNET_MessageHeader *msg) | |||
2065 | uLong xdata_len; | 2073 | uLong xdata_len; |
2066 | int ret; | 2074 | int ret; |
2067 | 2075 | ||
2068 | switch (ntohs(msg->type)) | 2076 | switch (ntohs (msg->type)) |
2069 | { | 2077 | { |
2070 | case GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION: { | 2078 | case GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION: { |
2071 | const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *imsg; | 2079 | const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *imsg; |
2072 | 2080 | ||
2073 | imsg = | 2081 | imsg = |
2074 | (const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *)msg; | 2082 | (const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *) msg; |
2075 | data_len = (uLong)ntohs(imsg->config_size); | 2083 | data_len = (uLong) ntohs (imsg->config_size); |
2076 | xdata_len = | 2084 | xdata_len = |
2077 | ntohs(imsg->header.size) - | 2085 | ntohs (imsg->header.size) |
2078 | sizeof(struct GNUNET_TESTBED_PeerConfigurationInformationMessage); | 2086 | - sizeof(struct GNUNET_TESTBED_PeerConfigurationInformationMessage); |
2079 | xdata = (const Bytef *)&imsg[1]; | 2087 | xdata = (const Bytef *) &imsg[1]; |
2080 | } | 2088 | } |
2081 | break; | 2089 | break; |
2082 | 2090 | ||
2083 | case GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION: { | 2091 | case GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION: { |
2084 | const struct GNUNET_TESTBED_SlaveConfiguration *imsg; | 2092 | const struct GNUNET_TESTBED_SlaveConfiguration *imsg; |
2085 | 2093 | ||
2086 | imsg = (const struct GNUNET_TESTBED_SlaveConfiguration *)msg; | 2094 | imsg = (const struct GNUNET_TESTBED_SlaveConfiguration *) msg; |
2087 | data_len = (uLong)ntohs(imsg->config_size); | 2095 | data_len = (uLong) ntohs (imsg->config_size); |
2088 | xdata_len = ntohs(imsg->header.size) - | 2096 | xdata_len = ntohs (imsg->header.size) |
2089 | sizeof(struct GNUNET_TESTBED_SlaveConfiguration); | 2097 | - sizeof(struct GNUNET_TESTBED_SlaveConfiguration); |
2090 | xdata = (const Bytef *)&imsg[1]; | 2098 | xdata = (const Bytef *) &imsg[1]; |
2091 | } | 2099 | } |
2092 | break; | 2100 | break; |
2093 | 2101 | ||
2094 | case GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST: { | 2102 | case GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST: { |
2095 | const struct GNUNET_TESTBED_AddHostMessage *imsg; | 2103 | const struct GNUNET_TESTBED_AddHostMessage *imsg; |
2096 | uint16_t osize; | 2104 | uint16_t osize; |
2097 | 2105 | ||
2098 | imsg = (const struct GNUNET_TESTBED_AddHostMessage *)msg; | 2106 | imsg = (const struct GNUNET_TESTBED_AddHostMessage *) msg; |
2099 | data_len = (uLong)ntohs(imsg->config_size); | 2107 | data_len = (uLong) ntohs (imsg->config_size); |
2100 | osize = sizeof(struct GNUNET_TESTBED_AddHostMessage) + | 2108 | osize = sizeof(struct GNUNET_TESTBED_AddHostMessage) |
2101 | ntohs(imsg->username_length) + ntohs(imsg->hostname_length); | 2109 | + ntohs (imsg->username_length) + ntohs (imsg->hostname_length); |
2102 | xdata_len = ntohs(imsg->header.size) - osize; | 2110 | xdata_len = ntohs (imsg->header.size) - osize; |
2103 | xdata = (const Bytef *)((const void *)imsg + osize); | 2111 | xdata = (const Bytef *) ((const void *) imsg + osize); |
2104 | } | 2112 | } |
2105 | break; | 2113 | break; |
2106 | 2114 | ||
2107 | case GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT: { | 2115 | case GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT: { |
2108 | const struct GNUNET_TESTBED_ControllerLinkResponse *imsg; | 2116 | const struct GNUNET_TESTBED_ControllerLinkResponse *imsg; |
2109 | 2117 | ||
2110 | imsg = (const struct GNUNET_TESTBED_ControllerLinkResponse *)msg; | 2118 | imsg = (const struct GNUNET_TESTBED_ControllerLinkResponse *) msg; |
2111 | data_len = ntohs(imsg->config_size); | 2119 | data_len = ntohs (imsg->config_size); |
2112 | xdata_len = ntohs(imsg->header.size) - | 2120 | xdata_len = ntohs (imsg->header.size) |
2113 | sizeof(const struct GNUNET_TESTBED_ControllerLinkResponse); | 2121 | - sizeof(const struct GNUNET_TESTBED_ControllerLinkResponse); |
2114 | xdata = (const Bytef *)&imsg[1]; | 2122 | xdata = (const Bytef *) &imsg[1]; |
2115 | } | 2123 | } |
2116 | break; | 2124 | break; |
2117 | 2125 | ||
2118 | case GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER: { | 2126 | case GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER: { |
2119 | const struct GNUNET_TESTBED_PeerCreateMessage *imsg; | 2127 | const struct GNUNET_TESTBED_PeerCreateMessage *imsg; |
2120 | 2128 | ||
2121 | imsg = (const struct GNUNET_TESTBED_PeerCreateMessage *)msg; | 2129 | imsg = (const struct GNUNET_TESTBED_PeerCreateMessage *) msg; |
2122 | data_len = ntohs(imsg->config_size); | 2130 | data_len = ntohs (imsg->config_size); |
2123 | xdata_len = ntohs(imsg->header.size) - | 2131 | xdata_len = ntohs (imsg->header.size) |
2124 | sizeof(struct GNUNET_TESTBED_PeerCreateMessage); | 2132 | - sizeof(struct GNUNET_TESTBED_PeerCreateMessage); |
2125 | xdata = (const Bytef *)&imsg[1]; | 2133 | xdata = (const Bytef *) &imsg[1]; |
2126 | } | 2134 | } |
2127 | break; | 2135 | break; |
2128 | 2136 | ||
2129 | case GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER: { | 2137 | case GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER: { |
2130 | const struct GNUNET_TESTBED_PeerReconfigureMessage *imsg; | 2138 | const struct GNUNET_TESTBED_PeerReconfigureMessage *imsg; |
2131 | 2139 | ||
2132 | imsg = (const struct GNUNET_TESTBED_PeerReconfigureMessage *)msg; | 2140 | imsg = (const struct GNUNET_TESTBED_PeerReconfigureMessage *) msg; |
2133 | data_len = ntohs(imsg->config_size); | 2141 | data_len = ntohs (imsg->config_size); |
2134 | xdata_len = ntohs(imsg->header.size) - | 2142 | xdata_len = ntohs (imsg->header.size) |
2135 | sizeof(struct GNUNET_TESTBED_PeerReconfigureMessage); | 2143 | - sizeof(struct GNUNET_TESTBED_PeerReconfigureMessage); |
2136 | xdata = (const Bytef *)&imsg[1]; | 2144 | xdata = (const Bytef *) &imsg[1]; |
2137 | } | 2145 | } |
2138 | break; | 2146 | break; |
2139 | 2147 | ||
2140 | default: | 2148 | default: |
2141 | GNUNET_assert(0); | 2149 | GNUNET_assert (0); |
2142 | } | 2150 | } |
2143 | data = GNUNET_malloc(data_len); | 2151 | data = GNUNET_malloc (data_len); |
2144 | if (Z_OK != (ret = uncompress(data, &data_len, xdata, xdata_len))) | 2152 | if (Z_OK != (ret = uncompress (data, &data_len, xdata, xdata_len))) |
2145 | { | 2153 | { |
2146 | GNUNET_free(data); | 2154 | GNUNET_free (data); |
2147 | GNUNET_break_op(0); /* Un-compression failure */ | 2155 | GNUNET_break_op (0); /* Un-compression failure */ |
2148 | return NULL; | 2156 | return NULL; |
2149 | } | 2157 | } |
2150 | cfg = GNUNET_CONFIGURATION_create(); | 2158 | cfg = GNUNET_CONFIGURATION_create (); |
2151 | if (GNUNET_OK != GNUNET_CONFIGURATION_deserialize(cfg, | 2159 | if (GNUNET_OK != GNUNET_CONFIGURATION_deserialize (cfg, |
2152 | (const char *)data, | 2160 | (const char *) data, |
2153 | (size_t)data_len, | 2161 | (size_t) data_len, |
2154 | NULL)) | 2162 | NULL)) |
2155 | { | 2163 | { |
2156 | GNUNET_free(data); | 2164 | GNUNET_free (data); |
2157 | GNUNET_break_op(0); /* De-serialization failure */ | 2165 | GNUNET_break_op (0); /* De-serialization failure */ |
2158 | return NULL; | 2166 | return NULL; |
2159 | } | 2167 | } |
2160 | GNUNET_free(data); | 2168 | GNUNET_free (data); |
2161 | return cfg; | 2169 | return cfg; |
2162 | } | 2170 | } |
2163 | 2171 | ||
@@ -2170,22 +2178,22 @@ GNUNET_TESTBED_extract_config_(const struct GNUNET_MessageHeader *msg) | |||
2170 | * @return the error message | 2178 | * @return the error message |
2171 | */ | 2179 | */ |
2172 | const char * | 2180 | const char * |
2173 | GNUNET_TESTBED_parse_error_string_( | 2181 | GNUNET_TESTBED_parse_error_string_ ( |
2174 | const struct GNUNET_TESTBED_OperationFailureEventMessage *msg) | 2182 | const struct GNUNET_TESTBED_OperationFailureEventMessage *msg) |
2175 | { | 2183 | { |
2176 | uint16_t msize; | 2184 | uint16_t msize; |
2177 | const char *emsg; | 2185 | const char *emsg; |
2178 | 2186 | ||
2179 | msize = ntohs(msg->header.size); | 2187 | msize = ntohs (msg->header.size); |
2180 | if (sizeof(struct GNUNET_TESTBED_OperationFailureEventMessage) >= msize) | 2188 | if (sizeof(struct GNUNET_TESTBED_OperationFailureEventMessage) >= msize) |
2181 | return NULL; | 2189 | return NULL; |
2182 | msize -= sizeof(struct GNUNET_TESTBED_OperationFailureEventMessage); | 2190 | msize -= sizeof(struct GNUNET_TESTBED_OperationFailureEventMessage); |
2183 | emsg = (const char *)&msg[1]; | 2191 | emsg = (const char *) &msg[1]; |
2184 | if ('\0' != emsg[msize - 1]) | 2192 | if ('\0' != emsg[msize - 1]) |
2185 | { | 2193 | { |
2186 | GNUNET_break(0); | 2194 | GNUNET_break (0); |
2187 | return NULL; | 2195 | return NULL; |
2188 | } | 2196 | } |
2189 | return emsg; | 2197 | return emsg; |
2190 | } | 2198 | } |
2191 | 2199 | ||
@@ -2198,13 +2206,13 @@ GNUNET_TESTBED_parse_error_string_( | |||
2198 | * @return the incremented operation id. | 2206 | * @return the incremented operation id. |
2199 | */ | 2207 | */ |
2200 | uint64_t | 2208 | uint64_t |
2201 | GNUNET_TESTBED_get_next_op_id(struct GNUNET_TESTBED_Controller *controller) | 2209 | GNUNET_TESTBED_get_next_op_id (struct GNUNET_TESTBED_Controller *controller) |
2202 | { | 2210 | { |
2203 | uint64_t op_id; | 2211 | uint64_t op_id; |
2204 | 2212 | ||
2205 | op_id = (uint64_t)GNUNET_TESTBED_host_get_id_(controller->host); | 2213 | op_id = (uint64_t) GNUNET_TESTBED_host_get_id_ (controller->host); |
2206 | op_id = op_id << 32; | 2214 | op_id = op_id << 32; |
2207 | op_id |= (uint64_t)controller->operation_counter++; | 2215 | op_id |= (uint64_t) controller->operation_counter++; |
2208 | return op_id; | 2216 | return op_id; |
2209 | } | 2217 | } |
2210 | 2218 | ||
@@ -2215,17 +2223,17 @@ GNUNET_TESTBED_get_next_op_id(struct GNUNET_TESTBED_Controller *controller) | |||
2215 | * @param cls the closure from GNUNET_TESTBED_operation_create_() | 2223 | * @param cls the closure from GNUNET_TESTBED_operation_create_() |
2216 | */ | 2224 | */ |
2217 | static void | 2225 | static void |
2218 | opstart_shutdown_peers(void *cls) | 2226 | opstart_shutdown_peers (void *cls) |
2219 | { | 2227 | { |
2220 | struct OperationContext *opc = cls; | 2228 | struct OperationContext *opc = cls; |
2221 | struct GNUNET_MQ_Envelope *env; | 2229 | struct GNUNET_MQ_Envelope *env; |
2222 | struct GNUNET_TESTBED_ShutdownPeersMessage *msg; | 2230 | struct GNUNET_TESTBED_ShutdownPeersMessage *msg; |
2223 | 2231 | ||
2224 | opc->state = OPC_STATE_STARTED; | 2232 | opc->state = OPC_STATE_STARTED; |
2225 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS); | 2233 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS); |
2226 | msg->operation_id = GNUNET_htonll(opc->id); | 2234 | msg->operation_id = GNUNET_htonll (opc->id); |
2227 | GNUNET_TESTBED_insert_opc_(opc->c, opc); | 2235 | GNUNET_TESTBED_insert_opc_ (opc->c, opc); |
2228 | GNUNET_MQ_send(opc->c->mq, env); | 2236 | GNUNET_MQ_send (opc->c->mq, env); |
2229 | } | 2237 | } |
2230 | 2238 | ||
2231 | 2239 | ||
@@ -2235,24 +2243,24 @@ opstart_shutdown_peers(void *cls) | |||
2235 | * @param cls the closure from GNUNET_TESTBED_operation_create_() | 2243 | * @param cls the closure from GNUNET_TESTBED_operation_create_() |
2236 | */ | 2244 | */ |
2237 | static void | 2245 | static void |
2238 | oprelease_shutdown_peers(void *cls) | 2246 | oprelease_shutdown_peers (void *cls) |
2239 | { | 2247 | { |
2240 | struct OperationContext *opc = cls; | 2248 | struct OperationContext *opc = cls; |
2241 | 2249 | ||
2242 | switch (opc->state) | 2250 | switch (opc->state) |
2243 | { | 2251 | { |
2244 | case OPC_STATE_STARTED: | 2252 | case OPC_STATE_STARTED: |
2245 | GNUNET_TESTBED_remove_opc_(opc->c, opc); | 2253 | GNUNET_TESTBED_remove_opc_ (opc->c, opc); |
2246 | 2254 | ||
2247 | /* no break; continue */ | 2255 | /* no break; continue */ |
2248 | case OPC_STATE_INIT: | 2256 | case OPC_STATE_INIT: |
2249 | GNUNET_free(opc->data); | 2257 | GNUNET_free (opc->data); |
2250 | break; | 2258 | break; |
2251 | 2259 | ||
2252 | case OPC_STATE_FINISHED: | 2260 | case OPC_STATE_FINISHED: |
2253 | break; | 2261 | break; |
2254 | } | 2262 | } |
2255 | GNUNET_free(opc); | 2263 | GNUNET_free (opc); |
2256 | } | 2264 | } |
2257 | 2265 | ||
2258 | 2266 | ||
@@ -2272,32 +2280,32 @@ oprelease_shutdown_peers(void *cls) | |||
2272 | * present | 2280 | * present |
2273 | */ | 2281 | */ |
2274 | struct GNUNET_TESTBED_Operation * | 2282 | struct GNUNET_TESTBED_Operation * |
2275 | GNUNET_TESTBED_shutdown_peers(struct GNUNET_TESTBED_Controller *c, | 2283 | GNUNET_TESTBED_shutdown_peers (struct GNUNET_TESTBED_Controller *c, |
2276 | void *op_cls, | 2284 | void *op_cls, |
2277 | GNUNET_TESTBED_OperationCompletionCallback cb, | 2285 | GNUNET_TESTBED_OperationCompletionCallback cb, |
2278 | void *cb_cls) | 2286 | void *cb_cls) |
2279 | { | 2287 | { |
2280 | struct OperationContext *opc; | 2288 | struct OperationContext *opc; |
2281 | struct ShutdownPeersData *data; | 2289 | struct ShutdownPeersData *data; |
2282 | 2290 | ||
2283 | if (0 != GNUNET_CONTAINER_multihashmap32_size(c->opc_map)) | 2291 | if (0 != GNUNET_CONTAINER_multihashmap32_size (c->opc_map)) |
2284 | return NULL; | 2292 | return NULL; |
2285 | data = GNUNET_new(struct ShutdownPeersData); | 2293 | data = GNUNET_new (struct ShutdownPeersData); |
2286 | data->cb = cb; | 2294 | data->cb = cb; |
2287 | data->cb_cls = cb_cls; | 2295 | data->cb_cls = cb_cls; |
2288 | opc = GNUNET_new(struct OperationContext); | 2296 | opc = GNUNET_new (struct OperationContext); |
2289 | opc->c = c; | 2297 | opc->c = c; |
2290 | opc->op_cls = op_cls; | 2298 | opc->op_cls = op_cls; |
2291 | opc->data = data; | 2299 | opc->data = data; |
2292 | opc->id = GNUNET_TESTBED_get_next_op_id(c); | 2300 | opc->id = GNUNET_TESTBED_get_next_op_id (c); |
2293 | opc->type = OP_SHUTDOWN_PEERS; | 2301 | opc->type = OP_SHUTDOWN_PEERS; |
2294 | opc->state = OPC_STATE_INIT; | 2302 | opc->state = OPC_STATE_INIT; |
2295 | opc->op = GNUNET_TESTBED_operation_create_(opc, | 2303 | opc->op = GNUNET_TESTBED_operation_create_ (opc, |
2296 | &opstart_shutdown_peers, | 2304 | &opstart_shutdown_peers, |
2297 | &oprelease_shutdown_peers); | 2305 | &oprelease_shutdown_peers); |
2298 | GNUNET_TESTBED_operation_queue_insert_(opc->c->opq_parallel_operations, | 2306 | GNUNET_TESTBED_operation_queue_insert_ (opc->c->opq_parallel_operations, |
2299 | opc->op); | 2307 | opc->op); |
2300 | GNUNET_TESTBED_operation_begin_wait_(opc->op); | 2308 | GNUNET_TESTBED_operation_begin_wait_ (opc->op); |
2301 | return opc->op; | 2309 | return opc->op; |
2302 | } | 2310 | } |
2303 | 2311 | ||
@@ -2311,7 +2319,7 @@ GNUNET_TESTBED_shutdown_peers(struct GNUNET_TESTBED_Controller *c, | |||
2311 | * @return The peer's unique ID. | 2319 | * @return The peer's unique ID. |
2312 | */ | 2320 | */ |
2313 | uint32_t | 2321 | uint32_t |
2314 | GNUNET_TESTBED_get_index(const struct GNUNET_TESTBED_Peer *peer) | 2322 | GNUNET_TESTBED_get_index (const struct GNUNET_TESTBED_Peer *peer) |
2315 | { | 2323 | { |
2316 | return peer->unique_id; | 2324 | return peer->unique_id; |
2317 | } | 2325 | } |
@@ -2324,22 +2332,22 @@ GNUNET_TESTBED_get_index(const struct GNUNET_TESTBED_Peer *peer) | |||
2324 | * @param barrier the barrier to remove | 2332 | * @param barrier the barrier to remove |
2325 | */ | 2333 | */ |
2326 | void | 2334 | void |
2327 | GNUNET_TESTBED_barrier_remove_(struct GNUNET_TESTBED_Barrier *barrier) | 2335 | GNUNET_TESTBED_barrier_remove_ (struct GNUNET_TESTBED_Barrier *barrier) |
2328 | { | 2336 | { |
2329 | struct GNUNET_TESTBED_Controller *c = barrier->c; | 2337 | struct GNUNET_TESTBED_Controller *c = barrier->c; |
2330 | 2338 | ||
2331 | GNUNET_assert(NULL != c->barrier_map); /* No barriers present */ | 2339 | GNUNET_assert (NULL != c->barrier_map); /* No barriers present */ |
2332 | GNUNET_assert(GNUNET_OK == | 2340 | GNUNET_assert (GNUNET_OK == |
2333 | GNUNET_CONTAINER_multihashmap_remove(c->barrier_map, | 2341 | GNUNET_CONTAINER_multihashmap_remove (c->barrier_map, |
2334 | &barrier->key, | 2342 | &barrier->key, |
2335 | barrier)); | 2343 | barrier)); |
2336 | GNUNET_free(barrier->name); | 2344 | GNUNET_free (barrier->name); |
2337 | GNUNET_free(barrier); | 2345 | GNUNET_free (barrier); |
2338 | if (0 == GNUNET_CONTAINER_multihashmap_size(c->barrier_map)) | 2346 | if (0 == GNUNET_CONTAINER_multihashmap_size (c->barrier_map)) |
2339 | { | 2347 | { |
2340 | GNUNET_CONTAINER_multihashmap_destroy(c->barrier_map); | 2348 | GNUNET_CONTAINER_multihashmap_destroy (c->barrier_map); |
2341 | c->barrier_map = NULL; | 2349 | c->barrier_map = NULL; |
2342 | } | 2350 | } |
2343 | } | 2351 | } |
2344 | 2352 | ||
2345 | 2353 | ||
@@ -2360,12 +2368,12 @@ GNUNET_TESTBED_barrier_remove_(struct GNUNET_TESTBED_Barrier *barrier) | |||
2360 | * @return barrier handle; NULL upon error | 2368 | * @return barrier handle; NULL upon error |
2361 | */ | 2369 | */ |
2362 | struct GNUNET_TESTBED_Barrier * | 2370 | struct GNUNET_TESTBED_Barrier * |
2363 | GNUNET_TESTBED_barrier_init_(struct GNUNET_TESTBED_Controller *controller, | 2371 | GNUNET_TESTBED_barrier_init_ (struct GNUNET_TESTBED_Controller *controller, |
2364 | const char *name, | 2372 | const char *name, |
2365 | unsigned int quorum, | 2373 | unsigned int quorum, |
2366 | GNUNET_TESTBED_barrier_status_cb cb, | 2374 | GNUNET_TESTBED_barrier_status_cb cb, |
2367 | void *cls, | 2375 | void *cls, |
2368 | int echo) | 2376 | int echo) |
2369 | { | 2377 | { |
2370 | struct GNUNET_TESTBED_BarrierInit *msg; | 2378 | struct GNUNET_TESTBED_BarrierInit *msg; |
2371 | struct GNUNET_MQ_Envelope *env; | 2379 | struct GNUNET_MQ_Envelope *env; |
@@ -2373,41 +2381,41 @@ GNUNET_TESTBED_barrier_init_(struct GNUNET_TESTBED_Controller *controller, | |||
2373 | struct GNUNET_HashCode key; | 2381 | struct GNUNET_HashCode key; |
2374 | size_t name_len; | 2382 | size_t name_len; |
2375 | 2383 | ||
2376 | GNUNET_assert(quorum <= 100); | 2384 | GNUNET_assert (quorum <= 100); |
2377 | GNUNET_assert(NULL != cb); | 2385 | GNUNET_assert (NULL != cb); |
2378 | name_len = strlen(name); | 2386 | name_len = strlen (name); |
2379 | GNUNET_assert(0 < name_len); | 2387 | GNUNET_assert (0 < name_len); |
2380 | GNUNET_CRYPTO_hash(name, name_len, &key); | 2388 | GNUNET_CRYPTO_hash (name, name_len, &key); |
2381 | if (NULL == controller->barrier_map) | 2389 | if (NULL == controller->barrier_map) |
2382 | controller->barrier_map = | 2390 | controller->barrier_map = |
2383 | GNUNET_CONTAINER_multihashmap_create(3, GNUNET_YES); | 2391 | GNUNET_CONTAINER_multihashmap_create (3, GNUNET_YES); |
2384 | if (GNUNET_YES == | 2392 | if (GNUNET_YES == |
2385 | GNUNET_CONTAINER_multihashmap_contains(controller->barrier_map, &key)) | 2393 | GNUNET_CONTAINER_multihashmap_contains (controller->barrier_map, &key)) |
2386 | { | 2394 | { |
2387 | GNUNET_break(0); | 2395 | GNUNET_break (0); |
2388 | return NULL; | 2396 | return NULL; |
2389 | } | 2397 | } |
2390 | LOG_DEBUG("Initialising barrier `%s'\n", name); | 2398 | LOG_DEBUG ("Initialising barrier `%s'\n", name); |
2391 | barrier = GNUNET_new(struct GNUNET_TESTBED_Barrier); | 2399 | barrier = GNUNET_new (struct GNUNET_TESTBED_Barrier); |
2392 | barrier->c = controller; | 2400 | barrier->c = controller; |
2393 | barrier->name = GNUNET_strdup(name); | 2401 | barrier->name = GNUNET_strdup (name); |
2394 | barrier->cb = cb; | 2402 | barrier->cb = cb; |
2395 | barrier->cls = cls; | 2403 | barrier->cls = cls; |
2396 | barrier->echo = echo; | 2404 | barrier->echo = echo; |
2397 | GNUNET_memcpy(&barrier->key, &key, sizeof(struct GNUNET_HashCode)); | 2405 | GNUNET_memcpy (&barrier->key, &key, sizeof(struct GNUNET_HashCode)); |
2398 | GNUNET_assert(GNUNET_OK == | 2406 | GNUNET_assert (GNUNET_OK == |
2399 | GNUNET_CONTAINER_multihashmap_put( | 2407 | GNUNET_CONTAINER_multihashmap_put ( |
2400 | controller->barrier_map, | 2408 | controller->barrier_map, |
2401 | &barrier->key, | 2409 | &barrier->key, |
2402 | barrier, | 2410 | barrier, |
2403 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); | 2411 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); |
2404 | 2412 | ||
2405 | env = GNUNET_MQ_msg_extra(msg, | 2413 | env = GNUNET_MQ_msg_extra (msg, |
2406 | name_len, | 2414 | name_len, |
2407 | GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT); | 2415 | GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT); |
2408 | msg->quorum = (uint8_t)quorum; | 2416 | msg->quorum = (uint8_t) quorum; |
2409 | GNUNET_memcpy(msg->name, barrier->name, name_len); | 2417 | GNUNET_memcpy (msg->name, barrier->name, name_len); |
2410 | GNUNET_MQ_send(barrier->c->mq, env); | 2418 | GNUNET_MQ_send (barrier->c->mq, env); |
2411 | return barrier; | 2419 | return barrier; |
2412 | } | 2420 | } |
2413 | 2421 | ||
@@ -2427,18 +2435,18 @@ GNUNET_TESTBED_barrier_init_(struct GNUNET_TESTBED_Controller *controller, | |||
2427 | * @return barrier handle; NULL upon error | 2435 | * @return barrier handle; NULL upon error |
2428 | */ | 2436 | */ |
2429 | struct GNUNET_TESTBED_Barrier * | 2437 | struct GNUNET_TESTBED_Barrier * |
2430 | GNUNET_TESTBED_barrier_init(struct GNUNET_TESTBED_Controller *controller, | 2438 | GNUNET_TESTBED_barrier_init (struct GNUNET_TESTBED_Controller *controller, |
2431 | const char *name, | 2439 | const char *name, |
2432 | unsigned int quorum, | 2440 | unsigned int quorum, |
2433 | GNUNET_TESTBED_barrier_status_cb cb, | 2441 | GNUNET_TESTBED_barrier_status_cb cb, |
2434 | void *cls) | 2442 | void *cls) |
2435 | { | 2443 | { |
2436 | return GNUNET_TESTBED_barrier_init_(controller, | 2444 | return GNUNET_TESTBED_barrier_init_ (controller, |
2437 | name, | 2445 | name, |
2438 | quorum, | 2446 | quorum, |
2439 | cb, | 2447 | cb, |
2440 | cls, | 2448 | cls, |
2441 | GNUNET_YES); | 2449 | GNUNET_YES); |
2442 | } | 2450 | } |
2443 | 2451 | ||
2444 | 2452 | ||
@@ -2448,18 +2456,18 @@ GNUNET_TESTBED_barrier_init(struct GNUNET_TESTBED_Controller *controller, | |||
2448 | * @param barrier the barrier handle | 2456 | * @param barrier the barrier handle |
2449 | */ | 2457 | */ |
2450 | void | 2458 | void |
2451 | GNUNET_TESTBED_barrier_cancel(struct GNUNET_TESTBED_Barrier *barrier) | 2459 | GNUNET_TESTBED_barrier_cancel (struct GNUNET_TESTBED_Barrier *barrier) |
2452 | { | 2460 | { |
2453 | struct GNUNET_MQ_Envelope *env; | 2461 | struct GNUNET_MQ_Envelope *env; |
2454 | struct GNUNET_TESTBED_BarrierCancel *msg; | 2462 | struct GNUNET_TESTBED_BarrierCancel *msg; |
2455 | size_t slen; | 2463 | size_t slen; |
2456 | 2464 | ||
2457 | slen = strlen(barrier->name); | 2465 | slen = strlen (barrier->name); |
2458 | env = | 2466 | env = |
2459 | GNUNET_MQ_msg_extra(msg, slen, GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL); | 2467 | GNUNET_MQ_msg_extra (msg, slen, GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL); |
2460 | GNUNET_memcpy(msg->name, barrier->name, slen); | 2468 | GNUNET_memcpy (msg->name, barrier->name, slen); |
2461 | GNUNET_MQ_send(barrier->c->mq, env); | 2469 | GNUNET_MQ_send (barrier->c->mq, env); |
2462 | GNUNET_TESTBED_barrier_remove_(barrier); | 2470 | GNUNET_TESTBED_barrier_remove_ (barrier); |
2463 | } | 2471 | } |
2464 | 2472 | ||
2465 | 2473 | ||