diff options
Diffstat (limited to 'src/set')
-rw-r--r-- | src/set/gnunet-service-set.c | 1873 | ||||
-rw-r--r-- | src/set/gnunet-service-set.h | 41 | ||||
-rw-r--r-- | src/set/gnunet-service-set_intersection.c | 1244 | ||||
-rw-r--r-- | src/set/gnunet-service-set_intersection.h | 18 | ||||
-rw-r--r-- | src/set/gnunet-service-set_protocol.h | 21 | ||||
-rw-r--r-- | src/set/gnunet-service-set_union.c | 2266 | ||||
-rw-r--r-- | src/set/gnunet-service-set_union.h | 73 | ||||
-rw-r--r-- | src/set/gnunet-service-set_union_strata_estimator.c | 202 | ||||
-rw-r--r-- | src/set/gnunet-service-set_union_strata_estimator.h | 37 | ||||
-rw-r--r-- | src/set/gnunet-set-ibf-profiler.c | 350 | ||||
-rw-r--r-- | src/set/gnunet-set-profiler.c | 540 | ||||
-rw-r--r-- | src/set/ibf.c | 280 | ||||
-rw-r--r-- | src/set/ibf.h | 56 | ||||
-rw-r--r-- | src/set/ibf_sim.c | 116 | ||||
-rw-r--r-- | src/set/plugin_block_set_test.c | 43 | ||||
-rw-r--r-- | src/set/set.h | 39 | ||||
-rw-r--r-- | src/set/set_api.c | 932 | ||||
-rw-r--r-- | src/set/test_set_api.c | 414 | ||||
-rw-r--r-- | src/set/test_set_intersection_result_full.c | 411 | ||||
-rw-r--r-- | src/set/test_set_union_copy.c | 282 | ||||
-rw-r--r-- | src/set/test_set_union_result_symmetric.c | 475 |
21 files changed, 4909 insertions, 4804 deletions
diff --git a/src/set/gnunet-service-set.c b/src/set/gnunet-service-set.c index 2dad49e6d..6e49599a2 100644 --- a/src/set/gnunet-service-set.c +++ b/src/set/gnunet-service-set.c | |||
@@ -39,7 +39,8 @@ | |||
39 | /** | 39 | /** |
40 | * Lazy copy requests made by a client. | 40 | * Lazy copy requests made by a client. |
41 | */ | 41 | */ |
42 | struct LazyCopyRequest { | 42 | struct LazyCopyRequest |
43 | { | ||
43 | /** | 44 | /** |
44 | * Kept in a DLL. | 45 | * Kept in a DLL. |
45 | */ | 46 | */ |
@@ -66,7 +67,8 @@ struct LazyCopyRequest { | |||
66 | * A listener is inhabited by a client, and waits for evaluation | 67 | * A listener is inhabited by a client, and waits for evaluation |
67 | * requests from remote peers. | 68 | * requests from remote peers. |
68 | */ | 69 | */ |
69 | struct Listener { | 70 | struct Listener |
71 | { | ||
70 | /** | 72 | /** |
71 | * Listeners are held in a doubly linked list. | 73 | * Listeners are held in a doubly linked list. |
72 | */ | 74 | */ |
@@ -180,15 +182,15 @@ static uint32_t suggest_id; | |||
180 | * or NULL if there is none | 182 | * or NULL if there is none |
181 | */ | 183 | */ |
182 | static struct Operation * | 184 | static struct Operation * |
183 | get_incoming(uint32_t id) | 185 | get_incoming (uint32_t id) |
184 | { | 186 | { |
185 | for (struct Listener *listener = listener_head; NULL != listener; | 187 | for (struct Listener *listener = listener_head; NULL != listener; |
186 | listener = listener->next) | 188 | listener = listener->next) |
187 | { | 189 | { |
188 | for (struct Operation *op = listener->op_head; NULL != op; op = op->next) | 190 | for (struct Operation *op = listener->op_head; NULL != op; op = op->next) |
189 | if (op->suggest_id == id) | 191 | if (op->suggest_id == id) |
190 | return op; | 192 | return op; |
191 | } | 193 | } |
192 | return NULL; | 194 | return NULL; |
193 | } | 195 | } |
194 | 196 | ||
@@ -199,31 +201,32 @@ get_incoming(uint32_t id) | |||
199 | * @param op remote request to destroy | 201 | * @param op remote request to destroy |
200 | */ | 202 | */ |
201 | static void | 203 | static void |
202 | incoming_destroy(struct Operation *op) | 204 | incoming_destroy (struct Operation *op) |
203 | { | 205 | { |
204 | struct Listener *listener; | 206 | struct Listener *listener; |
205 | 207 | ||
206 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 208 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
207 | "Destroying incoming operation %p\n", | 209 | "Destroying incoming operation %p\n", |
208 | op); | 210 | op); |
209 | if (NULL != (listener = op->listener)) | 211 | if (NULL != (listener = op->listener)) |
210 | { | 212 | { |
211 | GNUNET_CONTAINER_DLL_remove(listener->op_head, listener->op_tail, op); | 213 | GNUNET_CONTAINER_DLL_remove (listener->op_head, listener->op_tail, op); |
212 | op->listener = NULL; | 214 | op->listener = NULL; |
213 | } | 215 | } |
214 | if (NULL != op->timeout_task) | 216 | if (NULL != op->timeout_task) |
215 | { | 217 | { |
216 | GNUNET_SCHEDULER_cancel(op->timeout_task); | 218 | GNUNET_SCHEDULER_cancel (op->timeout_task); |
217 | op->timeout_task = NULL; | 219 | op->timeout_task = NULL; |
218 | } | 220 | } |
219 | _GSS_operation_destroy2(op); | 221 | _GSS_operation_destroy2 (op); |
220 | } | 222 | } |
221 | 223 | ||
222 | 224 | ||
223 | /** | 225 | /** |
224 | * Context for the #garbage_collect_cb(). | 226 | * Context for the #garbage_collect_cb(). |
225 | */ | 227 | */ |
226 | struct GarbageContext { | 228 | struct GarbageContext |
229 | { | ||
227 | /** | 230 | /** |
228 | * Map for which we are garbage collecting removed elements. | 231 | * Map for which we are garbage collecting removed elements. |
229 | */ | 232 | */ |
@@ -251,22 +254,22 @@ struct GarbageContext { | |||
251 | * @return #GNUNET_OK (continue to iterate) | 254 | * @return #GNUNET_OK (continue to iterate) |
252 | */ | 255 | */ |
253 | static int | 256 | static int |
254 | garbage_collect_cb(void *cls, const struct GNUNET_HashCode *key, void *value) | 257 | garbage_collect_cb (void *cls, const struct GNUNET_HashCode *key, void *value) |
255 | { | 258 | { |
256 | //struct GarbageContext *gc = cls; | 259 | // struct GarbageContext *gc = cls; |
257 | //struct ElementEntry *ee = value; | 260 | // struct ElementEntry *ee = value; |
258 | 261 | ||
259 | //if (GNUNET_YES != ee->removed) | 262 | // if (GNUNET_YES != ee->removed) |
260 | // return GNUNET_OK; | 263 | // return GNUNET_OK; |
261 | //if ( (gc->max_op_generation < ee->generation_added) || | 264 | // if ( (gc->max_op_generation < ee->generation_added) || |
262 | // (ee->generation_removed > gc->min_op_generation) ) | 265 | // (ee->generation_removed > gc->min_op_generation) ) |
263 | //{ | 266 | // { |
264 | // GNUNET_assert (GNUNET_YES == | 267 | // GNUNET_assert (GNUNET_YES == |
265 | // GNUNET_CONTAINER_multihashmap_remove (gc->map, | 268 | // GNUNET_CONTAINER_multihashmap_remove (gc->map, |
266 | // key, | 269 | // key, |
267 | // ee)); | 270 | // ee)); |
268 | // GNUNET_free (ee); | 271 | // GNUNET_free (ee); |
269 | //} | 272 | // } |
270 | return GNUNET_OK; | 273 | return GNUNET_OK; |
271 | } | 274 | } |
272 | 275 | ||
@@ -279,23 +282,23 @@ garbage_collect_cb(void *cls, const struct GNUNET_HashCode *key, void *value) | |||
279 | * @param set set to garbage collect | 282 | * @param set set to garbage collect |
280 | */ | 283 | */ |
281 | static void | 284 | static void |
282 | collect_generation_garbage(struct Set *set) | 285 | collect_generation_garbage (struct Set *set) |
283 | { | 286 | { |
284 | struct GarbageContext gc; | 287 | struct GarbageContext gc; |
285 | 288 | ||
286 | gc.min_op_generation = UINT_MAX; | 289 | gc.min_op_generation = UINT_MAX; |
287 | gc.max_op_generation = 0; | 290 | gc.max_op_generation = 0; |
288 | for (struct Operation *op = set->ops_head; NULL != op; op = op->next) | 291 | for (struct Operation *op = set->ops_head; NULL != op; op = op->next) |
289 | { | 292 | { |
290 | gc.min_op_generation = | 293 | gc.min_op_generation = |
291 | GNUNET_MIN(gc.min_op_generation, op->generation_created); | 294 | GNUNET_MIN (gc.min_op_generation, op->generation_created); |
292 | gc.max_op_generation = | 295 | gc.max_op_generation = |
293 | GNUNET_MAX(gc.max_op_generation, op->generation_created); | 296 | GNUNET_MAX (gc.max_op_generation, op->generation_created); |
294 | } | 297 | } |
295 | gc.map = set->content->elements; | 298 | gc.map = set->content->elements; |
296 | GNUNET_CONTAINER_multihashmap_iterate(set->content->elements, | 299 | GNUNET_CONTAINER_multihashmap_iterate (set->content->elements, |
297 | &garbage_collect_cb, | 300 | &garbage_collect_cb, |
298 | &gc); | 301 | &gc); |
299 | } | 302 | } |
300 | 303 | ||
301 | 304 | ||
@@ -308,9 +311,9 @@ collect_generation_garbage(struct Set *set) | |||
308 | * @return #GNUNET_YES if @a generation is in any of the ranges | 311 | * @return #GNUNET_YES if @a generation is in any of the ranges |
309 | */ | 312 | */ |
310 | static int | 313 | static int |
311 | is_excluded_generation(unsigned int generation, | 314 | is_excluded_generation (unsigned int generation, |
312 | struct GenerationRange *excluded, | 315 | struct GenerationRange *excluded, |
313 | unsigned int excluded_size) | 316 | unsigned int excluded_size) |
314 | { | 317 | { |
315 | for (unsigned int i = 0; i < excluded_size; i++) | 318 | for (unsigned int i = 0; i < excluded_size; i++) |
316 | if ((generation >= excluded[i].start) && (generation < excluded[i].end)) | 319 | if ((generation >= excluded[i].start) && (generation < excluded[i].end)) |
@@ -329,57 +332,57 @@ is_excluded_generation(unsigned int generation, | |||
329 | * @return #GNUNET_YES if the element is in the set, #GNUNET_NO if not | 332 | * @return #GNUNET_YES if the element is in the set, #GNUNET_NO if not |
330 | */ | 333 | */ |
331 | static int | 334 | static int |
332 | is_element_of_generation(struct ElementEntry *ee, | 335 | is_element_of_generation (struct ElementEntry *ee, |
333 | unsigned int query_generation, | 336 | unsigned int query_generation, |
334 | struct GenerationRange *excluded, | 337 | struct GenerationRange *excluded, |
335 | unsigned int excluded_size) | 338 | unsigned int excluded_size) |
336 | { | 339 | { |
337 | struct MutationEvent *mut; | 340 | struct MutationEvent *mut; |
338 | int is_present; | 341 | int is_present; |
339 | 342 | ||
340 | GNUNET_assert(NULL != ee->mutations); | 343 | GNUNET_assert (NULL != ee->mutations); |
341 | if (GNUNET_YES == | 344 | if (GNUNET_YES == |
342 | is_excluded_generation(query_generation, excluded, excluded_size)) | 345 | is_excluded_generation (query_generation, excluded, excluded_size)) |
343 | { | 346 | { |
344 | GNUNET_break(0); | 347 | GNUNET_break (0); |
345 | return GNUNET_NO; | 348 | return GNUNET_NO; |
346 | } | 349 | } |
347 | 350 | ||
348 | is_present = GNUNET_NO; | 351 | is_present = GNUNET_NO; |
349 | 352 | ||
350 | /* Could be made faster with binary search, but lists | 353 | /* Could be made faster with binary search, but lists |
351 | are small, so why bother. */ | 354 | are small, so why bother. */ |
352 | for (unsigned int i = 0; i < ee->mutations_size; i++) | 355 | for (unsigned int i = 0; i < ee->mutations_size; i++) |
356 | { | ||
357 | mut = &ee->mutations[i]; | ||
358 | |||
359 | if (mut->generation > query_generation) | ||
353 | { | 360 | { |
354 | mut = &ee->mutations[i]; | 361 | /* The mutation doesn't apply to our generation |
355 | 362 | anymore. We can'b break here, since mutations aren't | |
356 | if (mut->generation > query_generation) | 363 | sorted by generation. */ |
357 | { | 364 | continue; |
358 | /* The mutation doesn't apply to our generation | ||
359 | anymore. We can'b break here, since mutations aren't | ||
360 | sorted by generation. */ | ||
361 | continue; | ||
362 | } | ||
363 | |||
364 | if (GNUNET_YES == | ||
365 | is_excluded_generation(mut->generation, excluded, excluded_size)) | ||
366 | { | ||
367 | /* The generation is excluded (because it belongs to another | ||
368 | fork via a lazy copy) and thus mutations aren't considered | ||
369 | for membership testing. */ | ||
370 | continue; | ||
371 | } | ||
372 | |||
373 | /* This would be an inconsistency in how we manage mutations. */ | ||
374 | if ((GNUNET_YES == is_present) && (GNUNET_YES == mut->added)) | ||
375 | GNUNET_assert(0); | ||
376 | /* Likewise. */ | ||
377 | if ((GNUNET_NO == is_present) && (GNUNET_NO == mut->added)) | ||
378 | GNUNET_assert(0); | ||
379 | |||
380 | is_present = mut->added; | ||
381 | } | 365 | } |
382 | 366 | ||
367 | if (GNUNET_YES == | ||
368 | is_excluded_generation (mut->generation, excluded, excluded_size)) | ||
369 | { | ||
370 | /* The generation is excluded (because it belongs to another | ||
371 | fork via a lazy copy) and thus mutations aren't considered | ||
372 | for membership testing. */ | ||
373 | continue; | ||
374 | } | ||
375 | |||
376 | /* This would be an inconsistency in how we manage mutations. */ | ||
377 | if ((GNUNET_YES == is_present) && (GNUNET_YES == mut->added)) | ||
378 | GNUNET_assert (0); | ||
379 | /* Likewise. */ | ||
380 | if ((GNUNET_NO == is_present) && (GNUNET_NO == mut->added)) | ||
381 | GNUNET_assert (0); | ||
382 | |||
383 | is_present = mut->added; | ||
384 | } | ||
385 | |||
383 | return is_present; | 386 | return is_present; |
384 | } | 387 | } |
385 | 388 | ||
@@ -392,12 +395,12 @@ is_element_of_generation(struct ElementEntry *ee, | |||
392 | * @return #GNUNET_YES if the element is in the set, #GNUNET_NO if not | 395 | * @return #GNUNET_YES if the element is in the set, #GNUNET_NO if not |
393 | */ | 396 | */ |
394 | int | 397 | int |
395 | _GSS_is_element_of_operation(struct ElementEntry *ee, struct Operation *op) | 398 | _GSS_is_element_of_operation (struct ElementEntry *ee, struct Operation *op) |
396 | { | 399 | { |
397 | return is_element_of_generation(ee, | 400 | return is_element_of_generation (ee, |
398 | op->generation_created, | 401 | op->generation_created, |
399 | op->set->excluded_generations, | 402 | op->set->excluded_generations, |
400 | op->set->excluded_generations_size); | 403 | op->set->excluded_generations_size); |
401 | } | 404 | } |
402 | 405 | ||
403 | 406 | ||
@@ -415,37 +418,37 @@ _GSS_is_element_of_operation(struct ElementEntry *ee, struct Operation *op) | |||
415 | * @param gc #GNUNET_YES to perform garbage collection on the set | 418 | * @param gc #GNUNET_YES to perform garbage collection on the set |
416 | */ | 419 | */ |
417 | void | 420 | void |
418 | _GSS_operation_destroy(struct Operation *op, int gc) | 421 | _GSS_operation_destroy (struct Operation *op, int gc) |
419 | { | 422 | { |
420 | struct Set *set = op->set; | 423 | struct Set *set = op->set; |
421 | struct GNUNET_CADET_Channel *channel; | 424 | struct GNUNET_CADET_Channel *channel; |
422 | 425 | ||
423 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Destroying operation %p\n", op); | 426 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Destroying operation %p\n", op); |
424 | GNUNET_assert(NULL == op->listener); | 427 | GNUNET_assert (NULL == op->listener); |
425 | if (NULL != op->state) | 428 | if (NULL != op->state) |
426 | { | 429 | { |
427 | set->vt->cancel(op); | 430 | set->vt->cancel (op); |
428 | op->state = NULL; | 431 | op->state = NULL; |
429 | } | 432 | } |
430 | if (NULL != set) | 433 | if (NULL != set) |
431 | { | 434 | { |
432 | GNUNET_CONTAINER_DLL_remove(set->ops_head, set->ops_tail, op); | 435 | GNUNET_CONTAINER_DLL_remove (set->ops_head, set->ops_tail, op); |
433 | op->set = NULL; | 436 | op->set = NULL; |
434 | } | 437 | } |
435 | if (NULL != op->context_msg) | 438 | if (NULL != op->context_msg) |
436 | { | 439 | { |
437 | GNUNET_free(op->context_msg); | 440 | GNUNET_free (op->context_msg); |
438 | op->context_msg = NULL; | 441 | op->context_msg = NULL; |
439 | } | 442 | } |
440 | if (NULL != (channel = op->channel)) | 443 | if (NULL != (channel = op->channel)) |
441 | { | 444 | { |
442 | /* This will free op; called conditionally as this helper function | 445 | /* This will free op; called conditionally as this helper function |
443 | is also called from within the channel disconnect handler. */ | 446 | is also called from within the channel disconnect handler. */ |
444 | op->channel = NULL; | 447 | op->channel = NULL; |
445 | GNUNET_CADET_channel_destroy(channel); | 448 | GNUNET_CADET_channel_destroy (channel); |
446 | } | 449 | } |
447 | if ((NULL != set) && (GNUNET_YES == gc)) | 450 | if ((NULL != set) && (GNUNET_YES == gc)) |
448 | collect_generation_garbage(set); | 451 | collect_generation_garbage (set); |
449 | /* We rely on the channel end handler to free 'op'. When 'op->channel' was NULL, | 452 | /* We rely on the channel end handler to free 'op'. When 'op->channel' was NULL, |
450 | * there was a channel end handler that will free 'op' on the call stack. */ | 453 | * there was a channel end handler that will free 'op' on the call stack. */ |
451 | } | 454 | } |
@@ -460,14 +463,14 @@ _GSS_operation_destroy(struct Operation *op, int gc) | |||
460 | * @return @a `struct ClientState` | 463 | * @return @a `struct ClientState` |
461 | */ | 464 | */ |
462 | static void * | 465 | static void * |
463 | client_connect_cb(void *cls, | 466 | client_connect_cb (void *cls, |
464 | struct GNUNET_SERVICE_Client *c, | 467 | struct GNUNET_SERVICE_Client *c, |
465 | struct GNUNET_MQ_Handle *mq) | 468 | struct GNUNET_MQ_Handle *mq) |
466 | { | 469 | { |
467 | struct ClientState *cs; | 470 | struct ClientState *cs; |
468 | 471 | ||
469 | num_clients++; | 472 | num_clients++; |
470 | cs = GNUNET_new(struct ClientState); | 473 | cs = GNUNET_new (struct ClientState); |
471 | cs->client = c; | 474 | cs->client = c; |
472 | cs->mq = mq; | 475 | cs->mq = mq; |
473 | return cs; | 476 | return cs; |
@@ -483,14 +486,14 @@ client_connect_cb(void *cls, | |||
483 | * @return #GNUNET_YES (continue to iterate) | 486 | * @return #GNUNET_YES (continue to iterate) |
484 | */ | 487 | */ |
485 | static int | 488 | static int |
486 | destroy_elements_iterator(void *cls, | 489 | destroy_elements_iterator (void *cls, |
487 | const struct GNUNET_HashCode *key, | 490 | const struct GNUNET_HashCode *key, |
488 | void *value) | 491 | void *value) |
489 | { | 492 | { |
490 | struct ElementEntry *ee = value; | 493 | struct ElementEntry *ee = value; |
491 | 494 | ||
492 | GNUNET_free_non_null(ee->mutations); | 495 | GNUNET_free_non_null (ee->mutations); |
493 | GNUNET_free(ee); | 496 | GNUNET_free (ee); |
494 | return GNUNET_YES; | 497 | return GNUNET_YES; |
495 | } | 498 | } |
496 | 499 | ||
@@ -503,117 +506,117 @@ destroy_elements_iterator(void *cls, | |||
503 | * @param internal_cls the `struct ClientState` | 506 | * @param internal_cls the `struct ClientState` |
504 | */ | 507 | */ |
505 | static void | 508 | static void |
506 | client_disconnect_cb(void *cls, | 509 | client_disconnect_cb (void *cls, |
507 | struct GNUNET_SERVICE_Client *client, | 510 | struct GNUNET_SERVICE_Client *client, |
508 | void *internal_cls) | 511 | void *internal_cls) |
509 | { | 512 | { |
510 | struct ClientState *cs = internal_cls; | 513 | struct ClientState *cs = internal_cls; |
511 | struct Operation *op; | 514 | struct Operation *op; |
512 | struct Listener *listener; | 515 | struct Listener *listener; |
513 | struct Set *set; | 516 | struct Set *set; |
514 | 517 | ||
515 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Client disconnected, cleaning up\n"); | 518 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client disconnected, cleaning up\n"); |
516 | if (NULL != (set = cs->set)) | 519 | if (NULL != (set = cs->set)) |
520 | { | ||
521 | struct SetContent *content = set->content; | ||
522 | struct PendingMutation *pm; | ||
523 | struct PendingMutation *pm_current; | ||
524 | struct LazyCopyRequest *lcr; | ||
525 | |||
526 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Destroying client's set\n"); | ||
527 | /* Destroy pending set operations */ | ||
528 | while (NULL != set->ops_head) | ||
529 | _GSS_operation_destroy (set->ops_head, GNUNET_NO); | ||
530 | |||
531 | /* Destroy operation-specific state */ | ||
532 | GNUNET_assert (NULL != set->state); | ||
533 | set->vt->destroy_set (set->state); | ||
534 | set->state = NULL; | ||
535 | |||
536 | /* Clean up ongoing iterations */ | ||
537 | if (NULL != set->iter) | ||
538 | { | ||
539 | GNUNET_CONTAINER_multihashmap_iterator_destroy (set->iter); | ||
540 | set->iter = NULL; | ||
541 | set->iteration_id++; | ||
542 | } | ||
543 | |||
544 | /* discard any pending mutations that reference this set */ | ||
545 | pm = content->pending_mutations_head; | ||
546 | while (NULL != pm) | ||
517 | { | 547 | { |
518 | struct SetContent *content = set->content; | 548 | pm_current = pm; |
519 | struct PendingMutation *pm; | 549 | pm = pm->next; |
520 | struct PendingMutation *pm_current; | 550 | if (pm_current->set == set) |
521 | struct LazyCopyRequest *lcr; | 551 | { |
522 | 552 | GNUNET_CONTAINER_DLL_remove (content->pending_mutations_head, | |
523 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Destroying client's set\n"); | 553 | content->pending_mutations_tail, |
524 | /* Destroy pending set operations */ | 554 | pm_current); |
525 | while (NULL != set->ops_head) | 555 | GNUNET_free (pm_current); |
526 | _GSS_operation_destroy(set->ops_head, GNUNET_NO); | 556 | } |
527 | |||
528 | /* Destroy operation-specific state */ | ||
529 | GNUNET_assert(NULL != set->state); | ||
530 | set->vt->destroy_set(set->state); | ||
531 | set->state = NULL; | ||
532 | |||
533 | /* Clean up ongoing iterations */ | ||
534 | if (NULL != set->iter) | ||
535 | { | ||
536 | GNUNET_CONTAINER_multihashmap_iterator_destroy(set->iter); | ||
537 | set->iter = NULL; | ||
538 | set->iteration_id++; | ||
539 | } | ||
540 | |||
541 | /* discard any pending mutations that reference this set */ | ||
542 | pm = content->pending_mutations_head; | ||
543 | while (NULL != pm) | ||
544 | { | ||
545 | pm_current = pm; | ||
546 | pm = pm->next; | ||
547 | if (pm_current->set == set) | ||
548 | { | ||
549 | GNUNET_CONTAINER_DLL_remove(content->pending_mutations_head, | ||
550 | content->pending_mutations_tail, | ||
551 | pm_current); | ||
552 | GNUNET_free(pm_current); | ||
553 | } | ||
554 | } | ||
555 | |||
556 | /* free set content (or at least decrement RC) */ | ||
557 | set->content = NULL; | ||
558 | GNUNET_assert(0 != content->refcount); | ||
559 | content->refcount--; | ||
560 | if (0 == content->refcount) | ||
561 | { | ||
562 | GNUNET_assert(NULL != content->elements); | ||
563 | GNUNET_CONTAINER_multihashmap_iterate(content->elements, | ||
564 | &destroy_elements_iterator, | ||
565 | NULL); | ||
566 | GNUNET_CONTAINER_multihashmap_destroy(content->elements); | ||
567 | content->elements = NULL; | ||
568 | GNUNET_free(content); | ||
569 | } | ||
570 | GNUNET_free_non_null(set->excluded_generations); | ||
571 | set->excluded_generations = NULL; | ||
572 | |||
573 | /* remove set from pending copy requests */ | ||
574 | lcr = lazy_copy_head; | ||
575 | while (NULL != lcr) | ||
576 | { | ||
577 | struct LazyCopyRequest *lcr_current = lcr; | ||
578 | |||
579 | lcr = lcr->next; | ||
580 | if (lcr_current->source_set == set) | ||
581 | { | ||
582 | GNUNET_CONTAINER_DLL_remove(lazy_copy_head, | ||
583 | lazy_copy_tail, | ||
584 | lcr_current); | ||
585 | GNUNET_free(lcr_current); | ||
586 | } | ||
587 | } | ||
588 | GNUNET_free(set); | ||
589 | } | 557 | } |
590 | 558 | ||
559 | /* free set content (or at least decrement RC) */ | ||
560 | set->content = NULL; | ||
561 | GNUNET_assert (0 != content->refcount); | ||
562 | content->refcount--; | ||
563 | if (0 == content->refcount) | ||
564 | { | ||
565 | GNUNET_assert (NULL != content->elements); | ||
566 | GNUNET_CONTAINER_multihashmap_iterate (content->elements, | ||
567 | &destroy_elements_iterator, | ||
568 | NULL); | ||
569 | GNUNET_CONTAINER_multihashmap_destroy (content->elements); | ||
570 | content->elements = NULL; | ||
571 | GNUNET_free (content); | ||
572 | } | ||
573 | GNUNET_free_non_null (set->excluded_generations); | ||
574 | set->excluded_generations = NULL; | ||
575 | |||
576 | /* remove set from pending copy requests */ | ||
577 | lcr = lazy_copy_head; | ||
578 | while (NULL != lcr) | ||
579 | { | ||
580 | struct LazyCopyRequest *lcr_current = lcr; | ||
581 | |||
582 | lcr = lcr->next; | ||
583 | if (lcr_current->source_set == set) | ||
584 | { | ||
585 | GNUNET_CONTAINER_DLL_remove (lazy_copy_head, | ||
586 | lazy_copy_tail, | ||
587 | lcr_current); | ||
588 | GNUNET_free (lcr_current); | ||
589 | } | ||
590 | } | ||
591 | GNUNET_free (set); | ||
592 | } | ||
593 | |||
591 | if (NULL != (listener = cs->listener)) | 594 | if (NULL != (listener = cs->listener)) |
595 | { | ||
596 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Destroying client's listener\n"); | ||
597 | GNUNET_CADET_close_port (listener->open_port); | ||
598 | listener->open_port = NULL; | ||
599 | while (NULL != (op = listener->op_head)) | ||
592 | { | 600 | { |
593 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Destroying client's listener\n"); | 601 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
594 | GNUNET_CADET_close_port(listener->open_port); | 602 | "Destroying incoming operation `%u' from peer `%s'\n", |
595 | listener->open_port = NULL; | 603 | (unsigned int) op->client_request_id, |
596 | while (NULL != (op = listener->op_head)) | 604 | GNUNET_i2s (&op->peer)); |
597 | { | 605 | incoming_destroy (op); |
598 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
599 | "Destroying incoming operation `%u' from peer `%s'\n", | ||
600 | (unsigned int)op->client_request_id, | ||
601 | GNUNET_i2s(&op->peer)); | ||
602 | incoming_destroy(op); | ||
603 | } | ||
604 | GNUNET_CONTAINER_DLL_remove(listener_head, listener_tail, listener); | ||
605 | GNUNET_free(listener); | ||
606 | } | 606 | } |
607 | GNUNET_free(cs); | 607 | GNUNET_CONTAINER_DLL_remove (listener_head, listener_tail, listener); |
608 | GNUNET_free (listener); | ||
609 | } | ||
610 | GNUNET_free (cs); | ||
608 | num_clients--; | 611 | num_clients--; |
609 | if ((GNUNET_YES == in_shutdown) && (0 == num_clients)) | 612 | if ((GNUNET_YES == in_shutdown) && (0 == num_clients)) |
613 | { | ||
614 | if (NULL != cadet) | ||
610 | { | 615 | { |
611 | if (NULL != cadet) | 616 | GNUNET_CADET_disconnect (cadet); |
612 | { | 617 | cadet = NULL; |
613 | GNUNET_CADET_disconnect(cadet); | ||
614 | cadet = NULL; | ||
615 | } | ||
616 | } | 618 | } |
619 | } | ||
617 | } | 620 | } |
618 | 621 | ||
619 | 622 | ||
@@ -626,7 +629,7 @@ client_disconnect_cb(void *cls, | |||
626 | * #GNUNET_SYSERR to destroy the channel | 629 | * #GNUNET_SYSERR to destroy the channel |
627 | */ | 630 | */ |
628 | static int | 631 | static int |
629 | check_incoming_msg(void *cls, const struct OperationRequestMessage *msg) | 632 | check_incoming_msg (void *cls, const struct OperationRequestMessage *msg) |
630 | { | 633 | { |
631 | struct Operation *op = cls; | 634 | struct Operation *op = cls; |
632 | struct Listener *listener = op->listener; | 635 | struct Listener *listener = op->listener; |
@@ -634,29 +637,29 @@ check_incoming_msg(void *cls, const struct OperationRequestMessage *msg) | |||
634 | 637 | ||
635 | /* double operation request */ | 638 | /* double operation request */ |
636 | if (0 != op->suggest_id) | 639 | if (0 != op->suggest_id) |
637 | { | 640 | { |
638 | GNUNET_break_op(0); | 641 | GNUNET_break_op (0); |
639 | return GNUNET_SYSERR; | 642 | return GNUNET_SYSERR; |
640 | } | 643 | } |
641 | /* This should be equivalent to the previous condition, but can't hurt to check twice */ | 644 | /* This should be equivalent to the previous condition, but can't hurt to check twice */ |
642 | if (NULL == op->listener) | 645 | if (NULL == op->listener) |
643 | { | 646 | { |
644 | GNUNET_break(0); | 647 | GNUNET_break (0); |
645 | return GNUNET_SYSERR; | 648 | return GNUNET_SYSERR; |
646 | } | 649 | } |
647 | if (listener->operation != | 650 | if (listener->operation != |
648 | (enum GNUNET_SET_OperationType)ntohl(msg->operation)) | 651 | (enum GNUNET_SET_OperationType) ntohl (msg->operation)) |
649 | { | 652 | { |
650 | GNUNET_break_op(0); | 653 | GNUNET_break_op (0); |
651 | return GNUNET_SYSERR; | 654 | return GNUNET_SYSERR; |
652 | } | 655 | } |
653 | nested_context = GNUNET_MQ_extract_nested_mh(msg); | 656 | nested_context = GNUNET_MQ_extract_nested_mh (msg); |
654 | if ((NULL != nested_context) && | 657 | if ((NULL != nested_context) && |
655 | (ntohs(nested_context->size) > GNUNET_SET_CONTEXT_MESSAGE_MAX_SIZE)) | 658 | (ntohs (nested_context->size) > GNUNET_SET_CONTEXT_MESSAGE_MAX_SIZE)) |
656 | { | 659 | { |
657 | GNUNET_break_op(0); | 660 | GNUNET_break_op (0); |
658 | return GNUNET_SYSERR; | 661 | return GNUNET_SYSERR; |
659 | } | 662 | } |
660 | return GNUNET_OK; | 663 | return GNUNET_OK; |
661 | } | 664 | } |
662 | 665 | ||
@@ -679,7 +682,7 @@ check_incoming_msg(void *cls, const struct OperationRequestMessage *msg) | |||
679 | * #GNUNET_SYSERR to destroy the channel | 682 | * #GNUNET_SYSERR to destroy the channel |
680 | */ | 683 | */ |
681 | static void | 684 | static void |
682 | handle_incoming_msg(void *cls, const struct OperationRequestMessage *msg) | 685 | handle_incoming_msg (void *cls, const struct OperationRequestMessage *msg) |
683 | { | 686 | { |
684 | struct Operation *op = cls; | 687 | struct Operation *op = cls; |
685 | struct Listener *listener = op->listener; | 688 | struct Listener *listener = op->listener; |
@@ -687,37 +690,37 @@ handle_incoming_msg(void *cls, const struct OperationRequestMessage *msg) | |||
687 | struct GNUNET_MQ_Envelope *env; | 690 | struct GNUNET_MQ_Envelope *env; |
688 | struct GNUNET_SET_RequestMessage *cmsg; | 691 | struct GNUNET_SET_RequestMessage *cmsg; |
689 | 692 | ||
690 | nested_context = GNUNET_MQ_extract_nested_mh(msg); | 693 | nested_context = GNUNET_MQ_extract_nested_mh (msg); |
691 | /* Make a copy of the nested_context (application-specific context | 694 | /* Make a copy of the nested_context (application-specific context |
692 | information that is opaque to set) so we can pass it to the | 695 | information that is opaque to set) so we can pass it to the |
693 | listener later on */ | 696 | listener later on */ |
694 | if (NULL != nested_context) | 697 | if (NULL != nested_context) |
695 | op->context_msg = GNUNET_copy_message(nested_context); | 698 | op->context_msg = GNUNET_copy_message (nested_context); |
696 | op->remote_element_count = ntohl(msg->element_count); | 699 | op->remote_element_count = ntohl (msg->element_count); |
697 | GNUNET_log( | 700 | GNUNET_log ( |
698 | GNUNET_ERROR_TYPE_DEBUG, | 701 | GNUNET_ERROR_TYPE_DEBUG, |
699 | "Received P2P operation request (op %u, port %s) for active listener\n", | 702 | "Received P2P operation request (op %u, port %s) for active listener\n", |
700 | (uint32_t)ntohl(msg->operation), | 703 | (uint32_t) ntohl (msg->operation), |
701 | GNUNET_h2s(&op->listener->app_id)); | 704 | GNUNET_h2s (&op->listener->app_id)); |
702 | GNUNET_assert(0 == op->suggest_id); | 705 | GNUNET_assert (0 == op->suggest_id); |
703 | if (0 == suggest_id) | 706 | if (0 == suggest_id) |
704 | suggest_id++; | 707 | suggest_id++; |
705 | op->suggest_id = suggest_id++; | 708 | op->suggest_id = suggest_id++; |
706 | GNUNET_assert(NULL != op->timeout_task); | 709 | GNUNET_assert (NULL != op->timeout_task); |
707 | GNUNET_SCHEDULER_cancel(op->timeout_task); | 710 | GNUNET_SCHEDULER_cancel (op->timeout_task); |
708 | op->timeout_task = NULL; | 711 | op->timeout_task = NULL; |
709 | env = GNUNET_MQ_msg_nested_mh(cmsg, | 712 | env = GNUNET_MQ_msg_nested_mh (cmsg, |
710 | GNUNET_MESSAGE_TYPE_SET_REQUEST, | 713 | GNUNET_MESSAGE_TYPE_SET_REQUEST, |
711 | op->context_msg); | 714 | op->context_msg); |
712 | GNUNET_log( | 715 | GNUNET_log ( |
713 | GNUNET_ERROR_TYPE_DEBUG, | 716 | GNUNET_ERROR_TYPE_DEBUG, |
714 | "Suggesting incoming request with accept id %u to listener %p of client %p\n", | 717 | "Suggesting incoming request with accept id %u to listener %p of client %p\n", |
715 | op->suggest_id, | 718 | op->suggest_id, |
716 | listener, | 719 | listener, |
717 | listener->cs); | 720 | listener->cs); |
718 | cmsg->accept_id = htonl(op->suggest_id); | 721 | cmsg->accept_id = htonl (op->suggest_id); |
719 | cmsg->peer_id = op->peer; | 722 | cmsg->peer_id = op->peer; |
720 | GNUNET_MQ_send(listener->cs->mq, env); | 723 | GNUNET_MQ_send (listener->cs->mq, env); |
721 | /* NOTE: GNUNET_CADET_receive_done() will be called in | 724 | /* NOTE: GNUNET_CADET_receive_done() will be called in |
722 | #handle_client_accept() */ | 725 | #handle_client_accept() */ |
723 | } | 726 | } |
@@ -730,61 +733,61 @@ handle_incoming_msg(void *cls, const struct OperationRequestMessage *msg) | |||
730 | * @param msg message specifying the change | 733 | * @param msg message specifying the change |
731 | */ | 734 | */ |
732 | static void | 735 | static void |
733 | execute_add(struct Set *set, const struct GNUNET_SET_ElementMessage *msg) | 736 | execute_add (struct Set *set, const struct GNUNET_SET_ElementMessage *msg) |
734 | { | 737 | { |
735 | struct GNUNET_SET_Element el; | 738 | struct GNUNET_SET_Element el; |
736 | struct ElementEntry *ee; | 739 | struct ElementEntry *ee; |
737 | struct GNUNET_HashCode hash; | 740 | struct GNUNET_HashCode hash; |
738 | 741 | ||
739 | GNUNET_assert(GNUNET_MESSAGE_TYPE_SET_ADD == ntohs(msg->header.type)); | 742 | GNUNET_assert (GNUNET_MESSAGE_TYPE_SET_ADD == ntohs (msg->header.type)); |
740 | el.size = ntohs(msg->header.size) - sizeof(*msg); | 743 | el.size = ntohs (msg->header.size) - sizeof(*msg); |
741 | el.data = &msg[1]; | 744 | el.data = &msg[1]; |
742 | el.element_type = ntohs(msg->element_type); | 745 | el.element_type = ntohs (msg->element_type); |
743 | GNUNET_SET_element_hash(&el, &hash); | 746 | GNUNET_SET_element_hash (&el, &hash); |
744 | ee = GNUNET_CONTAINER_multihashmap_get(set->content->elements, &hash); | 747 | ee = GNUNET_CONTAINER_multihashmap_get (set->content->elements, &hash); |
745 | if (NULL == ee) | 748 | if (NULL == ee) |
746 | { | 749 | { |
747 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 750 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
748 | "Client inserts element %s of size %u\n", | 751 | "Client inserts element %s of size %u\n", |
749 | GNUNET_h2s(&hash), | 752 | GNUNET_h2s (&hash), |
750 | el.size); | 753 | el.size); |
751 | ee = GNUNET_malloc(el.size + sizeof(*ee)); | 754 | ee = GNUNET_malloc (el.size + sizeof(*ee)); |
752 | ee->element.size = el.size; | 755 | ee->element.size = el.size; |
753 | GNUNET_memcpy(&ee[1], el.data, el.size); | 756 | GNUNET_memcpy (&ee[1], el.data, el.size); |
754 | ee->element.data = &ee[1]; | 757 | ee->element.data = &ee[1]; |
755 | ee->element.element_type = el.element_type; | 758 | ee->element.element_type = el.element_type; |
756 | ee->remote = GNUNET_NO; | 759 | ee->remote = GNUNET_NO; |
757 | ee->mutations = NULL; | 760 | ee->mutations = NULL; |
758 | ee->mutations_size = 0; | 761 | ee->mutations_size = 0; |
759 | ee->element_hash = hash; | 762 | ee->element_hash = hash; |
760 | GNUNET_break(GNUNET_YES == | 763 | GNUNET_break (GNUNET_YES == |
761 | GNUNET_CONTAINER_multihashmap_put( | 764 | GNUNET_CONTAINER_multihashmap_put ( |
762 | set->content->elements, | 765 | set->content->elements, |
763 | &ee->element_hash, | 766 | &ee->element_hash, |
764 | ee, | 767 | ee, |
765 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 768 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
766 | } | 769 | } |
767 | else if (GNUNET_YES == | 770 | else if (GNUNET_YES == |
768 | is_element_of_generation(ee, | 771 | is_element_of_generation (ee, |
769 | set->current_generation, | 772 | set->current_generation, |
770 | set->excluded_generations, | 773 | set->excluded_generations, |
771 | set->excluded_generations_size)) | 774 | set->excluded_generations_size)) |
772 | { | 775 | { |
773 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 776 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
774 | "Client inserted element %s of size %u twice (ignored)\n", | 777 | "Client inserted element %s of size %u twice (ignored)\n", |
775 | GNUNET_h2s(&hash), | 778 | GNUNET_h2s (&hash), |
776 | el.size); | 779 | el.size); |
777 | 780 | ||
778 | /* same element inserted twice */ | 781 | /* same element inserted twice */ |
779 | return; | 782 | return; |
780 | } | 783 | } |
781 | 784 | ||
782 | { | 785 | { |
783 | struct MutationEvent mut = { .generation = set->current_generation, | 786 | struct MutationEvent mut = { .generation = set->current_generation, |
784 | .added = GNUNET_YES }; | 787 | .added = GNUNET_YES }; |
785 | GNUNET_array_append(ee->mutations, ee->mutations_size, mut); | 788 | GNUNET_array_append (ee->mutations, ee->mutations_size, mut); |
786 | } | 789 | } |
787 | set->vt->add(set->state, ee); | 790 | set->vt->add (set->state, ee); |
788 | } | 791 | } |
789 | 792 | ||
790 | 793 | ||
@@ -795,49 +798,49 @@ execute_add(struct Set *set, const struct GNUNET_SET_ElementMessage *msg) | |||
795 | * @param msg message specifying the change | 798 | * @param msg message specifying the change |
796 | */ | 799 | */ |
797 | static void | 800 | static void |
798 | execute_remove(struct Set *set, const struct GNUNET_SET_ElementMessage *msg) | 801 | execute_remove (struct Set *set, const struct GNUNET_SET_ElementMessage *msg) |
799 | { | 802 | { |
800 | struct GNUNET_SET_Element el; | 803 | struct GNUNET_SET_Element el; |
801 | struct ElementEntry *ee; | 804 | struct ElementEntry *ee; |
802 | struct GNUNET_HashCode hash; | 805 | struct GNUNET_HashCode hash; |
803 | 806 | ||
804 | GNUNET_assert(GNUNET_MESSAGE_TYPE_SET_REMOVE == ntohs(msg->header.type)); | 807 | GNUNET_assert (GNUNET_MESSAGE_TYPE_SET_REMOVE == ntohs (msg->header.type)); |
805 | el.size = ntohs(msg->header.size) - sizeof(*msg); | 808 | el.size = ntohs (msg->header.size) - sizeof(*msg); |
806 | el.data = &msg[1]; | 809 | el.data = &msg[1]; |
807 | el.element_type = ntohs(msg->element_type); | 810 | el.element_type = ntohs (msg->element_type); |
808 | GNUNET_SET_element_hash(&el, &hash); | 811 | GNUNET_SET_element_hash (&el, &hash); |
809 | ee = GNUNET_CONTAINER_multihashmap_get(set->content->elements, &hash); | 812 | ee = GNUNET_CONTAINER_multihashmap_get (set->content->elements, &hash); |
810 | if (NULL == ee) | 813 | if (NULL == ee) |
811 | { | 814 | { |
812 | /* Client tried to remove non-existing element. */ | 815 | /* Client tried to remove non-existing element. */ |
813 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 816 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
814 | "Client removes non-existing element of size %u\n", | 817 | "Client removes non-existing element of size %u\n", |
815 | el.size); | 818 | el.size); |
816 | return; | 819 | return; |
817 | } | 820 | } |
818 | if (GNUNET_NO == is_element_of_generation(ee, | 821 | if (GNUNET_NO == is_element_of_generation (ee, |
819 | set->current_generation, | 822 | set->current_generation, |
820 | set->excluded_generations, | 823 | set->excluded_generations, |
821 | set->excluded_generations_size)) | 824 | set->excluded_generations_size)) |
822 | { | 825 | { |
823 | /* Client tried to remove element twice */ | 826 | /* Client tried to remove element twice */ |
824 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 827 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
825 | "Client removed element of size %u twice (ignored)\n", | 828 | "Client removed element of size %u twice (ignored)\n", |
826 | el.size); | 829 | el.size); |
827 | return; | 830 | return; |
828 | } | 831 | } |
829 | else | 832 | else |
830 | { | 833 | { |
831 | struct MutationEvent mut = { .generation = set->current_generation, | 834 | struct MutationEvent mut = { .generation = set->current_generation, |
832 | .added = GNUNET_NO }; | 835 | .added = GNUNET_NO }; |
833 | 836 | ||
834 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 837 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
835 | "Client removes element of size %u\n", | 838 | "Client removes element of size %u\n", |
836 | el.size); | 839 | el.size); |
837 | 840 | ||
838 | GNUNET_array_append(ee->mutations, ee->mutations_size, mut); | 841 | GNUNET_array_append (ee->mutations, ee->mutations_size, mut); |
839 | } | 842 | } |
840 | set->vt->remove(set->state, ee); | 843 | set->vt->remove (set->state, ee); |
841 | } | 844 | } |
842 | 845 | ||
843 | 846 | ||
@@ -848,21 +851,21 @@ execute_remove(struct Set *set, const struct GNUNET_SET_ElementMessage *msg) | |||
848 | * @param msg specification of what to change | 851 | * @param msg specification of what to change |
849 | */ | 852 | */ |
850 | static void | 853 | static void |
851 | execute_mutation(struct Set *set, const struct GNUNET_SET_ElementMessage *msg) | 854 | execute_mutation (struct Set *set, const struct GNUNET_SET_ElementMessage *msg) |
852 | { | 855 | { |
853 | switch (ntohs(msg->header.type)) | 856 | switch (ntohs (msg->header.type)) |
854 | { | 857 | { |
855 | case GNUNET_MESSAGE_TYPE_SET_ADD: | 858 | case GNUNET_MESSAGE_TYPE_SET_ADD: |
856 | execute_add(set, msg); | 859 | execute_add (set, msg); |
857 | break; | 860 | break; |
858 | 861 | ||
859 | case GNUNET_MESSAGE_TYPE_SET_REMOVE: | 862 | case GNUNET_MESSAGE_TYPE_SET_REMOVE: |
860 | execute_remove(set, msg); | 863 | execute_remove (set, msg); |
861 | break; | 864 | break; |
862 | 865 | ||
863 | default: | 866 | default: |
864 | GNUNET_break(0); | 867 | GNUNET_break (0); |
865 | } | 868 | } |
866 | } | 869 | } |
867 | 870 | ||
868 | 871 | ||
@@ -873,24 +876,24 @@ execute_mutation(struct Set *set, const struct GNUNET_SET_ElementMessage *msg) | |||
873 | * @param set the set to execute mutations on | 876 | * @param set the set to execute mutations on |
874 | */ | 877 | */ |
875 | static void | 878 | static void |
876 | execute_delayed_mutations(struct Set *set) | 879 | execute_delayed_mutations (struct Set *set) |
877 | { | 880 | { |
878 | struct PendingMutation *pm; | 881 | struct PendingMutation *pm; |
879 | 882 | ||
880 | if (0 != set->content->iterator_count) | 883 | if (0 != set->content->iterator_count) |
881 | return; /* still cannot do this */ | 884 | return; /* still cannot do this */ |
882 | while (NULL != (pm = set->content->pending_mutations_head)) | 885 | while (NULL != (pm = set->content->pending_mutations_head)) |
883 | { | 886 | { |
884 | GNUNET_CONTAINER_DLL_remove(set->content->pending_mutations_head, | 887 | GNUNET_CONTAINER_DLL_remove (set->content->pending_mutations_head, |
885 | set->content->pending_mutations_tail, | 888 | set->content->pending_mutations_tail, |
886 | pm); | 889 | pm); |
887 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 890 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
888 | "Executing pending mutation on %p.\n", | 891 | "Executing pending mutation on %p.\n", |
889 | pm->set); | 892 | pm->set); |
890 | execute_mutation(pm->set, pm->msg); | 893 | execute_mutation (pm->set, pm->msg); |
891 | GNUNET_free(pm->msg); | 894 | GNUNET_free (pm->msg); |
892 | GNUNET_free(pm); | 895 | GNUNET_free (pm); |
893 | } | 896 | } |
894 | } | 897 | } |
895 | 898 | ||
896 | 899 | ||
@@ -908,49 +911,49 @@ execute_delayed_mutations(struct Set *set) | |||
908 | * @param set set that should send its next element to its client | 911 | * @param set set that should send its next element to its client |
909 | */ | 912 | */ |
910 | static void | 913 | static void |
911 | send_client_element(struct Set *set) | 914 | send_client_element (struct Set *set) |
912 | { | 915 | { |
913 | int ret; | 916 | int ret; |
914 | struct ElementEntry *ee; | 917 | struct ElementEntry *ee; |
915 | struct GNUNET_MQ_Envelope *ev; | 918 | struct GNUNET_MQ_Envelope *ev; |
916 | struct GNUNET_SET_IterResponseMessage *msg; | 919 | struct GNUNET_SET_IterResponseMessage *msg; |
917 | 920 | ||
918 | GNUNET_assert(NULL != set->iter); | 921 | GNUNET_assert (NULL != set->iter); |
919 | do | 922 | do |
923 | { | ||
924 | ret = GNUNET_CONTAINER_multihashmap_iterator_next (set->iter, | ||
925 | NULL, | ||
926 | (const void **) &ee); | ||
927 | if (GNUNET_NO == ret) | ||
920 | { | 928 | { |
921 | ret = GNUNET_CONTAINER_multihashmap_iterator_next(set->iter, | 929 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration on %p done.\n", set); |
922 | NULL, | 930 | ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_ITER_DONE); |
923 | (const void **)&ee); | 931 | GNUNET_CONTAINER_multihashmap_iterator_destroy (set->iter); |
924 | if (GNUNET_NO == ret) | 932 | set->iter = NULL; |
925 | { | 933 | set->iteration_id++; |
926 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Iteration on %p done.\n", set); | 934 | GNUNET_assert (set->content->iterator_count > 0); |
927 | ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_SET_ITER_DONE); | 935 | set->content->iterator_count--; |
928 | GNUNET_CONTAINER_multihashmap_iterator_destroy(set->iter); | 936 | execute_delayed_mutations (set); |
929 | set->iter = NULL; | 937 | GNUNET_MQ_send (set->cs->mq, ev); |
930 | set->iteration_id++; | 938 | return; |
931 | GNUNET_assert(set->content->iterator_count > 0); | ||
932 | set->content->iterator_count--; | ||
933 | execute_delayed_mutations(set); | ||
934 | GNUNET_MQ_send(set->cs->mq, ev); | ||
935 | return; | ||
936 | } | ||
937 | GNUNET_assert(NULL != ee); | ||
938 | } | 939 | } |
940 | GNUNET_assert (NULL != ee); | ||
941 | } | ||
939 | while (GNUNET_NO == | 942 | while (GNUNET_NO == |
940 | is_element_of_generation(ee, | 943 | is_element_of_generation (ee, |
941 | set->iter_generation, | 944 | set->iter_generation, |
942 | set->excluded_generations, | 945 | set->excluded_generations, |
943 | set->excluded_generations_size)); | 946 | set->excluded_generations_size)); |
944 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 947 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
945 | "Sending iteration element on %p.\n", | 948 | "Sending iteration element on %p.\n", |
946 | set); | 949 | set); |
947 | ev = GNUNET_MQ_msg_extra(msg, | 950 | ev = GNUNET_MQ_msg_extra (msg, |
948 | ee->element.size, | 951 | ee->element.size, |
949 | GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT); | 952 | GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT); |
950 | GNUNET_memcpy(&msg[1], ee->element.data, ee->element.size); | 953 | GNUNET_memcpy (&msg[1], ee->element.data, ee->element.size); |
951 | msg->element_type = htons(ee->element.element_type); | 954 | msg->element_type = htons (ee->element.element_type); |
952 | msg->iteration_id = htons(set->iteration_id); | 955 | msg->iteration_id = htons (set->iteration_id); |
953 | GNUNET_MQ_send(set->cs->mq, ev); | 956 | GNUNET_MQ_send (set->cs->mq, ev); |
954 | } | 957 | } |
955 | 958 | ||
956 | 959 | ||
@@ -964,36 +967,36 @@ send_client_element(struct Set *set) | |||
964 | * @param m message sent by the client | 967 | * @param m message sent by the client |
965 | */ | 968 | */ |
966 | static void | 969 | static void |
967 | handle_client_iterate(void *cls, const struct GNUNET_MessageHeader *m) | 970 | handle_client_iterate (void *cls, const struct GNUNET_MessageHeader *m) |
968 | { | 971 | { |
969 | struct ClientState *cs = cls; | 972 | struct ClientState *cs = cls; |
970 | struct Set *set; | 973 | struct Set *set; |
971 | 974 | ||
972 | if (NULL == (set = cs->set)) | 975 | if (NULL == (set = cs->set)) |
973 | { | 976 | { |
974 | /* attempt to iterate over a non existing set */ | 977 | /* attempt to iterate over a non existing set */ |
975 | GNUNET_break(0); | 978 | GNUNET_break (0); |
976 | GNUNET_SERVICE_client_drop(cs->client); | 979 | GNUNET_SERVICE_client_drop (cs->client); |
977 | return; | 980 | return; |
978 | } | 981 | } |
979 | if (NULL != set->iter) | 982 | if (NULL != set->iter) |
980 | { | 983 | { |
981 | /* Only one concurrent iterate-action allowed per set */ | 984 | /* Only one concurrent iterate-action allowed per set */ |
982 | GNUNET_break(0); | 985 | GNUNET_break (0); |
983 | GNUNET_SERVICE_client_drop(cs->client); | 986 | GNUNET_SERVICE_client_drop (cs->client); |
984 | return; | 987 | return; |
985 | } | 988 | } |
986 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 989 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
987 | "Iterating set %p in gen %u with %u content elements\n", | 990 | "Iterating set %p in gen %u with %u content elements\n", |
988 | (void *)set, | 991 | (void *) set, |
989 | set->current_generation, | 992 | set->current_generation, |
990 | GNUNET_CONTAINER_multihashmap_size(set->content->elements)); | 993 | GNUNET_CONTAINER_multihashmap_size (set->content->elements)); |
991 | GNUNET_SERVICE_client_continue(cs->client); | 994 | GNUNET_SERVICE_client_continue (cs->client); |
992 | set->content->iterator_count++; | 995 | set->content->iterator_count++; |
993 | set->iter = | 996 | set->iter = |
994 | GNUNET_CONTAINER_multihashmap_iterator_create(set->content->elements); | 997 | GNUNET_CONTAINER_multihashmap_iterator_create (set->content->elements); |
995 | set->iter_generation = set->current_generation; | 998 | set->iter_generation = set->current_generation; |
996 | send_client_element(set); | 999 | send_client_element (set); |
997 | } | 1000 | } |
998 | 1001 | ||
999 | 1002 | ||
@@ -1006,53 +1009,53 @@ handle_client_iterate(void *cls, const struct GNUNET_MessageHeader *m) | |||
1006 | * @param m message sent by the client | 1009 | * @param m message sent by the client |
1007 | */ | 1010 | */ |
1008 | static void | 1011 | static void |
1009 | handle_client_create_set(void *cls, const struct GNUNET_SET_CreateMessage *msg) | 1012 | handle_client_create_set (void *cls, const struct GNUNET_SET_CreateMessage *msg) |
1010 | { | 1013 | { |
1011 | struct ClientState *cs = cls; | 1014 | struct ClientState *cs = cls; |
1012 | struct Set *set; | 1015 | struct Set *set; |
1013 | 1016 | ||
1014 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1017 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1015 | "Client created new set (operation %u)\n", | 1018 | "Client created new set (operation %u)\n", |
1016 | (uint32_t)ntohl(msg->operation)); | 1019 | (uint32_t) ntohl (msg->operation)); |
1017 | if (NULL != cs->set) | 1020 | if (NULL != cs->set) |
1018 | { | 1021 | { |
1019 | /* There can only be one set per client */ | 1022 | /* There can only be one set per client */ |
1020 | GNUNET_break(0); | 1023 | GNUNET_break (0); |
1021 | GNUNET_SERVICE_client_drop(cs->client); | 1024 | GNUNET_SERVICE_client_drop (cs->client); |
1022 | return; | 1025 | return; |
1023 | } | 1026 | } |
1024 | set = GNUNET_new(struct Set); | 1027 | set = GNUNET_new (struct Set); |
1025 | switch (ntohl(msg->operation)) | 1028 | switch (ntohl (msg->operation)) |
1026 | { | 1029 | { |
1027 | case GNUNET_SET_OPERATION_INTERSECTION: | 1030 | case GNUNET_SET_OPERATION_INTERSECTION: |
1028 | set->vt = _GSS_intersection_vt(); | 1031 | set->vt = _GSS_intersection_vt (); |
1029 | break; | 1032 | break; |
1030 | 1033 | ||
1031 | case GNUNET_SET_OPERATION_UNION: | 1034 | case GNUNET_SET_OPERATION_UNION: |
1032 | set->vt = _GSS_union_vt(); | 1035 | set->vt = _GSS_union_vt (); |
1033 | break; | 1036 | break; |
1034 | 1037 | ||
1035 | default: | 1038 | default: |
1036 | GNUNET_free(set); | 1039 | GNUNET_free (set); |
1037 | GNUNET_break(0); | 1040 | GNUNET_break (0); |
1038 | GNUNET_SERVICE_client_drop(cs->client); | 1041 | GNUNET_SERVICE_client_drop (cs->client); |
1039 | return; | 1042 | return; |
1040 | } | 1043 | } |
1041 | set->operation = (enum GNUNET_SET_OperationType)ntohl(msg->operation); | 1044 | set->operation = (enum GNUNET_SET_OperationType) ntohl (msg->operation); |
1042 | set->state = set->vt->create(); | 1045 | set->state = set->vt->create (); |
1043 | if (NULL == set->state) | 1046 | if (NULL == set->state) |
1044 | { | 1047 | { |
1045 | /* initialization failed (i.e. out of memory) */ | 1048 | /* initialization failed (i.e. out of memory) */ |
1046 | GNUNET_free(set); | 1049 | GNUNET_free (set); |
1047 | GNUNET_SERVICE_client_drop(cs->client); | 1050 | GNUNET_SERVICE_client_drop (cs->client); |
1048 | return; | 1051 | return; |
1049 | } | 1052 | } |
1050 | set->content = GNUNET_new(struct SetContent); | 1053 | set->content = GNUNET_new (struct SetContent); |
1051 | set->content->refcount = 1; | 1054 | set->content->refcount = 1; |
1052 | set->content->elements = GNUNET_CONTAINER_multihashmap_create(1, GNUNET_YES); | 1055 | set->content->elements = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES); |
1053 | set->cs = cs; | 1056 | set->cs = cs; |
1054 | cs->set = set; | 1057 | cs->set = set; |
1055 | GNUNET_SERVICE_client_continue(cs->client); | 1058 | GNUNET_SERVICE_client_continue (cs->client); |
1056 | } | 1059 | } |
1057 | 1060 | ||
1058 | 1061 | ||
@@ -1066,14 +1069,14 @@ handle_client_create_set(void *cls, const struct GNUNET_SET_CreateMessage *msg) | |||
1066 | * @param tc context information (why was this task triggered now) | 1069 | * @param tc context information (why was this task triggered now) |
1067 | */ | 1070 | */ |
1068 | static void | 1071 | static void |
1069 | incoming_timeout_cb(void *cls) | 1072 | incoming_timeout_cb (void *cls) |
1070 | { | 1073 | { |
1071 | struct Operation *op = cls; | 1074 | struct Operation *op = cls; |
1072 | 1075 | ||
1073 | op->timeout_task = NULL; | 1076 | op->timeout_task = NULL; |
1074 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1077 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1075 | "Remote peer's incoming request timed out\n"); | 1078 | "Remote peer's incoming request timed out\n"); |
1076 | incoming_destroy(op); | 1079 | incoming_destroy (op); |
1077 | } | 1080 | } |
1078 | 1081 | ||
1079 | 1082 | ||
@@ -1094,24 +1097,24 @@ incoming_timeout_cb(void *cls) | |||
1094 | * returns NULL on error | 1097 | * returns NULL on error |
1095 | */ | 1098 | */ |
1096 | static void * | 1099 | static void * |
1097 | channel_new_cb(void *cls, | 1100 | channel_new_cb (void *cls, |
1098 | struct GNUNET_CADET_Channel *channel, | 1101 | struct GNUNET_CADET_Channel *channel, |
1099 | const struct GNUNET_PeerIdentity *source) | 1102 | const struct GNUNET_PeerIdentity *source) |
1100 | { | 1103 | { |
1101 | struct Listener *listener = cls; | 1104 | struct Listener *listener = cls; |
1102 | struct Operation *op; | 1105 | struct Operation *op; |
1103 | 1106 | ||
1104 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "New incoming channel\n"); | 1107 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New incoming channel\n"); |
1105 | op = GNUNET_new(struct Operation); | 1108 | op = GNUNET_new (struct Operation); |
1106 | op->listener = listener; | 1109 | op->listener = listener; |
1107 | op->peer = *source; | 1110 | op->peer = *source; |
1108 | op->channel = channel; | 1111 | op->channel = channel; |
1109 | op->mq = GNUNET_CADET_get_mq(op->channel); | 1112 | op->mq = GNUNET_CADET_get_mq (op->channel); |
1110 | op->salt = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX); | 1113 | op->salt = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX); |
1111 | op->timeout_task = GNUNET_SCHEDULER_add_delayed(INCOMING_CHANNEL_TIMEOUT, | 1114 | op->timeout_task = GNUNET_SCHEDULER_add_delayed (INCOMING_CHANNEL_TIMEOUT, |
1112 | &incoming_timeout_cb, | 1115 | &incoming_timeout_cb, |
1113 | op); | 1116 | op); |
1114 | GNUNET_CONTAINER_DLL_insert(listener->op_head, listener->op_tail, op); | 1117 | GNUNET_CONTAINER_DLL_insert (listener->op_head, listener->op_tail, op); |
1115 | return op; | 1118 | return op; |
1116 | } | 1119 | } |
1117 | 1120 | ||
@@ -1133,12 +1136,12 @@ channel_new_cb(void *cls, | |||
1133 | * @param channel connection to the other end (henceforth invalid) | 1136 | * @param channel connection to the other end (henceforth invalid) |
1134 | */ | 1137 | */ |
1135 | static void | 1138 | static void |
1136 | channel_end_cb(void *channel_ctx, const struct GNUNET_CADET_Channel *channel) | 1139 | channel_end_cb (void *channel_ctx, const struct GNUNET_CADET_Channel *channel) |
1137 | { | 1140 | { |
1138 | struct Operation *op = channel_ctx; | 1141 | struct Operation *op = channel_ctx; |
1139 | 1142 | ||
1140 | op->channel = NULL; | 1143 | op->channel = NULL; |
1141 | _GSS_operation_destroy2(op); | 1144 | _GSS_operation_destroy2 (op); |
1142 | } | 1145 | } |
1143 | 1146 | ||
1144 | 1147 | ||
@@ -1148,28 +1151,28 @@ channel_end_cb(void *channel_ctx, const struct GNUNET_CADET_Channel *channel) | |||
1148 | * logic in the various places where it is called. | 1151 | * logic in the various places where it is called. |
1149 | */ | 1152 | */ |
1150 | void | 1153 | void |
1151 | _GSS_operation_destroy2(struct Operation *op) | 1154 | _GSS_operation_destroy2 (struct Operation *op) |
1152 | { | 1155 | { |
1153 | struct GNUNET_CADET_Channel *channel; | 1156 | struct GNUNET_CADET_Channel *channel; |
1154 | 1157 | ||
1155 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "channel_end_cb called\n"); | 1158 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "channel_end_cb called\n"); |
1156 | if (NULL != (channel = op->channel)) | 1159 | if (NULL != (channel = op->channel)) |
1157 | { | 1160 | { |
1158 | /* This will free op; called conditionally as this helper function | 1161 | /* This will free op; called conditionally as this helper function |
1159 | is also called from within the channel disconnect handler. */ | 1162 | is also called from within the channel disconnect handler. */ |
1160 | op->channel = NULL; | 1163 | op->channel = NULL; |
1161 | GNUNET_CADET_channel_destroy(channel); | 1164 | GNUNET_CADET_channel_destroy (channel); |
1162 | } | 1165 | } |
1163 | if (NULL != op->listener) | 1166 | if (NULL != op->listener) |
1164 | { | 1167 | { |
1165 | incoming_destroy(op); | 1168 | incoming_destroy (op); |
1166 | return; | 1169 | return; |
1167 | } | 1170 | } |
1168 | if (NULL != op->set) | 1171 | if (NULL != op->set) |
1169 | op->set->vt->channel_death(op); | 1172 | op->set->vt->channel_death (op); |
1170 | else | 1173 | else |
1171 | _GSS_operation_destroy(op, GNUNET_YES); | 1174 | _GSS_operation_destroy (op, GNUNET_YES); |
1172 | GNUNET_free(op); | 1175 | GNUNET_free (op); |
1173 | } | 1176 | } |
1174 | 1177 | ||
1175 | 1178 | ||
@@ -1188,9 +1191,9 @@ _GSS_operation_destroy2(struct Operation *op) | |||
1188 | * this value will be negative.. | 1191 | * this value will be negative.. |
1189 | */ | 1192 | */ |
1190 | static void | 1193 | static void |
1191 | channel_window_cb(void *cls, | 1194 | channel_window_cb (void *cls, |
1192 | const struct GNUNET_CADET_Channel *channel, | 1195 | const struct GNUNET_CADET_Channel *channel, |
1193 | int window_size) | 1196 | int window_size) |
1194 | { | 1197 | { |
1195 | /* FIXME: not implemented, we could do flow control here... */ | 1198 | /* FIXME: not implemented, we could do flow control here... */ |
1196 | } | 1199 | } |
@@ -1203,102 +1206,102 @@ channel_window_cb(void *cls, | |||
1203 | * @param msg message sent by the client | 1206 | * @param msg message sent by the client |
1204 | */ | 1207 | */ |
1205 | static void | 1208 | static void |
1206 | handle_client_listen(void *cls, const struct GNUNET_SET_ListenMessage *msg) | 1209 | handle_client_listen (void *cls, const struct GNUNET_SET_ListenMessage *msg) |
1207 | { | 1210 | { |
1208 | struct ClientState *cs = cls; | 1211 | struct ClientState *cs = cls; |
1209 | struct GNUNET_MQ_MessageHandler cadet_handlers[] = | 1212 | struct GNUNET_MQ_MessageHandler cadet_handlers[] = |
1210 | { GNUNET_MQ_hd_var_size(incoming_msg, | 1213 | { GNUNET_MQ_hd_var_size (incoming_msg, |
1211 | GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, | 1214 | GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, |
1212 | struct OperationRequestMessage, | 1215 | struct OperationRequestMessage, |
1213 | NULL), | 1216 | NULL), |
1214 | GNUNET_MQ_hd_var_size(union_p2p_ibf, | 1217 | GNUNET_MQ_hd_var_size (union_p2p_ibf, |
1215 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF, | 1218 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF, |
1216 | struct IBFMessage, | 1219 | struct IBFMessage, |
1217 | NULL), | 1220 | NULL), |
1218 | GNUNET_MQ_hd_var_size(union_p2p_elements, | 1221 | GNUNET_MQ_hd_var_size (union_p2p_elements, |
1219 | GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS, | 1222 | GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS, |
1220 | struct GNUNET_SET_ElementMessage, | 1223 | struct GNUNET_SET_ElementMessage, |
1221 | NULL), | 1224 | NULL), |
1222 | GNUNET_MQ_hd_var_size(union_p2p_offer, | 1225 | GNUNET_MQ_hd_var_size (union_p2p_offer, |
1223 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER, | 1226 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER, |
1224 | struct GNUNET_MessageHeader, | 1227 | struct GNUNET_MessageHeader, |
1225 | NULL), | 1228 | NULL), |
1226 | GNUNET_MQ_hd_var_size(union_p2p_inquiry, | 1229 | GNUNET_MQ_hd_var_size (union_p2p_inquiry, |
1227 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY, | 1230 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY, |
1228 | struct InquiryMessage, | 1231 | struct InquiryMessage, |
1229 | NULL), | 1232 | NULL), |
1230 | GNUNET_MQ_hd_var_size(union_p2p_demand, | 1233 | GNUNET_MQ_hd_var_size (union_p2p_demand, |
1231 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND, | 1234 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND, |
1232 | struct GNUNET_MessageHeader, | 1235 | struct GNUNET_MessageHeader, |
1233 | NULL), | 1236 | NULL), |
1234 | GNUNET_MQ_hd_fixed_size(union_p2p_done, | 1237 | GNUNET_MQ_hd_fixed_size (union_p2p_done, |
1235 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE, | 1238 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE, |
1236 | struct GNUNET_MessageHeader, | 1239 | struct GNUNET_MessageHeader, |
1237 | NULL), | 1240 | NULL), |
1238 | GNUNET_MQ_hd_fixed_size(union_p2p_over, | 1241 | GNUNET_MQ_hd_fixed_size (union_p2p_over, |
1239 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OVER, | 1242 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OVER, |
1240 | struct GNUNET_MessageHeader, | 1243 | struct GNUNET_MessageHeader, |
1241 | NULL), | 1244 | NULL), |
1242 | GNUNET_MQ_hd_fixed_size(union_p2p_full_done, | 1245 | GNUNET_MQ_hd_fixed_size (union_p2p_full_done, |
1243 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE, | 1246 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE, |
1244 | struct GNUNET_MessageHeader, | 1247 | struct GNUNET_MessageHeader, |
1245 | NULL), | 1248 | NULL), |
1246 | GNUNET_MQ_hd_fixed_size(union_p2p_request_full, | 1249 | GNUNET_MQ_hd_fixed_size (union_p2p_request_full, |
1247 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL, | 1250 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL, |
1248 | struct GNUNET_MessageHeader, | 1251 | struct GNUNET_MessageHeader, |
1249 | NULL), | 1252 | NULL), |
1250 | GNUNET_MQ_hd_var_size(union_p2p_strata_estimator, | 1253 | GNUNET_MQ_hd_var_size (union_p2p_strata_estimator, |
1251 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE, | 1254 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE, |
1252 | struct StrataEstimatorMessage, | 1255 | struct StrataEstimatorMessage, |
1253 | NULL), | 1256 | NULL), |
1254 | GNUNET_MQ_hd_var_size(union_p2p_strata_estimator, | 1257 | GNUNET_MQ_hd_var_size (union_p2p_strata_estimator, |
1255 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC, | 1258 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC, |
1256 | struct StrataEstimatorMessage, | 1259 | struct StrataEstimatorMessage, |
1257 | NULL), | 1260 | NULL), |
1258 | GNUNET_MQ_hd_var_size(union_p2p_full_element, | 1261 | GNUNET_MQ_hd_var_size (union_p2p_full_element, |
1259 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT, | 1262 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT, |
1260 | struct GNUNET_SET_ElementMessage, | 1263 | struct GNUNET_SET_ElementMessage, |
1261 | NULL), | 1264 | NULL), |
1262 | GNUNET_MQ_hd_fixed_size(intersection_p2p_element_info, | 1265 | GNUNET_MQ_hd_fixed_size (intersection_p2p_element_info, |
1263 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO, | 1266 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO, |
1264 | struct IntersectionElementInfoMessage, | 1267 | struct IntersectionElementInfoMessage, |
1265 | NULL), | 1268 | NULL), |
1266 | GNUNET_MQ_hd_var_size(intersection_p2p_bf, | 1269 | GNUNET_MQ_hd_var_size (intersection_p2p_bf, |
1267 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF, | 1270 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF, |
1268 | struct BFMessage, | 1271 | struct BFMessage, |
1269 | NULL), | 1272 | NULL), |
1270 | GNUNET_MQ_hd_fixed_size(intersection_p2p_done, | 1273 | GNUNET_MQ_hd_fixed_size (intersection_p2p_done, |
1271 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE, | 1274 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE, |
1272 | struct IntersectionDoneMessage, | 1275 | struct IntersectionDoneMessage, |
1273 | NULL), | 1276 | NULL), |
1274 | GNUNET_MQ_handler_end() }; | 1277 | GNUNET_MQ_handler_end () }; |
1275 | struct Listener *listener; | 1278 | struct Listener *listener; |
1276 | 1279 | ||
1277 | if (NULL != cs->listener) | 1280 | if (NULL != cs->listener) |
1278 | { | 1281 | { |
1279 | /* max. one active listener per client! */ | 1282 | /* max. one active listener per client! */ |
1280 | GNUNET_break(0); | 1283 | GNUNET_break (0); |
1281 | GNUNET_SERVICE_client_drop(cs->client); | 1284 | GNUNET_SERVICE_client_drop (cs->client); |
1282 | return; | 1285 | return; |
1283 | } | 1286 | } |
1284 | listener = GNUNET_new(struct Listener); | 1287 | listener = GNUNET_new (struct Listener); |
1285 | listener->cs = cs; | 1288 | listener->cs = cs; |
1286 | cs->listener = listener; | 1289 | cs->listener = listener; |
1287 | listener->app_id = msg->app_id; | 1290 | listener->app_id = msg->app_id; |
1288 | listener->operation = (enum GNUNET_SET_OperationType)ntohl(msg->operation); | 1291 | listener->operation = (enum GNUNET_SET_OperationType) ntohl (msg->operation); |
1289 | GNUNET_CONTAINER_DLL_insert(listener_head, listener_tail, listener); | 1292 | GNUNET_CONTAINER_DLL_insert (listener_head, listener_tail, listener); |
1290 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1293 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1291 | "New listener created (op %u, port %s)\n", | 1294 | "New listener created (op %u, port %s)\n", |
1292 | listener->operation, | 1295 | listener->operation, |
1293 | GNUNET_h2s(&listener->app_id)); | 1296 | GNUNET_h2s (&listener->app_id)); |
1294 | listener->open_port = GNUNET_CADET_open_port(cadet, | 1297 | listener->open_port = GNUNET_CADET_open_port (cadet, |
1295 | &msg->app_id, | 1298 | &msg->app_id, |
1296 | &channel_new_cb, | 1299 | &channel_new_cb, |
1297 | listener, | 1300 | listener, |
1298 | &channel_window_cb, | 1301 | &channel_window_cb, |
1299 | &channel_end_cb, | 1302 | &channel_end_cb, |
1300 | cadet_handlers); | 1303 | cadet_handlers); |
1301 | GNUNET_SERVICE_client_continue(cs->client); | 1304 | GNUNET_SERVICE_client_continue (cs->client); |
1302 | } | 1305 | } |
1303 | 1306 | ||
1304 | 1307 | ||
@@ -1310,28 +1313,28 @@ handle_client_listen(void *cls, const struct GNUNET_SET_ListenMessage *msg) | |||
1310 | * @param msg message sent by the client | 1313 | * @param msg message sent by the client |
1311 | */ | 1314 | */ |
1312 | static void | 1315 | static void |
1313 | handle_client_reject(void *cls, const struct GNUNET_SET_RejectMessage *msg) | 1316 | handle_client_reject (void *cls, const struct GNUNET_SET_RejectMessage *msg) |
1314 | { | 1317 | { |
1315 | struct ClientState *cs = cls; | 1318 | struct ClientState *cs = cls; |
1316 | struct Operation *op; | 1319 | struct Operation *op; |
1317 | 1320 | ||
1318 | op = get_incoming(ntohl(msg->accept_reject_id)); | 1321 | op = get_incoming (ntohl (msg->accept_reject_id)); |
1319 | if (NULL == op) | 1322 | if (NULL == op) |
1320 | { | 1323 | { |
1321 | /* no matching incoming operation for this reject; | 1324 | /* no matching incoming operation for this reject; |
1322 | could be that the other peer already disconnected... */ | 1325 | could be that the other peer already disconnected... */ |
1323 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1326 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1324 | "Client rejected unknown operation %u\n", | 1327 | "Client rejected unknown operation %u\n", |
1325 | (unsigned int)ntohl(msg->accept_reject_id)); | 1328 | (unsigned int) ntohl (msg->accept_reject_id)); |
1326 | GNUNET_SERVICE_client_continue(cs->client); | 1329 | GNUNET_SERVICE_client_continue (cs->client); |
1327 | return; | 1330 | return; |
1328 | } | 1331 | } |
1329 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1332 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1330 | "Peer request (op %u, app %s) rejected by client\n", | 1333 | "Peer request (op %u, app %s) rejected by client\n", |
1331 | op->listener->operation, | 1334 | op->listener->operation, |
1332 | GNUNET_h2s(&cs->listener->app_id)); | 1335 | GNUNET_h2s (&cs->listener->app_id)); |
1333 | _GSS_operation_destroy2(op); | 1336 | _GSS_operation_destroy2 (op); |
1334 | GNUNET_SERVICE_client_continue(cs->client); | 1337 | GNUNET_SERVICE_client_continue (cs->client); |
1335 | } | 1338 | } |
1336 | 1339 | ||
1337 | 1340 | ||
@@ -1342,7 +1345,7 @@ handle_client_reject(void *cls, const struct GNUNET_SET_RejectMessage *msg) | |||
1342 | * @param msg message sent by the client | 1345 | * @param msg message sent by the client |
1343 | */ | 1346 | */ |
1344 | static int | 1347 | static int |
1345 | check_client_mutation(void *cls, const struct GNUNET_SET_ElementMessage *msg) | 1348 | check_client_mutation (void *cls, const struct GNUNET_SET_ElementMessage *msg) |
1346 | { | 1349 | { |
1347 | /* NOTE: Technically, we should probably check with the | 1350 | /* NOTE: Technically, we should probably check with the |
1348 | block library whether the element we are given is well-formed */ | 1351 | block library whether the element we are given is well-formed */ |
@@ -1357,36 +1360,36 @@ check_client_mutation(void *cls, const struct GNUNET_SET_ElementMessage *msg) | |||
1357 | * @param msg message sent by the client | 1360 | * @param msg message sent by the client |
1358 | */ | 1361 | */ |
1359 | static void | 1362 | static void |
1360 | handle_client_mutation(void *cls, const struct GNUNET_SET_ElementMessage *msg) | 1363 | handle_client_mutation (void *cls, const struct GNUNET_SET_ElementMessage *msg) |
1361 | { | 1364 | { |
1362 | struct ClientState *cs = cls; | 1365 | struct ClientState *cs = cls; |
1363 | struct Set *set; | 1366 | struct Set *set; |
1364 | 1367 | ||
1365 | if (NULL == (set = cs->set)) | 1368 | if (NULL == (set = cs->set)) |
1366 | { | 1369 | { |
1367 | /* client without a set requested an operation */ | 1370 | /* client without a set requested an operation */ |
1368 | GNUNET_break(0); | 1371 | GNUNET_break (0); |
1369 | GNUNET_SERVICE_client_drop(cs->client); | 1372 | GNUNET_SERVICE_client_drop (cs->client); |
1370 | return; | 1373 | return; |
1371 | } | 1374 | } |
1372 | GNUNET_SERVICE_client_continue(cs->client); | 1375 | GNUNET_SERVICE_client_continue (cs->client); |
1373 | 1376 | ||
1374 | if (0 != set->content->iterator_count) | 1377 | if (0 != set->content->iterator_count) |
1375 | { | 1378 | { |
1376 | struct PendingMutation *pm; | 1379 | struct PendingMutation *pm; |
1377 | 1380 | ||
1378 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Scheduling mutation on set\n"); | 1381 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Scheduling mutation on set\n"); |
1379 | pm = GNUNET_new(struct PendingMutation); | 1382 | pm = GNUNET_new (struct PendingMutation); |
1380 | pm->msg = | 1383 | pm->msg = |
1381 | (struct GNUNET_SET_ElementMessage *)GNUNET_copy_message(&msg->header); | 1384 | (struct GNUNET_SET_ElementMessage *) GNUNET_copy_message (&msg->header); |
1382 | pm->set = set; | 1385 | pm->set = set; |
1383 | GNUNET_CONTAINER_DLL_insert_tail(set->content->pending_mutations_head, | 1386 | GNUNET_CONTAINER_DLL_insert_tail (set->content->pending_mutations_head, |
1384 | set->content->pending_mutations_tail, | 1387 | set->content->pending_mutations_tail, |
1385 | pm); | 1388 | pm); |
1386 | return; | 1389 | return; |
1387 | } | 1390 | } |
1388 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Executing mutation on set\n"); | 1391 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing mutation on set\n"); |
1389 | execute_mutation(set, msg); | 1392 | execute_mutation (set, msg); |
1390 | } | 1393 | } |
1391 | 1394 | ||
1392 | 1395 | ||
@@ -1397,26 +1400,26 @@ handle_client_mutation(void *cls, const struct GNUNET_SET_ElementMessage *msg) | |||
1397 | * @param set the set where we want to advance the generation | 1400 | * @param set the set where we want to advance the generation |
1398 | */ | 1401 | */ |
1399 | static void | 1402 | static void |
1400 | advance_generation(struct Set *set) | 1403 | advance_generation (struct Set *set) |
1401 | { | 1404 | { |
1402 | struct GenerationRange r; | 1405 | struct GenerationRange r; |
1403 | 1406 | ||
1404 | if (set->current_generation == set->content->latest_generation) | 1407 | if (set->current_generation == set->content->latest_generation) |
1405 | { | 1408 | { |
1406 | set->content->latest_generation++; | 1409 | set->content->latest_generation++; |
1407 | set->current_generation++; | 1410 | set->current_generation++; |
1408 | return; | 1411 | return; |
1409 | } | 1412 | } |
1410 | 1413 | ||
1411 | GNUNET_assert(set->current_generation < set->content->latest_generation); | 1414 | GNUNET_assert (set->current_generation < set->content->latest_generation); |
1412 | 1415 | ||
1413 | r.start = set->current_generation + 1; | 1416 | r.start = set->current_generation + 1; |
1414 | r.end = set->content->latest_generation + 1; | 1417 | r.end = set->content->latest_generation + 1; |
1415 | set->content->latest_generation = r.end; | 1418 | set->content->latest_generation = r.end; |
1416 | set->current_generation = r.end; | 1419 | set->current_generation = r.end; |
1417 | GNUNET_array_append(set->excluded_generations, | 1420 | GNUNET_array_append (set->excluded_generations, |
1418 | set->excluded_generations_size, | 1421 | set->excluded_generations_size, |
1419 | r); | 1422 | r); |
1420 | } | 1423 | } |
1421 | 1424 | ||
1422 | 1425 | ||
@@ -1430,7 +1433,7 @@ advance_generation(struct Set *set) | |||
1430 | * @return #GNUNET_OK if the message is well-formed | 1433 | * @return #GNUNET_OK if the message is well-formed |
1431 | */ | 1434 | */ |
1432 | static int | 1435 | static int |
1433 | check_client_evaluate(void *cls, const struct GNUNET_SET_EvaluateMessage *msg) | 1436 | check_client_evaluate (void *cls, const struct GNUNET_SET_EvaluateMessage *msg) |
1434 | { | 1437 | { |
1435 | /* FIXME: suboptimal, even if the context below could be NULL, | 1438 | /* FIXME: suboptimal, even if the context below could be NULL, |
1436 | there are malformed messages this does not check for... */ | 1439 | there are malformed messages this does not check for... */ |
@@ -1447,122 +1450,122 @@ check_client_evaluate(void *cls, const struct GNUNET_SET_EvaluateMessage *msg) | |||
1447 | * @param msg message sent by the client | 1450 | * @param msg message sent by the client |
1448 | */ | 1451 | */ |
1449 | static void | 1452 | static void |
1450 | handle_client_evaluate(void *cls, const struct GNUNET_SET_EvaluateMessage *msg) | 1453 | handle_client_evaluate (void *cls, const struct GNUNET_SET_EvaluateMessage *msg) |
1451 | { | 1454 | { |
1452 | struct ClientState *cs = cls; | 1455 | struct ClientState *cs = cls; |
1453 | struct Operation *op = GNUNET_new(struct Operation); | 1456 | struct Operation *op = GNUNET_new (struct Operation); |
1454 | const struct GNUNET_MQ_MessageHandler cadet_handlers[] = | 1457 | const struct GNUNET_MQ_MessageHandler cadet_handlers[] = |
1455 | { GNUNET_MQ_hd_var_size(incoming_msg, | 1458 | { GNUNET_MQ_hd_var_size (incoming_msg, |
1456 | GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, | 1459 | GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, |
1457 | struct OperationRequestMessage, | 1460 | struct OperationRequestMessage, |
1458 | op), | 1461 | op), |
1459 | GNUNET_MQ_hd_var_size(union_p2p_ibf, | 1462 | GNUNET_MQ_hd_var_size (union_p2p_ibf, |
1460 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF, | 1463 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF, |
1461 | struct IBFMessage, | 1464 | struct IBFMessage, |
1462 | op), | 1465 | op), |
1463 | GNUNET_MQ_hd_var_size(union_p2p_elements, | 1466 | GNUNET_MQ_hd_var_size (union_p2p_elements, |
1464 | GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS, | 1467 | GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS, |
1465 | struct GNUNET_SET_ElementMessage, | 1468 | struct GNUNET_SET_ElementMessage, |
1466 | op), | 1469 | op), |
1467 | GNUNET_MQ_hd_var_size(union_p2p_offer, | 1470 | GNUNET_MQ_hd_var_size (union_p2p_offer, |
1468 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER, | 1471 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER, |
1469 | struct GNUNET_MessageHeader, | 1472 | struct GNUNET_MessageHeader, |
1470 | op), | 1473 | op), |
1471 | GNUNET_MQ_hd_var_size(union_p2p_inquiry, | 1474 | GNUNET_MQ_hd_var_size (union_p2p_inquiry, |
1472 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY, | 1475 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY, |
1473 | struct InquiryMessage, | 1476 | struct InquiryMessage, |
1474 | op), | 1477 | op), |
1475 | GNUNET_MQ_hd_var_size(union_p2p_demand, | 1478 | GNUNET_MQ_hd_var_size (union_p2p_demand, |
1476 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND, | 1479 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND, |
1477 | struct GNUNET_MessageHeader, | 1480 | struct GNUNET_MessageHeader, |
1478 | op), | 1481 | op), |
1479 | GNUNET_MQ_hd_fixed_size(union_p2p_done, | 1482 | GNUNET_MQ_hd_fixed_size (union_p2p_done, |
1480 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE, | 1483 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE, |
1481 | struct GNUNET_MessageHeader, | 1484 | struct GNUNET_MessageHeader, |
1482 | op), | 1485 | op), |
1483 | GNUNET_MQ_hd_fixed_size(union_p2p_over, | 1486 | GNUNET_MQ_hd_fixed_size (union_p2p_over, |
1484 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OVER, | 1487 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OVER, |
1485 | struct GNUNET_MessageHeader, | 1488 | struct GNUNET_MessageHeader, |
1486 | op), | 1489 | op), |
1487 | GNUNET_MQ_hd_fixed_size(union_p2p_full_done, | 1490 | GNUNET_MQ_hd_fixed_size (union_p2p_full_done, |
1488 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE, | 1491 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE, |
1489 | struct GNUNET_MessageHeader, | 1492 | struct GNUNET_MessageHeader, |
1490 | op), | 1493 | op), |
1491 | GNUNET_MQ_hd_fixed_size(union_p2p_request_full, | 1494 | GNUNET_MQ_hd_fixed_size (union_p2p_request_full, |
1492 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL, | 1495 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL, |
1493 | struct GNUNET_MessageHeader, | 1496 | struct GNUNET_MessageHeader, |
1494 | op), | 1497 | op), |
1495 | GNUNET_MQ_hd_var_size(union_p2p_strata_estimator, | 1498 | GNUNET_MQ_hd_var_size (union_p2p_strata_estimator, |
1496 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE, | 1499 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE, |
1497 | struct StrataEstimatorMessage, | 1500 | struct StrataEstimatorMessage, |
1498 | op), | 1501 | op), |
1499 | GNUNET_MQ_hd_var_size(union_p2p_strata_estimator, | 1502 | GNUNET_MQ_hd_var_size (union_p2p_strata_estimator, |
1500 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC, | 1503 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC, |
1501 | struct StrataEstimatorMessage, | 1504 | struct StrataEstimatorMessage, |
1502 | op), | 1505 | op), |
1503 | GNUNET_MQ_hd_var_size(union_p2p_full_element, | 1506 | GNUNET_MQ_hd_var_size (union_p2p_full_element, |
1504 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT, | 1507 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT, |
1505 | struct GNUNET_SET_ElementMessage, | 1508 | struct GNUNET_SET_ElementMessage, |
1506 | op), | 1509 | op), |
1507 | GNUNET_MQ_hd_fixed_size(intersection_p2p_element_info, | 1510 | GNUNET_MQ_hd_fixed_size (intersection_p2p_element_info, |
1508 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO, | 1511 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO, |
1509 | struct IntersectionElementInfoMessage, | 1512 | struct IntersectionElementInfoMessage, |
1510 | op), | 1513 | op), |
1511 | GNUNET_MQ_hd_var_size(intersection_p2p_bf, | 1514 | GNUNET_MQ_hd_var_size (intersection_p2p_bf, |
1512 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF, | 1515 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF, |
1513 | struct BFMessage, | 1516 | struct BFMessage, |
1514 | op), | 1517 | op), |
1515 | GNUNET_MQ_hd_fixed_size(intersection_p2p_done, | 1518 | GNUNET_MQ_hd_fixed_size (intersection_p2p_done, |
1516 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE, | 1519 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE, |
1517 | struct IntersectionDoneMessage, | 1520 | struct IntersectionDoneMessage, |
1518 | op), | 1521 | op), |
1519 | GNUNET_MQ_handler_end() }; | 1522 | GNUNET_MQ_handler_end () }; |
1520 | struct Set *set; | 1523 | struct Set *set; |
1521 | const struct GNUNET_MessageHeader *context; | 1524 | const struct GNUNET_MessageHeader *context; |
1522 | 1525 | ||
1523 | if (NULL == (set = cs->set)) | 1526 | if (NULL == (set = cs->set)) |
1524 | { | 1527 | { |
1525 | GNUNET_break(0); | 1528 | GNUNET_break (0); |
1526 | GNUNET_free(op); | 1529 | GNUNET_free (op); |
1527 | GNUNET_SERVICE_client_drop(cs->client); | 1530 | GNUNET_SERVICE_client_drop (cs->client); |
1528 | return; | 1531 | return; |
1529 | } | 1532 | } |
1530 | op->salt = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX); | 1533 | op->salt = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX); |
1531 | op->peer = msg->target_peer; | 1534 | op->peer = msg->target_peer; |
1532 | op->result_mode = ntohl(msg->result_mode); | 1535 | op->result_mode = ntohl (msg->result_mode); |
1533 | op->client_request_id = ntohl(msg->request_id); | 1536 | op->client_request_id = ntohl (msg->request_id); |
1534 | op->byzantine = msg->byzantine; | 1537 | op->byzantine = msg->byzantine; |
1535 | op->byzantine_lower_bound = msg->byzantine_lower_bound; | 1538 | op->byzantine_lower_bound = msg->byzantine_lower_bound; |
1536 | op->force_full = msg->force_full; | 1539 | op->force_full = msg->force_full; |
1537 | op->force_delta = msg->force_delta; | 1540 | op->force_delta = msg->force_delta; |
1538 | context = GNUNET_MQ_extract_nested_mh(msg); | 1541 | context = GNUNET_MQ_extract_nested_mh (msg); |
1539 | 1542 | ||
1540 | /* Advance generation values, so that | 1543 | /* Advance generation values, so that |
1541 | mutations won't interfer with the running operation. */ | 1544 | mutations won't interfer with the running operation. */ |
1542 | op->set = set; | 1545 | op->set = set; |
1543 | op->generation_created = set->current_generation; | 1546 | op->generation_created = set->current_generation; |
1544 | advance_generation(set); | 1547 | advance_generation (set); |
1545 | GNUNET_CONTAINER_DLL_insert(set->ops_head, set->ops_tail, op); | 1548 | GNUNET_CONTAINER_DLL_insert (set->ops_head, set->ops_tail, op); |
1546 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1549 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1547 | "Creating new CADET channel to port %s for set operation type %u\n", | 1550 | "Creating new CADET channel to port %s for set operation type %u\n", |
1548 | GNUNET_h2s(&msg->app_id), | 1551 | GNUNET_h2s (&msg->app_id), |
1549 | set->operation); | 1552 | set->operation); |
1550 | op->channel = GNUNET_CADET_channel_create(cadet, | 1553 | op->channel = GNUNET_CADET_channel_create (cadet, |
1551 | op, | 1554 | op, |
1552 | &msg->target_peer, | 1555 | &msg->target_peer, |
1553 | &msg->app_id, | 1556 | &msg->app_id, |
1554 | &channel_window_cb, | 1557 | &channel_window_cb, |
1555 | &channel_end_cb, | 1558 | &channel_end_cb, |
1556 | cadet_handlers); | 1559 | cadet_handlers); |
1557 | op->mq = GNUNET_CADET_get_mq(op->channel); | 1560 | op->mq = GNUNET_CADET_get_mq (op->channel); |
1558 | op->state = set->vt->evaluate(op, context); | 1561 | op->state = set->vt->evaluate (op, context); |
1559 | if (NULL == op->state) | 1562 | if (NULL == op->state) |
1560 | { | 1563 | { |
1561 | GNUNET_break(0); | 1564 | GNUNET_break (0); |
1562 | GNUNET_SERVICE_client_drop(cs->client); | 1565 | GNUNET_SERVICE_client_drop (cs->client); |
1563 | return; | 1566 | return; |
1564 | } | 1567 | } |
1565 | GNUNET_SERVICE_client_continue(cs->client); | 1568 | GNUNET_SERVICE_client_continue (cs->client); |
1566 | } | 1569 | } |
1567 | 1570 | ||
1568 | 1571 | ||
@@ -1575,37 +1578,37 @@ handle_client_evaluate(void *cls, const struct GNUNET_SET_EvaluateMessage *msg) | |||
1575 | * @param ack the message | 1578 | * @param ack the message |
1576 | */ | 1579 | */ |
1577 | static void | 1580 | static void |
1578 | handle_client_iter_ack(void *cls, const struct GNUNET_SET_IterAckMessage *ack) | 1581 | handle_client_iter_ack (void *cls, const struct GNUNET_SET_IterAckMessage *ack) |
1579 | { | 1582 | { |
1580 | struct ClientState *cs = cls; | 1583 | struct ClientState *cs = cls; |
1581 | struct Set *set; | 1584 | struct Set *set; |
1582 | 1585 | ||
1583 | if (NULL == (set = cs->set)) | 1586 | if (NULL == (set = cs->set)) |
1584 | { | 1587 | { |
1585 | /* client without a set acknowledged receiving a value */ | 1588 | /* client without a set acknowledged receiving a value */ |
1586 | GNUNET_break(0); | 1589 | GNUNET_break (0); |
1587 | GNUNET_SERVICE_client_drop(cs->client); | 1590 | GNUNET_SERVICE_client_drop (cs->client); |
1588 | return; | 1591 | return; |
1589 | } | 1592 | } |
1590 | if (NULL == set->iter) | 1593 | if (NULL == set->iter) |
1591 | { | 1594 | { |
1592 | /* client sent an ack, but we were not expecting one (as | 1595 | /* client sent an ack, but we were not expecting one (as |
1593 | set iteration has finished) */ | 1596 | set iteration has finished) */ |
1594 | GNUNET_break(0); | 1597 | GNUNET_break (0); |
1595 | GNUNET_SERVICE_client_drop(cs->client); | 1598 | GNUNET_SERVICE_client_drop (cs->client); |
1596 | return; | 1599 | return; |
1597 | } | 1600 | } |
1598 | GNUNET_SERVICE_client_continue(cs->client); | 1601 | GNUNET_SERVICE_client_continue (cs->client); |
1599 | if (ntohl(ack->send_more)) | 1602 | if (ntohl (ack->send_more)) |
1600 | { | 1603 | { |
1601 | send_client_element(set); | 1604 | send_client_element (set); |
1602 | } | 1605 | } |
1603 | else | 1606 | else |
1604 | { | 1607 | { |
1605 | GNUNET_CONTAINER_multihashmap_iterator_destroy(set->iter); | 1608 | GNUNET_CONTAINER_multihashmap_iterator_destroy (set->iter); |
1606 | set->iter = NULL; | 1609 | set->iter = NULL; |
1607 | set->iteration_id++; | 1610 | set->iteration_id++; |
1608 | } | 1611 | } |
1609 | } | 1612 | } |
1610 | 1613 | ||
1611 | 1614 | ||
@@ -1616,8 +1619,8 @@ handle_client_iter_ack(void *cls, const struct GNUNET_SET_IterAckMessage *ack) | |||
1616 | * @param mh the message | 1619 | * @param mh the message |
1617 | */ | 1620 | */ |
1618 | static void | 1621 | static void |
1619 | handle_client_copy_lazy_prepare(void *cls, | 1622 | handle_client_copy_lazy_prepare (void *cls, |
1620 | const struct GNUNET_MessageHeader *mh) | 1623 | const struct GNUNET_MessageHeader *mh) |
1621 | { | 1624 | { |
1622 | struct ClientState *cs = cls; | 1625 | struct ClientState *cs = cls; |
1623 | struct Set *set; | 1626 | struct Set *set; |
@@ -1626,22 +1629,22 @@ handle_client_copy_lazy_prepare(void *cls, | |||
1626 | struct GNUNET_SET_CopyLazyResponseMessage *resp_msg; | 1629 | struct GNUNET_SET_CopyLazyResponseMessage *resp_msg; |
1627 | 1630 | ||
1628 | if (NULL == (set = cs->set)) | 1631 | if (NULL == (set = cs->set)) |
1629 | { | 1632 | { |
1630 | /* client without a set requested an operation */ | 1633 | /* client without a set requested an operation */ |
1631 | GNUNET_break(0); | 1634 | GNUNET_break (0); |
1632 | GNUNET_SERVICE_client_drop(cs->client); | 1635 | GNUNET_SERVICE_client_drop (cs->client); |
1633 | return; | 1636 | return; |
1634 | } | 1637 | } |
1635 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1638 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1636 | "Client requested creation of lazy copy\n"); | 1639 | "Client requested creation of lazy copy\n"); |
1637 | cr = GNUNET_new(struct LazyCopyRequest); | 1640 | cr = GNUNET_new (struct LazyCopyRequest); |
1638 | cr->cookie = ++lazy_copy_cookie; | 1641 | cr->cookie = ++lazy_copy_cookie; |
1639 | cr->source_set = set; | 1642 | cr->source_set = set; |
1640 | GNUNET_CONTAINER_DLL_insert(lazy_copy_head, lazy_copy_tail, cr); | 1643 | GNUNET_CONTAINER_DLL_insert (lazy_copy_head, lazy_copy_tail, cr); |
1641 | ev = GNUNET_MQ_msg(resp_msg, GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE); | 1644 | ev = GNUNET_MQ_msg (resp_msg, GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE); |
1642 | resp_msg->cookie = cr->cookie; | 1645 | resp_msg->cookie = cr->cookie; |
1643 | GNUNET_MQ_send(set->cs->mq, ev); | 1646 | GNUNET_MQ_send (set->cs->mq, ev); |
1644 | GNUNET_SERVICE_client_continue(cs->client); | 1647 | GNUNET_SERVICE_client_continue (cs->client); |
1645 | } | 1648 | } |
1646 | 1649 | ||
1647 | 1650 | ||
@@ -1652,7 +1655,7 @@ handle_client_copy_lazy_prepare(void *cls, | |||
1652 | * @param msg the message | 1655 | * @param msg the message |
1653 | */ | 1656 | */ |
1654 | static void | 1657 | static void |
1655 | handle_client_copy_lazy_connect( | 1658 | handle_client_copy_lazy_connect ( |
1656 | void *cls, | 1659 | void *cls, |
1657 | const struct GNUNET_SET_CopyLazyConnectMessage *msg) | 1660 | const struct GNUNET_SET_CopyLazyConnectMessage *msg) |
1658 | { | 1661 | { |
@@ -1662,77 +1665,77 @@ handle_client_copy_lazy_connect( | |||
1662 | int found; | 1665 | int found; |
1663 | 1666 | ||
1664 | if (NULL != cs->set) | 1667 | if (NULL != cs->set) |
1665 | { | 1668 | { |
1666 | /* There can only be one set per client */ | 1669 | /* There can only be one set per client */ |
1667 | GNUNET_break(0); | 1670 | GNUNET_break (0); |
1668 | GNUNET_SERVICE_client_drop(cs->client); | 1671 | GNUNET_SERVICE_client_drop (cs->client); |
1669 | return; | 1672 | return; |
1670 | } | 1673 | } |
1671 | found = GNUNET_NO; | 1674 | found = GNUNET_NO; |
1672 | for (cr = lazy_copy_head; NULL != cr; cr = cr->next) | 1675 | for (cr = lazy_copy_head; NULL != cr; cr = cr->next) |
1676 | { | ||
1677 | if (cr->cookie == msg->cookie) | ||
1673 | { | 1678 | { |
1674 | if (cr->cookie == msg->cookie) | 1679 | found = GNUNET_YES; |
1675 | { | 1680 | break; |
1676 | found = GNUNET_YES; | ||
1677 | break; | ||
1678 | } | ||
1679 | } | 1681 | } |
1682 | } | ||
1680 | if (GNUNET_NO == found) | 1683 | if (GNUNET_NO == found) |
1681 | { | 1684 | { |
1682 | /* client asked for copy with cookie we don't know */ | 1685 | /* client asked for copy with cookie we don't know */ |
1683 | GNUNET_break(0); | 1686 | GNUNET_break (0); |
1684 | GNUNET_SERVICE_client_drop(cs->client); | 1687 | GNUNET_SERVICE_client_drop (cs->client); |
1685 | return; | 1688 | return; |
1686 | } | 1689 | } |
1687 | GNUNET_CONTAINER_DLL_remove(lazy_copy_head, lazy_copy_tail, cr); | 1690 | GNUNET_CONTAINER_DLL_remove (lazy_copy_head, lazy_copy_tail, cr); |
1688 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1691 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1689 | "Client %p requested use of lazy copy\n", | 1692 | "Client %p requested use of lazy copy\n", |
1690 | cs); | 1693 | cs); |
1691 | set = GNUNET_new(struct Set); | 1694 | set = GNUNET_new (struct Set); |
1692 | switch (cr->source_set->operation) | 1695 | switch (cr->source_set->operation) |
1693 | { | 1696 | { |
1694 | case GNUNET_SET_OPERATION_INTERSECTION: | 1697 | case GNUNET_SET_OPERATION_INTERSECTION: |
1695 | set->vt = _GSS_intersection_vt(); | 1698 | set->vt = _GSS_intersection_vt (); |
1696 | break; | 1699 | break; |
1697 | 1700 | ||
1698 | case GNUNET_SET_OPERATION_UNION: | 1701 | case GNUNET_SET_OPERATION_UNION: |
1699 | set->vt = _GSS_union_vt(); | 1702 | set->vt = _GSS_union_vt (); |
1700 | break; | 1703 | break; |
1701 | 1704 | ||
1702 | default: | 1705 | default: |
1703 | GNUNET_assert(0); | 1706 | GNUNET_assert (0); |
1704 | return; | 1707 | return; |
1705 | } | 1708 | } |
1706 | 1709 | ||
1707 | if (NULL == set->vt->copy_state) | 1710 | if (NULL == set->vt->copy_state) |
1708 | { | 1711 | { |
1709 | /* Lazy copy not supported for this set operation */ | 1712 | /* Lazy copy not supported for this set operation */ |
1710 | GNUNET_break(0); | 1713 | GNUNET_break (0); |
1711 | GNUNET_free(set); | 1714 | GNUNET_free (set); |
1712 | GNUNET_free(cr); | 1715 | GNUNET_free (cr); |
1713 | GNUNET_SERVICE_client_drop(cs->client); | 1716 | GNUNET_SERVICE_client_drop (cs->client); |
1714 | return; | 1717 | return; |
1715 | } | 1718 | } |
1716 | 1719 | ||
1717 | set->operation = cr->source_set->operation; | 1720 | set->operation = cr->source_set->operation; |
1718 | set->state = set->vt->copy_state(cr->source_set->state); | 1721 | set->state = set->vt->copy_state (cr->source_set->state); |
1719 | set->content = cr->source_set->content; | 1722 | set->content = cr->source_set->content; |
1720 | set->content->refcount++; | 1723 | set->content->refcount++; |
1721 | 1724 | ||
1722 | set->current_generation = cr->source_set->current_generation; | 1725 | set->current_generation = cr->source_set->current_generation; |
1723 | set->excluded_generations_size = cr->source_set->excluded_generations_size; | 1726 | set->excluded_generations_size = cr->source_set->excluded_generations_size; |
1724 | set->excluded_generations = | 1727 | set->excluded_generations = |
1725 | GNUNET_memdup(cr->source_set->excluded_generations, | 1728 | GNUNET_memdup (cr->source_set->excluded_generations, |
1726 | set->excluded_generations_size * | 1729 | set->excluded_generations_size |
1727 | sizeof(struct GenerationRange)); | 1730 | * sizeof(struct GenerationRange)); |
1728 | 1731 | ||
1729 | /* Advance the generation of the new set, so that mutations to the | 1732 | /* Advance the generation of the new set, so that mutations to the |
1730 | of the cloned set and the source set are independent. */ | 1733 | of the cloned set and the source set are independent. */ |
1731 | advance_generation(set); | 1734 | advance_generation (set); |
1732 | set->cs = cs; | 1735 | set->cs = cs; |
1733 | cs->set = set; | 1736 | cs->set = set; |
1734 | GNUNET_free(cr); | 1737 | GNUNET_free (cr); |
1735 | GNUNET_SERVICE_client_continue(cs->client); | 1738 | GNUNET_SERVICE_client_continue (cs->client); |
1736 | } | 1739 | } |
1737 | 1740 | ||
1738 | 1741 | ||
@@ -1743,7 +1746,7 @@ handle_client_copy_lazy_connect( | |||
1743 | * @param msg the message | 1746 | * @param msg the message |
1744 | */ | 1747 | */ |
1745 | static void | 1748 | static void |
1746 | handle_client_cancel(void *cls, const struct GNUNET_SET_CancelMessage *msg) | 1749 | handle_client_cancel (void *cls, const struct GNUNET_SET_CancelMessage *msg) |
1747 | { | 1750 | { |
1748 | struct ClientState *cs = cls; | 1751 | struct ClientState *cs = cls; |
1749 | struct Set *set; | 1752 | struct Set *set; |
@@ -1751,40 +1754,40 @@ handle_client_cancel(void *cls, const struct GNUNET_SET_CancelMessage *msg) | |||
1751 | int found; | 1754 | int found; |
1752 | 1755 | ||
1753 | if (NULL == (set = cs->set)) | 1756 | if (NULL == (set = cs->set)) |
1754 | { | 1757 | { |
1755 | /* client without a set requested an operation */ | 1758 | /* client without a set requested an operation */ |
1756 | GNUNET_break(0); | 1759 | GNUNET_break (0); |
1757 | GNUNET_SERVICE_client_drop(cs->client); | 1760 | GNUNET_SERVICE_client_drop (cs->client); |
1758 | return; | 1761 | return; |
1759 | } | 1762 | } |
1760 | found = GNUNET_NO; | 1763 | found = GNUNET_NO; |
1761 | for (op = set->ops_head; NULL != op; op = op->next) | 1764 | for (op = set->ops_head; NULL != op; op = op->next) |
1765 | { | ||
1766 | if (op->client_request_id == ntohl (msg->request_id)) | ||
1762 | { | 1767 | { |
1763 | if (op->client_request_id == ntohl(msg->request_id)) | 1768 | found = GNUNET_YES; |
1764 | { | 1769 | break; |
1765 | found = GNUNET_YES; | ||
1766 | break; | ||
1767 | } | ||
1768 | } | 1770 | } |
1771 | } | ||
1769 | if (GNUNET_NO == found) | 1772 | if (GNUNET_NO == found) |
1770 | { | 1773 | { |
1771 | /* It may happen that the operation was already destroyed due to | 1774 | /* It may happen that the operation was already destroyed due to |
1772 | * the other peer disconnecting. The client may not know about this | 1775 | * the other peer disconnecting. The client may not know about this |
1773 | * yet and try to cancel the (just barely non-existent) operation. | 1776 | * yet and try to cancel the (just barely non-existent) operation. |
1774 | * So this is not a hard error. | 1777 | * So this is not a hard error. |
1775 | */ | 1778 | */ |
1776 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 1779 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1777 | "Client canceled non-existent op %u\n", | 1780 | "Client canceled non-existent op %u\n", |
1778 | (uint32_t)ntohl(msg->request_id)); | 1781 | (uint32_t) ntohl (msg->request_id)); |
1779 | } | 1782 | } |
1780 | else | 1783 | else |
1781 | { | 1784 | { |
1782 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1785 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1783 | "Client requested cancel for op %u\n", | 1786 | "Client requested cancel for op %u\n", |
1784 | (uint32_t)ntohl(msg->request_id)); | 1787 | (uint32_t) ntohl (msg->request_id)); |
1785 | _GSS_operation_destroy(op, GNUNET_YES); | 1788 | _GSS_operation_destroy (op, GNUNET_YES); |
1786 | } | 1789 | } |
1787 | GNUNET_SERVICE_client_continue(cs->client); | 1790 | GNUNET_SERVICE_client_continue (cs->client); |
1788 | } | 1791 | } |
1789 | 1792 | ||
1790 | 1793 | ||
@@ -1797,7 +1800,7 @@ handle_client_cancel(void *cls, const struct GNUNET_SET_CancelMessage *msg) | |||
1797 | * @param msg the message | 1800 | * @param msg the message |
1798 | */ | 1801 | */ |
1799 | static void | 1802 | static void |
1800 | handle_client_accept(void *cls, const struct GNUNET_SET_AcceptMessage *msg) | 1803 | handle_client_accept (void *cls, const struct GNUNET_SET_AcceptMessage *msg) |
1801 | { | 1804 | { |
1802 | struct ClientState *cs = cls; | 1805 | struct ClientState *cs = cls; |
1803 | struct Set *set; | 1806 | struct Set *set; |
@@ -1807,40 +1810,40 @@ handle_client_accept(void *cls, const struct GNUNET_SET_AcceptMessage *msg) | |||
1807 | struct Listener *listener; | 1810 | struct Listener *listener; |
1808 | 1811 | ||
1809 | if (NULL == (set = cs->set)) | 1812 | if (NULL == (set = cs->set)) |
1810 | { | 1813 | { |
1811 | /* client without a set requested to accept */ | 1814 | /* client without a set requested to accept */ |
1812 | GNUNET_break(0); | 1815 | GNUNET_break (0); |
1813 | GNUNET_SERVICE_client_drop(cs->client); | 1816 | GNUNET_SERVICE_client_drop (cs->client); |
1814 | return; | 1817 | return; |
1815 | } | 1818 | } |
1816 | op = get_incoming(ntohl(msg->accept_reject_id)); | 1819 | op = get_incoming (ntohl (msg->accept_reject_id)); |
1817 | if (NULL == op) | 1820 | if (NULL == op) |
1818 | { | 1821 | { |
1819 | /* It is not an error if the set op does not exist -- it may | 1822 | /* It is not an error if the set op does not exist -- it may |
1820 | * have been destroyed when the partner peer disconnected. */ | 1823 | * have been destroyed when the partner peer disconnected. */ |
1821 | GNUNET_log( | 1824 | GNUNET_log ( |
1822 | GNUNET_ERROR_TYPE_INFO, | 1825 | GNUNET_ERROR_TYPE_INFO, |
1823 | "Client %p accepted request %u of listener %p that is no longer active\n", | 1826 | "Client %p accepted request %u of listener %p that is no longer active\n", |
1824 | cs, | 1827 | cs, |
1825 | ntohl(msg->accept_reject_id), | 1828 | ntohl (msg->accept_reject_id), |
1826 | cs->listener); | 1829 | cs->listener); |
1827 | ev = GNUNET_MQ_msg(result_message, GNUNET_MESSAGE_TYPE_SET_RESULT); | 1830 | ev = GNUNET_MQ_msg (result_message, GNUNET_MESSAGE_TYPE_SET_RESULT); |
1828 | result_message->request_id = msg->request_id; | 1831 | result_message->request_id = msg->request_id; |
1829 | result_message->result_status = htons(GNUNET_SET_STATUS_FAILURE); | 1832 | result_message->result_status = htons (GNUNET_SET_STATUS_FAILURE); |
1830 | GNUNET_MQ_send(set->cs->mq, ev); | 1833 | GNUNET_MQ_send (set->cs->mq, ev); |
1831 | GNUNET_SERVICE_client_continue(cs->client); | 1834 | GNUNET_SERVICE_client_continue (cs->client); |
1832 | return; | 1835 | return; |
1833 | } | 1836 | } |
1834 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1837 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1835 | "Client accepting request %u\n", | 1838 | "Client accepting request %u\n", |
1836 | (uint32_t)ntohl(msg->accept_reject_id)); | 1839 | (uint32_t) ntohl (msg->accept_reject_id)); |
1837 | listener = op->listener; | 1840 | listener = op->listener; |
1838 | op->listener = NULL; | 1841 | op->listener = NULL; |
1839 | GNUNET_CONTAINER_DLL_remove(listener->op_head, listener->op_tail, op); | 1842 | GNUNET_CONTAINER_DLL_remove (listener->op_head, listener->op_tail, op); |
1840 | op->set = set; | 1843 | op->set = set; |
1841 | GNUNET_CONTAINER_DLL_insert(set->ops_head, set->ops_tail, op); | 1844 | GNUNET_CONTAINER_DLL_insert (set->ops_head, set->ops_tail, op); |
1842 | op->client_request_id = ntohl(msg->request_id); | 1845 | op->client_request_id = ntohl (msg->request_id); |
1843 | op->result_mode = ntohl(msg->result_mode); | 1846 | op->result_mode = ntohl (msg->result_mode); |
1844 | op->byzantine = msg->byzantine; | 1847 | op->byzantine = msg->byzantine; |
1845 | op->byzantine_lower_bound = msg->byzantine_lower_bound; | 1848 | op->byzantine_lower_bound = msg->byzantine_lower_bound; |
1846 | op->force_full = msg->force_full; | 1849 | op->force_full = msg->force_full; |
@@ -1849,20 +1852,20 @@ handle_client_accept(void *cls, const struct GNUNET_SET_AcceptMessage *msg) | |||
1849 | /* Advance generation values, so that future mutations do not | 1852 | /* Advance generation values, so that future mutations do not |
1850 | interfer with the running operation. */ | 1853 | interfer with the running operation. */ |
1851 | op->generation_created = set->current_generation; | 1854 | op->generation_created = set->current_generation; |
1852 | advance_generation(set); | 1855 | advance_generation (set); |
1853 | GNUNET_assert(NULL == op->state); | 1856 | GNUNET_assert (NULL == op->state); |
1854 | op->state = set->vt->accept(op); | 1857 | op->state = set->vt->accept (op); |
1855 | if (NULL == op->state) | 1858 | if (NULL == op->state) |
1856 | { | 1859 | { |
1857 | GNUNET_break(0); | 1860 | GNUNET_break (0); |
1858 | GNUNET_SERVICE_client_drop(cs->client); | 1861 | GNUNET_SERVICE_client_drop (cs->client); |
1859 | return; | 1862 | return; |
1860 | } | 1863 | } |
1861 | /* Now allow CADET to continue, as we did not do this in | 1864 | /* Now allow CADET to continue, as we did not do this in |
1862 | #handle_incoming_msg (as we wanted to first see if the | 1865 | #handle_incoming_msg (as we wanted to first see if the |
1863 | local client would accept the request). */ | 1866 | local client would accept the request). */ |
1864 | GNUNET_CADET_receive_done(op->channel); | 1867 | GNUNET_CADET_receive_done (op->channel); |
1865 | GNUNET_SERVICE_client_continue(cs->client); | 1868 | GNUNET_SERVICE_client_continue (cs->client); |
1866 | } | 1869 | } |
1867 | 1870 | ||
1868 | 1871 | ||
@@ -1872,20 +1875,20 @@ handle_client_accept(void *cls, const struct GNUNET_SET_AcceptMessage *msg) | |||
1872 | * @param cls closure, NULL | 1875 | * @param cls closure, NULL |
1873 | */ | 1876 | */ |
1874 | static void | 1877 | static void |
1875 | shutdown_task(void *cls) | 1878 | shutdown_task (void *cls) |
1876 | { | 1879 | { |
1877 | /* Delay actual shutdown to allow service to disconnect clients */ | 1880 | /* Delay actual shutdown to allow service to disconnect clients */ |
1878 | in_shutdown = GNUNET_YES; | 1881 | in_shutdown = GNUNET_YES; |
1879 | if (0 == num_clients) | 1882 | if (0 == num_clients) |
1883 | { | ||
1884 | if (NULL != cadet) | ||
1880 | { | 1885 | { |
1881 | if (NULL != cadet) | 1886 | GNUNET_CADET_disconnect (cadet); |
1882 | { | 1887 | cadet = NULL; |
1883 | GNUNET_CADET_disconnect(cadet); | ||
1884 | cadet = NULL; | ||
1885 | } | ||
1886 | } | 1888 | } |
1887 | GNUNET_STATISTICS_destroy(_GSS_statistics, GNUNET_YES); | 1889 | } |
1888 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "handled shutdown request\n"); | 1890 | GNUNET_STATISTICS_destroy (_GSS_statistics, GNUNET_YES); |
1891 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "handled shutdown request\n"); | ||
1889 | } | 1892 | } |
1890 | 1893 | ||
1891 | 1894 | ||
@@ -1898,85 +1901,85 @@ shutdown_task(void *cls) | |||
1898 | * @param service the initialized service | 1901 | * @param service the initialized service |
1899 | */ | 1902 | */ |
1900 | static void | 1903 | static void |
1901 | run(void *cls, | 1904 | run (void *cls, |
1902 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 1905 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
1903 | struct GNUNET_SERVICE_Handle *service) | 1906 | struct GNUNET_SERVICE_Handle *service) |
1904 | { | 1907 | { |
1905 | /* FIXME: need to modify SERVICE (!) API to allow | 1908 | /* FIXME: need to modify SERVICE (!) API to allow |
1906 | us to run a shutdown task *after* clients were | 1909 | us to run a shutdown task *after* clients were |
1907 | forcefully disconnected! */ | 1910 | forcefully disconnected! */ |
1908 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); | 1911 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); |
1909 | _GSS_statistics = GNUNET_STATISTICS_create("set", cfg); | 1912 | _GSS_statistics = GNUNET_STATISTICS_create ("set", cfg); |
1910 | cadet = GNUNET_CADET_connect(cfg); | 1913 | cadet = GNUNET_CADET_connect (cfg); |
1911 | if (NULL == cadet) | 1914 | if (NULL == cadet) |
1912 | { | 1915 | { |
1913 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 1916 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1914 | _("Could not connect to CADET service\n")); | 1917 | _ ("Could not connect to CADET service\n")); |
1915 | GNUNET_SCHEDULER_shutdown(); | 1918 | GNUNET_SCHEDULER_shutdown (); |
1916 | return; | 1919 | return; |
1917 | } | 1920 | } |
1918 | } | 1921 | } |
1919 | 1922 | ||
1920 | 1923 | ||
1921 | /** | 1924 | /** |
1922 | * Define "main" method using service macro. | 1925 | * Define "main" method using service macro. |
1923 | */ | 1926 | */ |
1924 | GNUNET_SERVICE_MAIN( | 1927 | GNUNET_SERVICE_MAIN ( |
1925 | "set", | 1928 | "set", |
1926 | GNUNET_SERVICE_OPTION_NONE, | 1929 | GNUNET_SERVICE_OPTION_NONE, |
1927 | &run, | 1930 | &run, |
1928 | &client_connect_cb, | 1931 | &client_connect_cb, |
1929 | &client_disconnect_cb, | 1932 | &client_disconnect_cb, |
1930 | NULL, | 1933 | NULL, |
1931 | GNUNET_MQ_hd_fixed_size(client_accept, | 1934 | GNUNET_MQ_hd_fixed_size (client_accept, |
1932 | GNUNET_MESSAGE_TYPE_SET_ACCEPT, | 1935 | GNUNET_MESSAGE_TYPE_SET_ACCEPT, |
1933 | struct GNUNET_SET_AcceptMessage, | 1936 | struct GNUNET_SET_AcceptMessage, |
1934 | NULL), | 1937 | NULL), |
1935 | GNUNET_MQ_hd_fixed_size(client_iter_ack, | 1938 | GNUNET_MQ_hd_fixed_size (client_iter_ack, |
1936 | GNUNET_MESSAGE_TYPE_SET_ITER_ACK, | 1939 | GNUNET_MESSAGE_TYPE_SET_ITER_ACK, |
1937 | struct GNUNET_SET_IterAckMessage, | 1940 | struct GNUNET_SET_IterAckMessage, |
1938 | NULL), | 1941 | NULL), |
1939 | GNUNET_MQ_hd_var_size(client_mutation, | 1942 | GNUNET_MQ_hd_var_size (client_mutation, |
1940 | GNUNET_MESSAGE_TYPE_SET_ADD, | 1943 | GNUNET_MESSAGE_TYPE_SET_ADD, |
1941 | struct GNUNET_SET_ElementMessage, | 1944 | struct GNUNET_SET_ElementMessage, |
1942 | NULL), | 1945 | NULL), |
1943 | GNUNET_MQ_hd_fixed_size(client_create_set, | 1946 | GNUNET_MQ_hd_fixed_size (client_create_set, |
1944 | GNUNET_MESSAGE_TYPE_SET_CREATE, | 1947 | GNUNET_MESSAGE_TYPE_SET_CREATE, |
1945 | struct GNUNET_SET_CreateMessage, | 1948 | struct GNUNET_SET_CreateMessage, |
1946 | NULL), | 1949 | NULL), |
1947 | GNUNET_MQ_hd_fixed_size(client_iterate, | 1950 | GNUNET_MQ_hd_fixed_size (client_iterate, |
1948 | GNUNET_MESSAGE_TYPE_SET_ITER_REQUEST, | 1951 | GNUNET_MESSAGE_TYPE_SET_ITER_REQUEST, |
1949 | struct GNUNET_MessageHeader, | 1952 | struct GNUNET_MessageHeader, |
1950 | NULL), | 1953 | NULL), |
1951 | GNUNET_MQ_hd_var_size(client_evaluate, | 1954 | GNUNET_MQ_hd_var_size (client_evaluate, |
1952 | GNUNET_MESSAGE_TYPE_SET_EVALUATE, | 1955 | GNUNET_MESSAGE_TYPE_SET_EVALUATE, |
1953 | struct GNUNET_SET_EvaluateMessage, | 1956 | struct GNUNET_SET_EvaluateMessage, |
1954 | NULL), | 1957 | NULL), |
1955 | GNUNET_MQ_hd_fixed_size(client_listen, | 1958 | GNUNET_MQ_hd_fixed_size (client_listen, |
1956 | GNUNET_MESSAGE_TYPE_SET_LISTEN, | 1959 | GNUNET_MESSAGE_TYPE_SET_LISTEN, |
1957 | struct GNUNET_SET_ListenMessage, | 1960 | struct GNUNET_SET_ListenMessage, |
1958 | NULL), | 1961 | NULL), |
1959 | GNUNET_MQ_hd_fixed_size(client_reject, | 1962 | GNUNET_MQ_hd_fixed_size (client_reject, |
1960 | GNUNET_MESSAGE_TYPE_SET_REJECT, | 1963 | GNUNET_MESSAGE_TYPE_SET_REJECT, |
1961 | struct GNUNET_SET_RejectMessage, | 1964 | struct GNUNET_SET_RejectMessage, |
1962 | NULL), | 1965 | NULL), |
1963 | GNUNET_MQ_hd_var_size(client_mutation, | 1966 | GNUNET_MQ_hd_var_size (client_mutation, |
1964 | GNUNET_MESSAGE_TYPE_SET_REMOVE, | 1967 | GNUNET_MESSAGE_TYPE_SET_REMOVE, |
1965 | struct GNUNET_SET_ElementMessage, | 1968 | struct GNUNET_SET_ElementMessage, |
1966 | NULL), | 1969 | NULL), |
1967 | GNUNET_MQ_hd_fixed_size(client_cancel, | 1970 | GNUNET_MQ_hd_fixed_size (client_cancel, |
1968 | GNUNET_MESSAGE_TYPE_SET_CANCEL, | 1971 | GNUNET_MESSAGE_TYPE_SET_CANCEL, |
1969 | struct GNUNET_SET_CancelMessage, | 1972 | struct GNUNET_SET_CancelMessage, |
1970 | NULL), | 1973 | NULL), |
1971 | GNUNET_MQ_hd_fixed_size(client_copy_lazy_prepare, | 1974 | GNUNET_MQ_hd_fixed_size (client_copy_lazy_prepare, |
1972 | GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_PREPARE, | 1975 | GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_PREPARE, |
1973 | struct GNUNET_MessageHeader, | 1976 | struct GNUNET_MessageHeader, |
1974 | NULL), | 1977 | NULL), |
1975 | GNUNET_MQ_hd_fixed_size(client_copy_lazy_connect, | 1978 | GNUNET_MQ_hd_fixed_size (client_copy_lazy_connect, |
1976 | GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT, | 1979 | GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT, |
1977 | struct GNUNET_SET_CopyLazyConnectMessage, | 1980 | struct GNUNET_SET_CopyLazyConnectMessage, |
1978 | NULL), | 1981 | NULL), |
1979 | GNUNET_MQ_handler_end()); | 1982 | GNUNET_MQ_handler_end ()); |
1980 | 1983 | ||
1981 | 1984 | ||
1982 | /* end of gnunet-service-set.c */ | 1985 | /* end of gnunet-service-set.c */ |
diff --git a/src/set/gnunet-service-set.h b/src/set/gnunet-service-set.h index 2234a5c72..402281da4 100644 --- a/src/set/gnunet-service-set.h +++ b/src/set/gnunet-service-set.h | |||
@@ -159,7 +159,8 @@ typedef void | |||
159 | * Dispatch table for a specific set operation. Every set operation | 159 | * Dispatch table for a specific set operation. Every set operation |
160 | * has to implement the callback in this struct. | 160 | * has to implement the callback in this struct. |
161 | */ | 161 | */ |
162 | struct SetVT { | 162 | struct SetVT |
163 | { | ||
163 | /** | 164 | /** |
164 | * Callback for the set creation. | 165 | * Callback for the set creation. |
165 | */ | 166 | */ |
@@ -211,7 +212,8 @@ struct SetVT { | |||
211 | * MutationEvent gives information about changes | 212 | * MutationEvent gives information about changes |
212 | * to an element (removal / addition) in a set content. | 213 | * to an element (removal / addition) in a set content. |
213 | */ | 214 | */ |
214 | struct MutationEvent { | 215 | struct MutationEvent |
216 | { | ||
215 | /** | 217 | /** |
216 | * First generation affected by this mutation event. | 218 | * First generation affected by this mutation event. |
217 | * | 219 | * |
@@ -234,7 +236,8 @@ struct MutationEvent { | |||
234 | * Element`, so that the remove and add operations are reasonably | 236 | * Element`, so that the remove and add operations are reasonably |
235 | * fast. | 237 | * fast. |
236 | */ | 238 | */ |
237 | struct ElementEntry { | 239 | struct ElementEntry |
240 | { | ||
238 | /** | 241 | /** |
239 | * The actual element. The data for the element | 242 | * The actual element. The data for the element |
240 | * should be allocated at the end of this struct. | 243 | * should be allocated at the end of this struct. |
@@ -281,7 +284,8 @@ struct Listener; | |||
281 | /** | 284 | /** |
282 | * State we keep per client. | 285 | * State we keep per client. |
283 | */ | 286 | */ |
284 | struct ClientState { | 287 | struct ClientState |
288 | { | ||
285 | /** | 289 | /** |
286 | * Set, if associated with the client, otherwise NULL. | 290 | * Set, if associated with the client, otherwise NULL. |
287 | */ | 291 | */ |
@@ -307,7 +311,8 @@ struct ClientState { | |||
307 | /** | 311 | /** |
308 | * Operation context used to execute a set operation. | 312 | * Operation context used to execute a set operation. |
309 | */ | 313 | */ |
310 | struct Operation { | 314 | struct Operation |
315 | { | ||
311 | /** | 316 | /** |
312 | * Kept in a DLL of the listener, if @e listener is non-NULL. | 317 | * Kept in a DLL of the listener, if @e listener is non-NULL. |
313 | */ | 318 | */ |
@@ -426,7 +431,8 @@ struct Operation { | |||
426 | * SetContent stores the actual set elements, which may be shared by | 431 | * SetContent stores the actual set elements, which may be shared by |
427 | * multiple generations derived from one set. | 432 | * multiple generations derived from one set. |
428 | */ | 433 | */ |
429 | struct SetContent { | 434 | struct SetContent |
435 | { | ||
430 | /** | 436 | /** |
431 | * Maps `struct GNUNET_HashCode *` to `struct ElementEntry *`. | 437 | * Maps `struct GNUNET_HashCode *` to `struct ElementEntry *`. |
432 | */ | 438 | */ |
@@ -463,7 +469,8 @@ struct SetContent { | |||
463 | }; | 469 | }; |
464 | 470 | ||
465 | 471 | ||
466 | struct GenerationRange { | 472 | struct GenerationRange |
473 | { | ||
467 | /** | 474 | /** |
468 | * First generation that is excluded. | 475 | * First generation that is excluded. |
469 | */ | 476 | */ |
@@ -479,7 +486,8 @@ struct GenerationRange { | |||
479 | /** | 486 | /** |
480 | * Information about a mutation to apply to a set. | 487 | * Information about a mutation to apply to a set. |
481 | */ | 488 | */ |
482 | struct PendingMutation { | 489 | struct PendingMutation |
490 | { | ||
483 | /** | 491 | /** |
484 | * Mutations are kept in a DLL. | 492 | * Mutations are kept in a DLL. |
485 | */ | 493 | */ |
@@ -507,7 +515,8 @@ struct PendingMutation { | |||
507 | /** | 515 | /** |
508 | * A set that supports a specific operation with other peers. | 516 | * A set that supports a specific operation with other peers. |
509 | */ | 517 | */ |
510 | struct Set { | 518 | struct Set |
519 | { | ||
511 | /** | 520 | /** |
512 | * Sets are held in a doubly linked list (in `sets_head` and `sets_tail`). | 521 | * Sets are held in a doubly linked list (in `sets_head` and `sets_tail`). |
513 | */ | 522 | */ |
@@ -611,8 +620,8 @@ extern struct GNUNET_STATISTICS_Handle *_GSS_statistics; | |||
611 | * @param gc #GNUNET_YES to perform garbage collection on the set | 620 | * @param gc #GNUNET_YES to perform garbage collection on the set |
612 | */ | 621 | */ |
613 | void | 622 | void |
614 | _GSS_operation_destroy(struct Operation *op, | 623 | _GSS_operation_destroy (struct Operation *op, |
615 | int gc); | 624 | int gc); |
616 | 625 | ||
617 | 626 | ||
618 | /** | 627 | /** |
@@ -621,7 +630,7 @@ _GSS_operation_destroy(struct Operation *op, | |||
621 | * logic in the various places where it is called. | 630 | * logic in the various places where it is called. |
622 | */ | 631 | */ |
623 | void | 632 | void |
624 | _GSS_operation_destroy2(struct Operation *op); | 633 | _GSS_operation_destroy2 (struct Operation *op); |
625 | 634 | ||
626 | 635 | ||
627 | /** | 636 | /** |
@@ -630,7 +639,7 @@ _GSS_operation_destroy2(struct Operation *op); | |||
630 | * @return the operation specific VTable | 639 | * @return the operation specific VTable |
631 | */ | 640 | */ |
632 | const struct SetVT * | 641 | const struct SetVT * |
633 | _GSS_union_vt(void); | 642 | _GSS_union_vt (void); |
634 | 643 | ||
635 | 644 | ||
636 | /** | 645 | /** |
@@ -639,7 +648,7 @@ _GSS_union_vt(void); | |||
639 | * @return the operation specific VTable | 648 | * @return the operation specific VTable |
640 | */ | 649 | */ |
641 | const struct SetVT * | 650 | const struct SetVT * |
642 | _GSS_intersection_vt(void); | 651 | _GSS_intersection_vt (void); |
643 | 652 | ||
644 | 653 | ||
645 | /** | 654 | /** |
@@ -650,8 +659,8 @@ _GSS_intersection_vt(void); | |||
650 | * @return #GNUNET_YES if the element is in the set, #GNUNET_NO if not | 659 | * @return #GNUNET_YES if the element is in the set, #GNUNET_NO if not |
651 | */ | 660 | */ |
652 | int | 661 | int |
653 | _GSS_is_element_of_operation(struct ElementEntry *ee, | 662 | _GSS_is_element_of_operation (struct ElementEntry *ee, |
654 | struct Operation *op); | 663 | struct Operation *op); |
655 | 664 | ||
656 | 665 | ||
657 | #endif | 666 | #endif |
diff --git a/src/set/gnunet-service-set_intersection.c b/src/set/gnunet-service-set_intersection.c index 964a26b91..1ae4dcdac 100644 --- a/src/set/gnunet-service-set_intersection.c +++ b/src/set/gnunet-service-set_intersection.c | |||
@@ -36,7 +36,8 @@ | |||
36 | /** | 36 | /** |
37 | * Current phase we are in for a intersection operation. | 37 | * Current phase we are in for a intersection operation. |
38 | */ | 38 | */ |
39 | enum IntersectionOperationPhase { | 39 | enum IntersectionOperationPhase |
40 | { | ||
40 | /** | 41 | /** |
41 | * We are just starting. | 42 | * We are just starting. |
42 | */ | 43 | */ |
@@ -78,7 +79,8 @@ enum IntersectionOperationPhase { | |||
78 | /** | 79 | /** |
79 | * State of an evaluate operation with another peer. | 80 | * State of an evaluate operation with another peer. |
80 | */ | 81 | */ |
81 | struct OperationState { | 82 | struct OperationState |
83 | { | ||
82 | /** | 84 | /** |
83 | * The bf we currently receive | 85 | * The bf we currently receive |
84 | */ | 86 | */ |
@@ -186,7 +188,8 @@ struct OperationState { | |||
186 | * Extra state required for efficient set intersection. | 188 | * Extra state required for efficient set intersection. |
187 | * Merely tracks the total number of elements. | 189 | * Merely tracks the total number of elements. |
188 | */ | 190 | */ |
189 | struct SetState { | 191 | struct SetState |
192 | { | ||
190 | /** | 193 | /** |
191 | * Number of currently valid elements in the set which have not been | 194 | * Number of currently valid elements in the set which have not been |
192 | * removed. | 195 | * removed. |
@@ -203,38 +206,38 @@ struct SetState { | |||
203 | * @param element element to send | 206 | * @param element element to send |
204 | */ | 207 | */ |
205 | static void | 208 | static void |
206 | send_client_removed_element(struct Operation *op, | 209 | send_client_removed_element (struct Operation *op, |
207 | struct GNUNET_SET_Element *element) | 210 | struct GNUNET_SET_Element *element) |
208 | { | 211 | { |
209 | struct GNUNET_MQ_Envelope *ev; | 212 | struct GNUNET_MQ_Envelope *ev; |
210 | struct GNUNET_SET_ResultMessage *rm; | 213 | struct GNUNET_SET_ResultMessage *rm; |
211 | 214 | ||
212 | if (GNUNET_SET_RESULT_REMOVED != op->result_mode) | 215 | if (GNUNET_SET_RESULT_REMOVED != op->result_mode) |
213 | return; /* Wrong mode for transmitting removed elements */ | 216 | return; /* Wrong mode for transmitting removed elements */ |
214 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 217 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
215 | "Sending removed element (size %u) to client\n", | 218 | "Sending removed element (size %u) to client\n", |
216 | element->size); | 219 | element->size); |
217 | GNUNET_STATISTICS_update(_GSS_statistics, | 220 | GNUNET_STATISTICS_update (_GSS_statistics, |
218 | "# Element removed messages sent", | 221 | "# Element removed messages sent", |
219 | 1, | 222 | 1, |
220 | GNUNET_NO); | 223 | GNUNET_NO); |
221 | GNUNET_assert(0 != op->client_request_id); | 224 | GNUNET_assert (0 != op->client_request_id); |
222 | ev = GNUNET_MQ_msg_extra(rm, | 225 | ev = GNUNET_MQ_msg_extra (rm, |
223 | element->size, | 226 | element->size, |
224 | GNUNET_MESSAGE_TYPE_SET_RESULT); | 227 | GNUNET_MESSAGE_TYPE_SET_RESULT); |
225 | if (NULL == ev) | 228 | if (NULL == ev) |
226 | { | 229 | { |
227 | GNUNET_break(0); | 230 | GNUNET_break (0); |
228 | return; | 231 | return; |
229 | } | 232 | } |
230 | rm->result_status = htons(GNUNET_SET_STATUS_OK); | 233 | rm->result_status = htons (GNUNET_SET_STATUS_OK); |
231 | rm->request_id = htonl(op->client_request_id); | 234 | rm->request_id = htonl (op->client_request_id); |
232 | rm->element_type = element->element_type; | 235 | rm->element_type = element->element_type; |
233 | GNUNET_memcpy(&rm[1], | 236 | GNUNET_memcpy (&rm[1], |
234 | element->data, | 237 | element->data, |
235 | element->size); | 238 | element->size); |
236 | GNUNET_MQ_send(op->set->cs->mq, | 239 | GNUNET_MQ_send (op->set->cs->mq, |
237 | ev); | 240 | ev); |
238 | } | 241 | } |
239 | 242 | ||
240 | 243 | ||
@@ -247,63 +250,63 @@ send_client_removed_element(struct Operation *op, | |||
247 | * @return #GNUNET_YES (we should continue to iterate) | 250 | * @return #GNUNET_YES (we should continue to iterate) |
248 | */ | 251 | */ |
249 | static int | 252 | static int |
250 | filtered_map_initialization(void *cls, | 253 | filtered_map_initialization (void *cls, |
251 | const struct GNUNET_HashCode *key, | 254 | const struct GNUNET_HashCode *key, |
252 | void *value) | 255 | void *value) |
253 | { | 256 | { |
254 | struct Operation *op = cls; | 257 | struct Operation *op = cls; |
255 | struct ElementEntry *ee = value; | 258 | struct ElementEntry *ee = value; |
256 | struct GNUNET_HashCode mutated_hash; | 259 | struct GNUNET_HashCode mutated_hash; |
257 | 260 | ||
258 | 261 | ||
259 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 262 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
260 | "FIMA called for %s:%u\n", | 263 | "FIMA called for %s:%u\n", |
261 | GNUNET_h2s(&ee->element_hash), | 264 | GNUNET_h2s (&ee->element_hash), |
262 | ee->element.size); | 265 | ee->element.size); |
263 | 266 | ||
264 | if (GNUNET_NO == _GSS_is_element_of_operation(ee, op)) | 267 | if (GNUNET_NO == _GSS_is_element_of_operation (ee, op)) |
265 | { | 268 | { |
266 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 269 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
267 | "Reduced initialization, not starting with %s:%u (wrong generation)\n", | 270 | "Reduced initialization, not starting with %s:%u (wrong generation)\n", |
268 | GNUNET_h2s(&ee->element_hash), | 271 | GNUNET_h2s (&ee->element_hash), |
269 | ee->element.size); | 272 | ee->element.size); |
270 | return GNUNET_YES; /* element not valid in our operation's generation */ | 273 | return GNUNET_YES; /* element not valid in our operation's generation */ |
271 | } | 274 | } |
272 | 275 | ||
273 | /* Test if element is in other peer's bloomfilter */ | 276 | /* Test if element is in other peer's bloomfilter */ |
274 | GNUNET_BLOCK_mingle_hash(&ee->element_hash, | 277 | GNUNET_BLOCK_mingle_hash (&ee->element_hash, |
275 | op->state->salt, | 278 | op->state->salt, |
276 | &mutated_hash); | 279 | &mutated_hash); |
277 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 280 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
278 | "Testing mingled hash %s with salt %u\n", | 281 | "Testing mingled hash %s with salt %u\n", |
279 | GNUNET_h2s(&mutated_hash), | 282 | GNUNET_h2s (&mutated_hash), |
280 | op->state->salt); | 283 | op->state->salt); |
281 | if (GNUNET_NO == | 284 | if (GNUNET_NO == |
282 | GNUNET_CONTAINER_bloomfilter_test(op->state->remote_bf, | 285 | GNUNET_CONTAINER_bloomfilter_test (op->state->remote_bf, |
283 | &mutated_hash)) | 286 | &mutated_hash)) |
284 | { | 287 | { |
285 | /* remove this element */ | 288 | /* remove this element */ |
286 | send_client_removed_element(op, | 289 | send_client_removed_element (op, |
287 | &ee->element); | 290 | &ee->element); |
288 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 291 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
289 | "Reduced initialization, not starting with %s:%u\n", | 292 | "Reduced initialization, not starting with %s:%u\n", |
290 | GNUNET_h2s(&ee->element_hash), | 293 | GNUNET_h2s (&ee->element_hash), |
291 | ee->element.size); | 294 | ee->element.size); |
292 | return GNUNET_YES; | 295 | return GNUNET_YES; |
293 | } | 296 | } |
294 | op->state->my_element_count++; | 297 | op->state->my_element_count++; |
295 | GNUNET_CRYPTO_hash_xor(&op->state->my_xor, | 298 | GNUNET_CRYPTO_hash_xor (&op->state->my_xor, |
296 | &ee->element_hash, | 299 | &ee->element_hash, |
297 | &op->state->my_xor); | 300 | &op->state->my_xor); |
298 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 301 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
299 | "Filtered initialization of my_elements, adding %s:%u\n", | 302 | "Filtered initialization of my_elements, adding %s:%u\n", |
300 | GNUNET_h2s(&ee->element_hash), | 303 | GNUNET_h2s (&ee->element_hash), |
301 | ee->element.size); | 304 | ee->element.size); |
302 | GNUNET_break(GNUNET_YES == | 305 | GNUNET_break (GNUNET_YES == |
303 | GNUNET_CONTAINER_multihashmap_put(op->state->my_elements, | 306 | GNUNET_CONTAINER_multihashmap_put (op->state->my_elements, |
304 | &ee->element_hash, | 307 | &ee->element_hash, |
305 | ee, | 308 | ee, |
306 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 309 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
307 | 310 | ||
308 | return GNUNET_YES; | 311 | return GNUNET_YES; |
309 | } | 312 | } |
@@ -319,48 +322,48 @@ filtered_map_initialization(void *cls, | |||
319 | * @return #GNUNET_YES (we should continue to iterate) | 322 | * @return #GNUNET_YES (we should continue to iterate) |
320 | */ | 323 | */ |
321 | static int | 324 | static int |
322 | iterator_bf_reduce(void *cls, | 325 | iterator_bf_reduce (void *cls, |
323 | const struct GNUNET_HashCode *key, | 326 | const struct GNUNET_HashCode *key, |
324 | void *value) | 327 | void *value) |
325 | { | 328 | { |
326 | struct Operation *op = cls; | 329 | struct Operation *op = cls; |
327 | struct ElementEntry *ee = value; | 330 | struct ElementEntry *ee = value; |
328 | struct GNUNET_HashCode mutated_hash; | 331 | struct GNUNET_HashCode mutated_hash; |
329 | 332 | ||
330 | GNUNET_BLOCK_mingle_hash(&ee->element_hash, | 333 | GNUNET_BLOCK_mingle_hash (&ee->element_hash, |
331 | op->state->salt, | 334 | op->state->salt, |
332 | &mutated_hash); | 335 | &mutated_hash); |
333 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 336 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
334 | "Testing mingled hash %s with salt %u\n", | 337 | "Testing mingled hash %s with salt %u\n", |
335 | GNUNET_h2s(&mutated_hash), | 338 | GNUNET_h2s (&mutated_hash), |
336 | op->state->salt); | 339 | op->state->salt); |
337 | if (GNUNET_NO == | 340 | if (GNUNET_NO == |
338 | GNUNET_CONTAINER_bloomfilter_test(op->state->remote_bf, | 341 | GNUNET_CONTAINER_bloomfilter_test (op->state->remote_bf, |
339 | &mutated_hash)) | 342 | &mutated_hash)) |
340 | { | 343 | { |
341 | GNUNET_break(0 < op->state->my_element_count); | 344 | GNUNET_break (0 < op->state->my_element_count); |
342 | op->state->my_element_count--; | 345 | op->state->my_element_count--; |
343 | GNUNET_CRYPTO_hash_xor(&op->state->my_xor, | 346 | GNUNET_CRYPTO_hash_xor (&op->state->my_xor, |
344 | &ee->element_hash, | 347 | &ee->element_hash, |
345 | &op->state->my_xor); | 348 | &op->state->my_xor); |
346 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 349 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
347 | "Bloom filter reduction of my_elements, removing %s:%u\n", | 350 | "Bloom filter reduction of my_elements, removing %s:%u\n", |
348 | GNUNET_h2s(&ee->element_hash), | 351 | GNUNET_h2s (&ee->element_hash), |
349 | ee->element.size); | 352 | ee->element.size); |
350 | GNUNET_assert(GNUNET_YES == | 353 | GNUNET_assert (GNUNET_YES == |
351 | GNUNET_CONTAINER_multihashmap_remove(op->state->my_elements, | 354 | GNUNET_CONTAINER_multihashmap_remove (op->state->my_elements, |
352 | &ee->element_hash, | 355 | &ee->element_hash, |
353 | ee)); | 356 | ee)); |
354 | send_client_removed_element(op, | 357 | send_client_removed_element (op, |
355 | &ee->element); | 358 | &ee->element); |
356 | } | 359 | } |
357 | else | 360 | else |
358 | { | 361 | { |
359 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 362 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
360 | "Bloom filter reduction of my_elements, keeping %s:%u\n", | 363 | "Bloom filter reduction of my_elements, keeping %s:%u\n", |
361 | GNUNET_h2s(&ee->element_hash), | 364 | GNUNET_h2s (&ee->element_hash), |
362 | ee->element.size); | 365 | ee->element.size); |
363 | } | 366 | } |
364 | return GNUNET_YES; | 367 | return GNUNET_YES; |
365 | } | 368 | } |
366 | 369 | ||
@@ -374,23 +377,23 @@ iterator_bf_reduce(void *cls, | |||
374 | * @return #GNUNET_YES (we should continue to iterate) | 377 | * @return #GNUNET_YES (we should continue to iterate) |
375 | */ | 378 | */ |
376 | static int | 379 | static int |
377 | iterator_bf_create(void *cls, | 380 | iterator_bf_create (void *cls, |
378 | const struct GNUNET_HashCode *key, | 381 | const struct GNUNET_HashCode *key, |
379 | void *value) | 382 | void *value) |
380 | { | 383 | { |
381 | struct Operation *op = cls; | 384 | struct Operation *op = cls; |
382 | struct ElementEntry *ee = value; | 385 | struct ElementEntry *ee = value; |
383 | struct GNUNET_HashCode mutated_hash; | 386 | struct GNUNET_HashCode mutated_hash; |
384 | 387 | ||
385 | GNUNET_BLOCK_mingle_hash(&ee->element_hash, | 388 | GNUNET_BLOCK_mingle_hash (&ee->element_hash, |
386 | op->state->salt, | 389 | op->state->salt, |
387 | &mutated_hash); | 390 | &mutated_hash); |
388 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 391 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
389 | "Initializing BF with hash %s with salt %u\n", | 392 | "Initializing BF with hash %s with salt %u\n", |
390 | GNUNET_h2s(&mutated_hash), | 393 | GNUNET_h2s (&mutated_hash), |
391 | op->state->salt); | 394 | op->state->salt); |
392 | GNUNET_CONTAINER_bloomfilter_add(op->state->local_bf, | 395 | GNUNET_CONTAINER_bloomfilter_add (op->state->local_bf, |
393 | &mutated_hash); | 396 | &mutated_hash); |
394 | return GNUNET_YES; | 397 | return GNUNET_YES; |
395 | } | 398 | } |
396 | 399 | ||
@@ -402,31 +405,31 @@ iterator_bf_create(void *cls, | |||
402 | * @param op the intersection operation to fail | 405 | * @param op the intersection operation to fail |
403 | */ | 406 | */ |
404 | static void | 407 | static void |
405 | fail_intersection_operation(struct Operation *op) | 408 | fail_intersection_operation (struct Operation *op) |
406 | { | 409 | { |
407 | struct GNUNET_MQ_Envelope *ev; | 410 | struct GNUNET_MQ_Envelope *ev; |
408 | struct GNUNET_SET_ResultMessage *msg; | 411 | struct GNUNET_SET_ResultMessage *msg; |
409 | 412 | ||
410 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, | 413 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
411 | "Intersection operation failed\n"); | 414 | "Intersection operation failed\n"); |
412 | GNUNET_STATISTICS_update(_GSS_statistics, | 415 | GNUNET_STATISTICS_update (_GSS_statistics, |
413 | "# Intersection operations failed", | 416 | "# Intersection operations failed", |
414 | 1, | 417 | 1, |
415 | GNUNET_NO); | 418 | GNUNET_NO); |
416 | if (NULL != op->state->my_elements) | 419 | if (NULL != op->state->my_elements) |
417 | { | 420 | { |
418 | GNUNET_CONTAINER_multihashmap_destroy(op->state->my_elements); | 421 | GNUNET_CONTAINER_multihashmap_destroy (op->state->my_elements); |
419 | op->state->my_elements = NULL; | 422 | op->state->my_elements = NULL; |
420 | } | 423 | } |
421 | ev = GNUNET_MQ_msg(msg, | 424 | ev = GNUNET_MQ_msg (msg, |
422 | GNUNET_MESSAGE_TYPE_SET_RESULT); | 425 | GNUNET_MESSAGE_TYPE_SET_RESULT); |
423 | msg->result_status = htons(GNUNET_SET_STATUS_FAILURE); | 426 | msg->result_status = htons (GNUNET_SET_STATUS_FAILURE); |
424 | msg->request_id = htonl(op->client_request_id); | 427 | msg->request_id = htonl (op->client_request_id); |
425 | msg->element_type = htons(0); | 428 | msg->element_type = htons (0); |
426 | GNUNET_MQ_send(op->set->cs->mq, | 429 | GNUNET_MQ_send (op->set->cs->mq, |
427 | ev); | 430 | ev); |
428 | _GSS_operation_destroy(op, | 431 | _GSS_operation_destroy (op, |
429 | GNUNET_YES); | 432 | GNUNET_YES); |
430 | } | 433 | } |
431 | 434 | ||
432 | 435 | ||
@@ -437,7 +440,7 @@ fail_intersection_operation(struct Operation *op) | |||
437 | * @param op intersection operation | 440 | * @param op intersection operation |
438 | */ | 441 | */ |
439 | static void | 442 | static void |
440 | send_bloomfilter(struct Operation *op) | 443 | send_bloomfilter (struct Operation *op) |
441 | { | 444 | { |
442 | struct GNUNET_MQ_Envelope *ev; | 445 | struct GNUNET_MQ_Envelope *ev; |
443 | struct BFMessage *msg; | 446 | struct BFMessage *msg; |
@@ -451,81 +454,83 @@ send_bloomfilter(struct Operation *op) | |||
451 | the number of bits per element, as the smaller set | 454 | the number of bits per element, as the smaller set |
452 | should use more bits to maximize its set reduction | 455 | should use more bits to maximize its set reduction |
453 | potential and minimize overall bandwidth consumption. */ | 456 | potential and minimize overall bandwidth consumption. */ |
454 | bf_elementbits = 2 + ceil(log2((double) | 457 | bf_elementbits = 2 + ceil (log2 ((double) |
455 | (op->remote_element_count / | 458 | (op->remote_element_count |
456 | (double)op->state->my_element_count))); | 459 | / (double) op->state->my_element_count))); |
457 | if (bf_elementbits < 1) | 460 | if (bf_elementbits < 1) |
458 | bf_elementbits = 1; /* make sure k is not 0 */ | 461 | bf_elementbits = 1; /* make sure k is not 0 */ |
459 | /* optimize BF-size to ~50% of bits set */ | 462 | /* optimize BF-size to ~50% of bits set */ |
460 | bf_size = ceil((double)(op->state->my_element_count | 463 | bf_size = ceil ((double) (op->state->my_element_count |
461 | * bf_elementbits / log(2))); | 464 | * bf_elementbits / log (2))); |
462 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 465 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
463 | "Sending Bloom filter (%u) of size %u bytes\n", | 466 | "Sending Bloom filter (%u) of size %u bytes\n", |
464 | (unsigned int)bf_elementbits, | 467 | (unsigned int) bf_elementbits, |
465 | (unsigned int)bf_size); | 468 | (unsigned int) bf_size); |
466 | op->state->local_bf = GNUNET_CONTAINER_bloomfilter_init(NULL, | 469 | op->state->local_bf = GNUNET_CONTAINER_bloomfilter_init (NULL, |
467 | bf_size, | 470 | bf_size, |
468 | bf_elementbits); | 471 | bf_elementbits); |
469 | op->state->salt = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE, | 472 | op->state->salt = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, |
470 | UINT32_MAX); | 473 | UINT32_MAX); |
471 | GNUNET_CONTAINER_multihashmap_iterate(op->state->my_elements, | 474 | GNUNET_CONTAINER_multihashmap_iterate (op->state->my_elements, |
472 | &iterator_bf_create, | 475 | &iterator_bf_create, |
473 | op); | 476 | op); |
474 | 477 | ||
475 | /* send our Bloom filter */ | 478 | /* send our Bloom filter */ |
476 | GNUNET_STATISTICS_update(_GSS_statistics, | 479 | GNUNET_STATISTICS_update (_GSS_statistics, |
477 | "# Intersection Bloom filters sent", | 480 | "# Intersection Bloom filters sent", |
478 | 1, | 481 | 1, |
479 | GNUNET_NO); | 482 | GNUNET_NO); |
480 | chunk_size = 60 * 1024 - sizeof(struct BFMessage); | 483 | chunk_size = 60 * 1024 - sizeof(struct BFMessage); |
481 | if (bf_size <= chunk_size) | 484 | if (bf_size <= chunk_size) |
482 | { | 485 | { |
483 | /* singlepart */ | 486 | /* singlepart */ |
484 | chunk_size = bf_size; | 487 | chunk_size = bf_size; |
485 | ev = GNUNET_MQ_msg_extra(msg, | 488 | ev = GNUNET_MQ_msg_extra (msg, |
486 | chunk_size, | 489 | chunk_size, |
487 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF); | 490 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF); |
488 | GNUNET_assert(GNUNET_SYSERR != | 491 | GNUNET_assert (GNUNET_SYSERR != |
489 | GNUNET_CONTAINER_bloomfilter_get_raw_data(op->state->local_bf, | 492 | GNUNET_CONTAINER_bloomfilter_get_raw_data ( |
490 | (char*)&msg[1], | 493 | op->state->local_bf, |
491 | bf_size)); | 494 | (char*) &msg[1], |
492 | msg->sender_element_count = htonl(op->state->my_element_count); | 495 | bf_size)); |
493 | msg->bloomfilter_total_length = htonl(bf_size); | 496 | msg->sender_element_count = htonl (op->state->my_element_count); |
494 | msg->bits_per_element = htonl(bf_elementbits); | 497 | msg->bloomfilter_total_length = htonl (bf_size); |
495 | msg->sender_mutator = htonl(op->state->salt); | 498 | msg->bits_per_element = htonl (bf_elementbits); |
496 | msg->element_xor_hash = op->state->my_xor; | 499 | msg->sender_mutator = htonl (op->state->salt); |
497 | GNUNET_MQ_send(op->mq, ev); | 500 | msg->element_xor_hash = op->state->my_xor; |
498 | } | 501 | GNUNET_MQ_send (op->mq, ev); |
502 | } | ||
499 | else | 503 | else |
504 | { | ||
505 | /* multipart */ | ||
506 | bf_data = GNUNET_malloc (bf_size); | ||
507 | GNUNET_assert (GNUNET_SYSERR != | ||
508 | GNUNET_CONTAINER_bloomfilter_get_raw_data ( | ||
509 | op->state->local_bf, | ||
510 | bf_data, | ||
511 | bf_size)); | ||
512 | offset = 0; | ||
513 | while (offset < bf_size) | ||
500 | { | 514 | { |
501 | /* multipart */ | 515 | if (bf_size - chunk_size < offset) |
502 | bf_data = GNUNET_malloc(bf_size); | 516 | chunk_size = bf_size - offset; |
503 | GNUNET_assert(GNUNET_SYSERR != | 517 | ev = GNUNET_MQ_msg_extra (msg, |
504 | GNUNET_CONTAINER_bloomfilter_get_raw_data(op->state->local_bf, | 518 | chunk_size, |
505 | bf_data, | 519 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF); |
506 | bf_size)); | 520 | GNUNET_memcpy (&msg[1], |
507 | offset = 0; | 521 | &bf_data[offset], |
508 | while (offset < bf_size) | 522 | chunk_size); |
509 | { | 523 | offset += chunk_size; |
510 | if (bf_size - chunk_size < offset) | 524 | msg->sender_element_count = htonl (op->state->my_element_count); |
511 | chunk_size = bf_size - offset; | 525 | msg->bloomfilter_total_length = htonl (bf_size); |
512 | ev = GNUNET_MQ_msg_extra(msg, | 526 | msg->bits_per_element = htonl (bf_elementbits); |
513 | chunk_size, | 527 | msg->sender_mutator = htonl (op->state->salt); |
514 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF); | 528 | msg->element_xor_hash = op->state->my_xor; |
515 | GNUNET_memcpy(&msg[1], | 529 | GNUNET_MQ_send (op->mq, ev); |
516 | &bf_data[offset], | ||
517 | chunk_size); | ||
518 | offset += chunk_size; | ||
519 | msg->sender_element_count = htonl(op->state->my_element_count); | ||
520 | msg->bloomfilter_total_length = htonl(bf_size); | ||
521 | msg->bits_per_element = htonl(bf_elementbits); | ||
522 | msg->sender_mutator = htonl(op->state->salt); | ||
523 | msg->element_xor_hash = op->state->my_xor; | ||
524 | GNUNET_MQ_send(op->mq, ev); | ||
525 | } | ||
526 | GNUNET_free(bf_data); | ||
527 | } | 530 | } |
528 | GNUNET_CONTAINER_bloomfilter_free(op->state->local_bf); | 531 | GNUNET_free (bf_data); |
532 | } | ||
533 | GNUNET_CONTAINER_bloomfilter_free (op->state->local_bf); | ||
529 | op->state->local_bf = NULL; | 534 | op->state->local_bf = NULL; |
530 | } | 535 | } |
531 | 536 | ||
@@ -537,27 +542,27 @@ send_bloomfilter(struct Operation *op) | |||
537 | * @param cls operation to destroy | 542 | * @param cls operation to destroy |
538 | */ | 543 | */ |
539 | static void | 544 | static void |
540 | send_client_done_and_destroy(void *cls) | 545 | send_client_done_and_destroy (void *cls) |
541 | { | 546 | { |
542 | struct Operation *op = cls; | 547 | struct Operation *op = cls; |
543 | struct GNUNET_MQ_Envelope *ev; | 548 | struct GNUNET_MQ_Envelope *ev; |
544 | struct GNUNET_SET_ResultMessage *rm; | 549 | struct GNUNET_SET_ResultMessage *rm; |
545 | 550 | ||
546 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 551 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
547 | "Intersection succeeded, sending DONE to local client\n"); | 552 | "Intersection succeeded, sending DONE to local client\n"); |
548 | GNUNET_STATISTICS_update(_GSS_statistics, | 553 | GNUNET_STATISTICS_update (_GSS_statistics, |
549 | "# Intersection operations succeeded", | 554 | "# Intersection operations succeeded", |
550 | 1, | 555 | 1, |
551 | GNUNET_NO); | 556 | GNUNET_NO); |
552 | ev = GNUNET_MQ_msg(rm, | 557 | ev = GNUNET_MQ_msg (rm, |
553 | GNUNET_MESSAGE_TYPE_SET_RESULT); | 558 | GNUNET_MESSAGE_TYPE_SET_RESULT); |
554 | rm->request_id = htonl(op->client_request_id); | 559 | rm->request_id = htonl (op->client_request_id); |
555 | rm->result_status = htons(GNUNET_SET_STATUS_DONE); | 560 | rm->result_status = htons (GNUNET_SET_STATUS_DONE); |
556 | rm->element_type = htons(0); | 561 | rm->element_type = htons (0); |
557 | GNUNET_MQ_send(op->set->cs->mq, | 562 | GNUNET_MQ_send (op->set->cs->mq, |
558 | ev); | 563 | ev); |
559 | _GSS_operation_destroy(op, | 564 | _GSS_operation_destroy (op, |
560 | GNUNET_YES); | 565 | GNUNET_YES); |
561 | } | 566 | } |
562 | 567 | ||
563 | 568 | ||
@@ -570,12 +575,12 @@ send_client_done_and_destroy(void *cls) | |||
570 | * @param cls the `struct Operation`. | 575 | * @param cls the `struct Operation`. |
571 | */ | 576 | */ |
572 | static void | 577 | static void |
573 | finished_local_operations(void *cls) | 578 | finished_local_operations (void *cls) |
574 | { | 579 | { |
575 | struct Operation *op = cls; | 580 | struct Operation *op = cls; |
576 | 581 | ||
577 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 582 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
578 | "DONE sent to other peer, now waiting for other end to close the channel\n"); | 583 | "DONE sent to other peer, now waiting for other end to close the channel\n"); |
579 | op->state->phase = PHASE_FINISHED; | 584 | op->state->phase = PHASE_FINISHED; |
580 | op->state->channel_death_expected = GNUNET_YES; | 585 | op->state->channel_death_expected = GNUNET_YES; |
581 | } | 586 | } |
@@ -589,22 +594,22 @@ finished_local_operations(void *cls) | |||
589 | * @param op operation to notify for. | 594 | * @param op operation to notify for. |
590 | */ | 595 | */ |
591 | static void | 596 | static void |
592 | send_p2p_done(struct Operation *op) | 597 | send_p2p_done (struct Operation *op) |
593 | { | 598 | { |
594 | struct GNUNET_MQ_Envelope *ev; | 599 | struct GNUNET_MQ_Envelope *ev; |
595 | struct IntersectionDoneMessage *idm; | 600 | struct IntersectionDoneMessage *idm; |
596 | 601 | ||
597 | GNUNET_assert(PHASE_MUST_SEND_DONE == op->state->phase); | 602 | GNUNET_assert (PHASE_MUST_SEND_DONE == op->state->phase); |
598 | GNUNET_assert(GNUNET_NO == op->state->channel_death_expected); | 603 | GNUNET_assert (GNUNET_NO == op->state->channel_death_expected); |
599 | ev = GNUNET_MQ_msg(idm, | 604 | ev = GNUNET_MQ_msg (idm, |
600 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE); | 605 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE); |
601 | idm->final_element_count = htonl(op->state->my_element_count); | 606 | idm->final_element_count = htonl (op->state->my_element_count); |
602 | idm->element_xor_hash = op->state->my_xor; | 607 | idm->element_xor_hash = op->state->my_xor; |
603 | GNUNET_MQ_notify_sent(ev, | 608 | GNUNET_MQ_notify_sent (ev, |
604 | &finished_local_operations, | 609 | &finished_local_operations, |
605 | op); | 610 | op); |
606 | GNUNET_MQ_send(op->mq, | 611 | GNUNET_MQ_send (op->mq, |
607 | ev); | 612 | ev); |
608 | } | 613 | } |
609 | 614 | ||
610 | 615 | ||
@@ -614,7 +619,7 @@ send_p2p_done(struct Operation *op) | |||
614 | * @param cls the `struct Operation *` | 619 | * @param cls the `struct Operation *` |
615 | */ | 620 | */ |
616 | static void | 621 | static void |
617 | send_remaining_elements(void *cls) | 622 | send_remaining_elements (void *cls) |
618 | { | 623 | { |
619 | struct Operation *op = cls; | 624 | struct Operation *op = cls; |
620 | const void *nxt; | 625 | const void *nxt; |
@@ -624,52 +629,54 @@ send_remaining_elements(void *cls) | |||
624 | const struct GNUNET_SET_Element *element; | 629 | const struct GNUNET_SET_Element *element; |
625 | int res; | 630 | int res; |
626 | 631 | ||
627 | res = GNUNET_CONTAINER_multihashmap_iterator_next(op->state->full_result_iter, | 632 | res = GNUNET_CONTAINER_multihashmap_iterator_next ( |
628 | NULL, | 633 | op->state->full_result_iter, |
629 | &nxt); | 634 | NULL, |
635 | &nxt); | ||
630 | if (GNUNET_NO == res) | 636 | if (GNUNET_NO == res) |
637 | { | ||
638 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
639 | "Sending done and destroy because iterator ran out\n"); | ||
640 | GNUNET_CONTAINER_multihashmap_iterator_destroy ( | ||
641 | op->state->full_result_iter); | ||
642 | op->state->full_result_iter = NULL; | ||
643 | if (PHASE_DONE_RECEIVED == op->state->phase) | ||
631 | { | 644 | { |
632 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 645 | op->state->phase = PHASE_FINISHED; |
633 | "Sending done and destroy because iterator ran out\n"); | 646 | send_client_done_and_destroy (op); |
634 | GNUNET_CONTAINER_multihashmap_iterator_destroy(op->state->full_result_iter); | 647 | } |
635 | op->state->full_result_iter = NULL; | 648 | else if (PHASE_MUST_SEND_DONE == op->state->phase) |
636 | if (PHASE_DONE_RECEIVED == op->state->phase) | 649 | { |
637 | { | 650 | send_p2p_done (op); |
638 | op->state->phase = PHASE_FINISHED; | ||
639 | send_client_done_and_destroy(op); | ||
640 | } | ||
641 | else if (PHASE_MUST_SEND_DONE == op->state->phase) | ||
642 | { | ||
643 | send_p2p_done(op); | ||
644 | } | ||
645 | else | ||
646 | { | ||
647 | GNUNET_assert(0); | ||
648 | } | ||
649 | return; | ||
650 | } | 651 | } |
652 | else | ||
653 | { | ||
654 | GNUNET_assert (0); | ||
655 | } | ||
656 | return; | ||
657 | } | ||
651 | ee = nxt; | 658 | ee = nxt; |
652 | element = &ee->element; | 659 | element = &ee->element; |
653 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 660 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
654 | "Sending element %s:%u to client (full set)\n", | 661 | "Sending element %s:%u to client (full set)\n", |
655 | GNUNET_h2s(&ee->element_hash), | 662 | GNUNET_h2s (&ee->element_hash), |
656 | element->size); | 663 | element->size); |
657 | GNUNET_assert(0 != op->client_request_id); | 664 | GNUNET_assert (0 != op->client_request_id); |
658 | ev = GNUNET_MQ_msg_extra(rm, | 665 | ev = GNUNET_MQ_msg_extra (rm, |
659 | element->size, | 666 | element->size, |
660 | GNUNET_MESSAGE_TYPE_SET_RESULT); | 667 | GNUNET_MESSAGE_TYPE_SET_RESULT); |
661 | GNUNET_assert(NULL != ev); | 668 | GNUNET_assert (NULL != ev); |
662 | rm->result_status = htons(GNUNET_SET_STATUS_OK); | 669 | rm->result_status = htons (GNUNET_SET_STATUS_OK); |
663 | rm->request_id = htonl(op->client_request_id); | 670 | rm->request_id = htonl (op->client_request_id); |
664 | rm->element_type = element->element_type; | 671 | rm->element_type = element->element_type; |
665 | GNUNET_memcpy(&rm[1], | 672 | GNUNET_memcpy (&rm[1], |
666 | element->data, | 673 | element->data, |
667 | element->size); | 674 | element->size); |
668 | GNUNET_MQ_notify_sent(ev, | 675 | GNUNET_MQ_notify_sent (ev, |
669 | &send_remaining_elements, | 676 | &send_remaining_elements, |
670 | op); | 677 | op); |
671 | GNUNET_MQ_send(op->set->cs->mq, | 678 | GNUNET_MQ_send (op->set->cs->mq, |
672 | ev); | 679 | ev); |
673 | } | 680 | } |
674 | 681 | ||
675 | 682 | ||
@@ -683,27 +690,27 @@ send_remaining_elements(void *cls) | |||
683 | * @return #GNUNET_YES (we should continue to iterate) | 690 | * @return #GNUNET_YES (we should continue to iterate) |
684 | */ | 691 | */ |
685 | static int | 692 | static int |
686 | initialize_map_unfiltered(void *cls, | 693 | initialize_map_unfiltered (void *cls, |
687 | const struct GNUNET_HashCode *key, | 694 | const struct GNUNET_HashCode *key, |
688 | void *value) | 695 | void *value) |
689 | { | 696 | { |
690 | struct ElementEntry *ee = value; | 697 | struct ElementEntry *ee = value; |
691 | struct Operation *op = cls; | 698 | struct Operation *op = cls; |
692 | 699 | ||
693 | if (GNUNET_NO == _GSS_is_element_of_operation(ee, op)) | 700 | if (GNUNET_NO == _GSS_is_element_of_operation (ee, op)) |
694 | return GNUNET_YES; /* element not live in operation's generation */ | 701 | return GNUNET_YES; /* element not live in operation's generation */ |
695 | GNUNET_CRYPTO_hash_xor(&op->state->my_xor, | 702 | GNUNET_CRYPTO_hash_xor (&op->state->my_xor, |
696 | &ee->element_hash, | 703 | &ee->element_hash, |
697 | &op->state->my_xor); | 704 | &op->state->my_xor); |
698 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 705 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
699 | "Initial full initialization of my_elements, adding %s:%u\n", | 706 | "Initial full initialization of my_elements, adding %s:%u\n", |
700 | GNUNET_h2s(&ee->element_hash), | 707 | GNUNET_h2s (&ee->element_hash), |
701 | ee->element.size); | 708 | ee->element.size); |
702 | GNUNET_break(GNUNET_YES == | 709 | GNUNET_break (GNUNET_YES == |
703 | GNUNET_CONTAINER_multihashmap_put(op->state->my_elements, | 710 | GNUNET_CONTAINER_multihashmap_put (op->state->my_elements, |
704 | &ee->element_hash, | 711 | &ee->element_hash, |
705 | ee, | 712 | ee, |
706 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 713 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
707 | return GNUNET_YES; | 714 | return GNUNET_YES; |
708 | } | 715 | } |
709 | 716 | ||
@@ -715,18 +722,18 @@ initialize_map_unfiltered(void *cls, | |||
715 | * @param op intersection operation | 722 | * @param op intersection operation |
716 | */ | 723 | */ |
717 | static void | 724 | static void |
718 | send_element_count(struct Operation *op) | 725 | send_element_count (struct Operation *op) |
719 | { | 726 | { |
720 | struct GNUNET_MQ_Envelope *ev; | 727 | struct GNUNET_MQ_Envelope *ev; |
721 | struct IntersectionElementInfoMessage *msg; | 728 | struct IntersectionElementInfoMessage *msg; |
722 | 729 | ||
723 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 730 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
724 | "Sending our element count (%u)\n", | 731 | "Sending our element count (%u)\n", |
725 | op->state->my_element_count); | 732 | op->state->my_element_count); |
726 | ev = GNUNET_MQ_msg(msg, | 733 | ev = GNUNET_MQ_msg (msg, |
727 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO); | 734 | GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO); |
728 | msg->sender_element_count = htonl(op->state->my_element_count); | 735 | msg->sender_element_count = htonl (op->state->my_element_count); |
729 | GNUNET_MQ_send(op->mq, ev); | 736 | GNUNET_MQ_send (op->mq, ev); |
730 | } | 737 | } |
731 | 738 | ||
732 | 739 | ||
@@ -737,13 +744,13 @@ send_element_count(struct Operation *op) | |||
737 | * @param op operation to start exchange for | 744 | * @param op operation to start exchange for |
738 | */ | 745 | */ |
739 | static void | 746 | static void |
740 | begin_bf_exchange(struct Operation *op) | 747 | begin_bf_exchange (struct Operation *op) |
741 | { | 748 | { |
742 | op->state->phase = PHASE_BF_EXCHANGE; | 749 | op->state->phase = PHASE_BF_EXCHANGE; |
743 | GNUNET_CONTAINER_multihashmap_iterate(op->set->content->elements, | 750 | GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements, |
744 | &initialize_map_unfiltered, | 751 | &initialize_map_unfiltered, |
745 | op); | 752 | op); |
746 | send_bloomfilter(op); | 753 | send_bloomfilter (op); |
747 | } | 754 | } |
748 | 755 | ||
749 | 756 | ||
@@ -755,35 +762,36 @@ begin_bf_exchange(struct Operation *op) | |||
755 | * @param mh the header of the message | 762 | * @param mh the header of the message |
756 | */ | 763 | */ |
757 | void | 764 | void |
758 | handle_intersection_p2p_element_info(void *cls, | 765 | handle_intersection_p2p_element_info (void *cls, |
759 | const struct IntersectionElementInfoMessage *msg) | 766 | const struct |
767 | IntersectionElementInfoMessage *msg) | ||
760 | { | 768 | { |
761 | struct Operation *op = cls; | 769 | struct Operation *op = cls; |
762 | 770 | ||
763 | if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation) | 771 | if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation) |
764 | { | 772 | { |
765 | GNUNET_break_op(0); | 773 | GNUNET_break_op (0); |
766 | fail_intersection_operation(op); | 774 | fail_intersection_operation (op); |
767 | return; | 775 | return; |
768 | } | 776 | } |
769 | op->remote_element_count = ntohl(msg->sender_element_count); | 777 | op->remote_element_count = ntohl (msg->sender_element_count); |
770 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 778 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
771 | "Received remote element count (%u), I have %u\n", | 779 | "Received remote element count (%u), I have %u\n", |
772 | op->remote_element_count, | 780 | op->remote_element_count, |
773 | op->state->my_element_count); | 781 | op->state->my_element_count); |
774 | if (((PHASE_INITIAL != op->state->phase) && | 782 | if (((PHASE_INITIAL != op->state->phase) && |
775 | (PHASE_COUNT_SENT != op->state->phase)) || | 783 | (PHASE_COUNT_SENT != op->state->phase)) || |
776 | (op->state->my_element_count > op->remote_element_count) || | 784 | (op->state->my_element_count > op->remote_element_count) || |
777 | (0 == op->state->my_element_count) || | 785 | (0 == op->state->my_element_count) || |
778 | (0 == op->remote_element_count)) | 786 | (0 == op->remote_element_count)) |
779 | { | 787 | { |
780 | GNUNET_break_op(0); | 788 | GNUNET_break_op (0); |
781 | fail_intersection_operation(op); | 789 | fail_intersection_operation (op); |
782 | return; | 790 | return; |
783 | } | 791 | } |
784 | GNUNET_break(NULL == op->state->remote_bf); | 792 | GNUNET_break (NULL == op->state->remote_bf); |
785 | begin_bf_exchange(op); | 793 | begin_bf_exchange (op); |
786 | GNUNET_CADET_receive_done(op->channel); | 794 | GNUNET_CADET_receive_done (op->channel); |
787 | } | 795 | } |
788 | 796 | ||
789 | 797 | ||
@@ -793,81 +801,82 @@ handle_intersection_p2p_element_info(void *cls, | |||
793 | * @param op the intersection operation | 801 | * @param op the intersection operation |
794 | */ | 802 | */ |
795 | static void | 803 | static void |
796 | process_bf(struct Operation *op) | 804 | process_bf (struct Operation *op) |
797 | { | 805 | { |
798 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 806 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
799 | "Received BF in phase %u, foreign count is %u, my element count is %u/%u\n", | 807 | "Received BF in phase %u, foreign count is %u, my element count is %u/%u\n", |
800 | op->state->phase, | 808 | op->state->phase, |
801 | op->remote_element_count, | 809 | op->remote_element_count, |
802 | op->state->my_element_count, | 810 | op->state->my_element_count, |
803 | GNUNET_CONTAINER_multihashmap_size(op->set->content->elements)); | 811 | GNUNET_CONTAINER_multihashmap_size (op->set->content->elements)); |
804 | switch (op->state->phase) | 812 | switch (op->state->phase) |
805 | { | 813 | { |
806 | case PHASE_INITIAL: | 814 | case PHASE_INITIAL: |
807 | GNUNET_break_op(0); | 815 | GNUNET_break_op (0); |
808 | fail_intersection_operation(op); | 816 | fail_intersection_operation (op); |
809 | return; | 817 | return; |
810 | 818 | ||
811 | case PHASE_COUNT_SENT: | 819 | case PHASE_COUNT_SENT: |
812 | /* This is the first BF being sent, build our initial map with | 820 | /* This is the first BF being sent, build our initial map with |
813 | filtering in place */ | 821 | filtering in place */ |
814 | op->state->my_element_count = 0; | 822 | op->state->my_element_count = 0; |
815 | GNUNET_CONTAINER_multihashmap_iterate(op->set->content->elements, | 823 | GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements, |
816 | &filtered_map_initialization, | 824 | &filtered_map_initialization, |
817 | op); | 825 | op); |
818 | break; | 826 | break; |
819 | 827 | ||
820 | case PHASE_BF_EXCHANGE: | 828 | case PHASE_BF_EXCHANGE: |
821 | /* Update our set by reduction */ | 829 | /* Update our set by reduction */ |
822 | GNUNET_CONTAINER_multihashmap_iterate(op->state->my_elements, | 830 | GNUNET_CONTAINER_multihashmap_iterate (op->state->my_elements, |
823 | &iterator_bf_reduce, | 831 | &iterator_bf_reduce, |
824 | op); | 832 | op); |
825 | break; | 833 | break; |
826 | 834 | ||
827 | case PHASE_MUST_SEND_DONE: | 835 | case PHASE_MUST_SEND_DONE: |
828 | GNUNET_break_op(0); | 836 | GNUNET_break_op (0); |
829 | fail_intersection_operation(op); | 837 | fail_intersection_operation (op); |
830 | return; | 838 | return; |
831 | 839 | ||
832 | case PHASE_DONE_RECEIVED: | 840 | case PHASE_DONE_RECEIVED: |
833 | GNUNET_break_op(0); | 841 | GNUNET_break_op (0); |
834 | fail_intersection_operation(op); | 842 | fail_intersection_operation (op); |
835 | return; | 843 | return; |
836 | 844 | ||
837 | case PHASE_FINISHED: | 845 | case PHASE_FINISHED: |
838 | GNUNET_break_op(0); | 846 | GNUNET_break_op (0); |
839 | fail_intersection_operation(op); | 847 | fail_intersection_operation (op); |
840 | return; | 848 | return; |
841 | } | 849 | } |
842 | GNUNET_CONTAINER_bloomfilter_free(op->state->remote_bf); | 850 | GNUNET_CONTAINER_bloomfilter_free (op->state->remote_bf); |
843 | op->state->remote_bf = NULL; | 851 | op->state->remote_bf = NULL; |
844 | 852 | ||
845 | if ((0 == op->state->my_element_count) || /* fully disjoint */ | 853 | if ((0 == op->state->my_element_count) || /* fully disjoint */ |
846 | ((op->state->my_element_count == op->remote_element_count) && | 854 | ((op->state->my_element_count == op->remote_element_count) && |
847 | (0 == GNUNET_memcmp(&op->state->my_xor, | 855 | (0 == GNUNET_memcmp (&op->state->my_xor, |
848 | &op->state->other_xor)))) | 856 | &op->state->other_xor)))) |
857 | { | ||
858 | /* we are done */ | ||
859 | op->state->phase = PHASE_MUST_SEND_DONE; | ||
860 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
861 | "Intersection succeeded, sending DONE to other peer\n"); | ||
862 | GNUNET_CONTAINER_bloomfilter_free (op->state->local_bf); | ||
863 | op->state->local_bf = NULL; | ||
864 | if (GNUNET_SET_RESULT_FULL == op->result_mode) | ||
849 | { | 865 | { |
850 | /* we are done */ | 866 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
851 | op->state->phase = PHASE_MUST_SEND_DONE; | 867 | "Sending full result set (%u elements)\n", |
852 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 868 | GNUNET_CONTAINER_multihashmap_size (op->state->my_elements)); |
853 | "Intersection succeeded, sending DONE to other peer\n"); | 869 | op->state->full_result_iter |
854 | GNUNET_CONTAINER_bloomfilter_free(op->state->local_bf); | 870 | = GNUNET_CONTAINER_multihashmap_iterator_create ( |
855 | op->state->local_bf = NULL; | 871 | op->state->my_elements); |
856 | if (GNUNET_SET_RESULT_FULL == op->result_mode) | 872 | send_remaining_elements (op); |
857 | { | ||
858 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
859 | "Sending full result set (%u elements)\n", | ||
860 | GNUNET_CONTAINER_multihashmap_size(op->state->my_elements)); | ||
861 | op->state->full_result_iter | ||
862 | = GNUNET_CONTAINER_multihashmap_iterator_create(op->state->my_elements); | ||
863 | send_remaining_elements(op); | ||
864 | return; | ||
865 | } | ||
866 | send_p2p_done(op); | ||
867 | return; | 873 | return; |
868 | } | 874 | } |
875 | send_p2p_done (op); | ||
876 | return; | ||
877 | } | ||
869 | op->state->phase = PHASE_BF_EXCHANGE; | 878 | op->state->phase = PHASE_BF_EXCHANGE; |
870 | send_bloomfilter(op); | 879 | send_bloomfilter (op); |
871 | } | 880 | } |
872 | 881 | ||
873 | 882 | ||
@@ -879,16 +888,16 @@ process_bf(struct Operation *op) | |||
879 | * @return #GNUNET_OK if @a msg is well-formed | 888 | * @return #GNUNET_OK if @a msg is well-formed |
880 | */ | 889 | */ |
881 | int | 890 | int |
882 | check_intersection_p2p_bf(void *cls, | 891 | check_intersection_p2p_bf (void *cls, |
883 | const struct BFMessage *msg) | 892 | const struct BFMessage *msg) |
884 | { | 893 | { |
885 | struct Operation *op = cls; | 894 | struct Operation *op = cls; |
886 | 895 | ||
887 | if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation) | 896 | if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation) |
888 | { | 897 | { |
889 | GNUNET_break_op(0); | 898 | GNUNET_break_op (0); |
890 | return GNUNET_SYSERR; | 899 | return GNUNET_SYSERR; |
891 | } | 900 | } |
892 | return GNUNET_OK; | 901 | return GNUNET_OK; |
893 | } | 902 | } |
894 | 903 | ||
@@ -900,8 +909,8 @@ check_intersection_p2p_bf(void *cls, | |||
900 | * @param msg the header of the message | 909 | * @param msg the header of the message |
901 | */ | 910 | */ |
902 | void | 911 | void |
903 | handle_intersection_p2p_bf(void *cls, | 912 | handle_intersection_p2p_bf (void *cls, |
904 | const struct BFMessage *msg) | 913 | const struct BFMessage *msg) |
905 | { | 914 | { |
906 | struct Operation *op = cls; | 915 | struct Operation *op = cls; |
907 | uint32_t bf_size; | 916 | uint32_t bf_size; |
@@ -909,85 +918,85 @@ handle_intersection_p2p_bf(void *cls, | |||
909 | uint32_t bf_bits_per_element; | 918 | uint32_t bf_bits_per_element; |
910 | 919 | ||
911 | switch (op->state->phase) | 920 | switch (op->state->phase) |
921 | { | ||
922 | case PHASE_INITIAL: | ||
923 | GNUNET_break_op (0); | ||
924 | fail_intersection_operation (op); | ||
925 | return; | ||
926 | |||
927 | case PHASE_COUNT_SENT: | ||
928 | case PHASE_BF_EXCHANGE: | ||
929 | bf_size = ntohl (msg->bloomfilter_total_length); | ||
930 | bf_bits_per_element = ntohl (msg->bits_per_element); | ||
931 | chunk_size = htons (msg->header.size) - sizeof(struct BFMessage); | ||
932 | op->state->other_xor = msg->element_xor_hash; | ||
933 | if (bf_size == chunk_size) | ||
912 | { | 934 | { |
913 | case PHASE_INITIAL: | 935 | if (NULL != op->state->bf_data) |
914 | GNUNET_break_op(0); | 936 | { |
915 | fail_intersection_operation(op); | 937 | GNUNET_break_op (0); |
916 | return; | 938 | fail_intersection_operation (op); |
917 | 939 | return; | |
918 | case PHASE_COUNT_SENT: | 940 | } |
919 | case PHASE_BF_EXCHANGE: | 941 | /* single part, done here immediately */ |
920 | bf_size = ntohl(msg->bloomfilter_total_length); | 942 | op->state->remote_bf |
921 | bf_bits_per_element = ntohl(msg->bits_per_element); | 943 | = GNUNET_CONTAINER_bloomfilter_init ((const char*) &msg[1], |
922 | chunk_size = htons(msg->header.size) - sizeof(struct BFMessage); | 944 | bf_size, |
923 | op->state->other_xor = msg->element_xor_hash; | 945 | bf_bits_per_element); |
924 | if (bf_size == chunk_size) | 946 | op->state->salt = ntohl (msg->sender_mutator); |
925 | { | 947 | op->remote_element_count = ntohl (msg->sender_element_count); |
926 | if (NULL != op->state->bf_data) | 948 | process_bf (op); |
927 | { | ||
928 | GNUNET_break_op(0); | ||
929 | fail_intersection_operation(op); | ||
930 | return; | ||
931 | } | ||
932 | /* single part, done here immediately */ | ||
933 | op->state->remote_bf | ||
934 | = GNUNET_CONTAINER_bloomfilter_init((const char*)&msg[1], | ||
935 | bf_size, | ||
936 | bf_bits_per_element); | ||
937 | op->state->salt = ntohl(msg->sender_mutator); | ||
938 | op->remote_element_count = ntohl(msg->sender_element_count); | ||
939 | process_bf(op); | ||
940 | break; | ||
941 | } | ||
942 | /* multipart chunk */ | ||
943 | if (NULL == op->state->bf_data) | ||
944 | { | ||
945 | /* first chunk, initialize */ | ||
946 | op->state->bf_data = GNUNET_malloc(bf_size); | ||
947 | op->state->bf_data_size = bf_size; | ||
948 | op->state->bf_bits_per_element = bf_bits_per_element; | ||
949 | op->state->bf_data_offset = 0; | ||
950 | op->state->salt = ntohl(msg->sender_mutator); | ||
951 | op->remote_element_count = ntohl(msg->sender_element_count); | ||
952 | } | ||
953 | else | ||
954 | { | ||
955 | /* increment */ | ||
956 | if ((op->state->bf_data_size != bf_size) || | ||
957 | (op->state->bf_bits_per_element != bf_bits_per_element) || | ||
958 | (op->state->bf_data_offset + chunk_size > bf_size) || | ||
959 | (op->state->salt != ntohl(msg->sender_mutator)) || | ||
960 | (op->remote_element_count != ntohl(msg->sender_element_count))) | ||
961 | { | ||
962 | GNUNET_break_op(0); | ||
963 | fail_intersection_operation(op); | ||
964 | return; | ||
965 | } | ||
966 | } | ||
967 | GNUNET_memcpy(&op->state->bf_data[op->state->bf_data_offset], | ||
968 | (const char*)&msg[1], | ||
969 | chunk_size); | ||
970 | op->state->bf_data_offset += chunk_size; | ||
971 | if (op->state->bf_data_offset == bf_size) | ||
972 | { | ||
973 | /* last chunk, run! */ | ||
974 | op->state->remote_bf | ||
975 | = GNUNET_CONTAINER_bloomfilter_init(op->state->bf_data, | ||
976 | bf_size, | ||
977 | bf_bits_per_element); | ||
978 | GNUNET_free(op->state->bf_data); | ||
979 | op->state->bf_data = NULL; | ||
980 | op->state->bf_data_size = 0; | ||
981 | process_bf(op); | ||
982 | } | ||
983 | break; | 949 | break; |
984 | |||
985 | default: | ||
986 | GNUNET_break_op(0); | ||
987 | fail_intersection_operation(op); | ||
988 | return; | ||
989 | } | 950 | } |
990 | GNUNET_CADET_receive_done(op->channel); | 951 | /* multipart chunk */ |
952 | if (NULL == op->state->bf_data) | ||
953 | { | ||
954 | /* first chunk, initialize */ | ||
955 | op->state->bf_data = GNUNET_malloc (bf_size); | ||
956 | op->state->bf_data_size = bf_size; | ||
957 | op->state->bf_bits_per_element = bf_bits_per_element; | ||
958 | op->state->bf_data_offset = 0; | ||
959 | op->state->salt = ntohl (msg->sender_mutator); | ||
960 | op->remote_element_count = ntohl (msg->sender_element_count); | ||
961 | } | ||
962 | else | ||
963 | { | ||
964 | /* increment */ | ||
965 | if ((op->state->bf_data_size != bf_size) || | ||
966 | (op->state->bf_bits_per_element != bf_bits_per_element) || | ||
967 | (op->state->bf_data_offset + chunk_size > bf_size) || | ||
968 | (op->state->salt != ntohl (msg->sender_mutator)) || | ||
969 | (op->remote_element_count != ntohl (msg->sender_element_count))) | ||
970 | { | ||
971 | GNUNET_break_op (0); | ||
972 | fail_intersection_operation (op); | ||
973 | return; | ||
974 | } | ||
975 | } | ||
976 | GNUNET_memcpy (&op->state->bf_data[op->state->bf_data_offset], | ||
977 | (const char*) &msg[1], | ||
978 | chunk_size); | ||
979 | op->state->bf_data_offset += chunk_size; | ||
980 | if (op->state->bf_data_offset == bf_size) | ||
981 | { | ||
982 | /* last chunk, run! */ | ||
983 | op->state->remote_bf | ||
984 | = GNUNET_CONTAINER_bloomfilter_init (op->state->bf_data, | ||
985 | bf_size, | ||
986 | bf_bits_per_element); | ||
987 | GNUNET_free (op->state->bf_data); | ||
988 | op->state->bf_data = NULL; | ||
989 | op->state->bf_data_size = 0; | ||
990 | process_bf (op); | ||
991 | } | ||
992 | break; | ||
993 | |||
994 | default: | ||
995 | GNUNET_break_op (0); | ||
996 | fail_intersection_operation (op); | ||
997 | return; | ||
998 | } | ||
999 | GNUNET_CADET_receive_done (op->channel); | ||
991 | } | 1000 | } |
992 | 1001 | ||
993 | 1002 | ||
@@ -1000,28 +1009,28 @@ handle_intersection_p2p_bf(void *cls, | |||
1000 | * @return #GNUNET_YES (we should continue to iterate) | 1009 | * @return #GNUNET_YES (we should continue to iterate) |
1001 | */ | 1010 | */ |
1002 | static int | 1011 | static int |
1003 | filter_all(void *cls, | 1012 | filter_all (void *cls, |
1004 | const struct GNUNET_HashCode *key, | 1013 | const struct GNUNET_HashCode *key, |
1005 | void *value) | 1014 | void *value) |
1006 | { | 1015 | { |
1007 | struct Operation *op = cls; | 1016 | struct Operation *op = cls; |
1008 | struct ElementEntry *ee = value; | 1017 | struct ElementEntry *ee = value; |
1009 | 1018 | ||
1010 | GNUNET_break(0 < op->state->my_element_count); | 1019 | GNUNET_break (0 < op->state->my_element_count); |
1011 | op->state->my_element_count--; | 1020 | op->state->my_element_count--; |
1012 | GNUNET_CRYPTO_hash_xor(&op->state->my_xor, | 1021 | GNUNET_CRYPTO_hash_xor (&op->state->my_xor, |
1013 | &ee->element_hash, | 1022 | &ee->element_hash, |
1014 | &op->state->my_xor); | 1023 | &op->state->my_xor); |
1015 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1024 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1016 | "Final reduction of my_elements, removing %s:%u\n", | 1025 | "Final reduction of my_elements, removing %s:%u\n", |
1017 | GNUNET_h2s(&ee->element_hash), | 1026 | GNUNET_h2s (&ee->element_hash), |
1018 | ee->element.size); | 1027 | ee->element.size); |
1019 | GNUNET_assert(GNUNET_YES == | 1028 | GNUNET_assert (GNUNET_YES == |
1020 | GNUNET_CONTAINER_multihashmap_remove(op->state->my_elements, | 1029 | GNUNET_CONTAINER_multihashmap_remove (op->state->my_elements, |
1021 | &ee->element_hash, | 1030 | &ee->element_hash, |
1022 | ee)); | 1031 | ee)); |
1023 | send_client_removed_element(op, | 1032 | send_client_removed_element (op, |
1024 | &ee->element); | 1033 | &ee->element); |
1025 | return GNUNET_YES; | 1034 | return GNUNET_YES; |
1026 | } | 1035 | } |
1027 | 1036 | ||
@@ -1033,61 +1042,61 @@ filter_all(void *cls, | |||
1033 | * @param mh the message | 1042 | * @param mh the message |
1034 | */ | 1043 | */ |
1035 | void | 1044 | void |
1036 | handle_intersection_p2p_done(void *cls, | 1045 | handle_intersection_p2p_done (void *cls, |
1037 | const struct IntersectionDoneMessage *idm) | 1046 | const struct IntersectionDoneMessage *idm) |
1038 | { | 1047 | { |
1039 | struct Operation *op = cls; | 1048 | struct Operation *op = cls; |
1040 | 1049 | ||
1041 | if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation) | 1050 | if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation) |
1042 | { | 1051 | { |
1043 | GNUNET_break_op(0); | 1052 | GNUNET_break_op (0); |
1044 | fail_intersection_operation(op); | 1053 | fail_intersection_operation (op); |
1045 | return; | 1054 | return; |
1046 | } | 1055 | } |
1047 | if (PHASE_BF_EXCHANGE != op->state->phase) | 1056 | if (PHASE_BF_EXCHANGE != op->state->phase) |
1048 | { | 1057 | { |
1049 | /* wrong phase to conclude? FIXME: Or should we allow this | 1058 | /* wrong phase to conclude? FIXME: Or should we allow this |
1050 | if the other peer has _initially_ already an empty set? */ | 1059 | if the other peer has _initially_ already an empty set? */ |
1051 | GNUNET_break_op(0); | 1060 | GNUNET_break_op (0); |
1052 | fail_intersection_operation(op); | 1061 | fail_intersection_operation (op); |
1053 | return; | 1062 | return; |
1054 | } | 1063 | } |
1055 | if (0 == ntohl(idm->final_element_count)) | 1064 | if (0 == ntohl (idm->final_element_count)) |
1056 | { | 1065 | { |
1057 | /* other peer determined empty set is the intersection, | 1066 | /* other peer determined empty set is the intersection, |
1058 | remove all elements */ | 1067 | remove all elements */ |
1059 | GNUNET_CONTAINER_multihashmap_iterate(op->state->my_elements, | 1068 | GNUNET_CONTAINER_multihashmap_iterate (op->state->my_elements, |
1060 | &filter_all, | 1069 | &filter_all, |
1061 | op); | 1070 | op); |
1062 | } | 1071 | } |
1063 | if ((op->state->my_element_count != ntohl(idm->final_element_count)) || | 1072 | if ((op->state->my_element_count != ntohl (idm->final_element_count)) || |
1064 | (0 != GNUNET_memcmp(&op->state->my_xor, | 1073 | (0 != GNUNET_memcmp (&op->state->my_xor, |
1065 | &idm->element_xor_hash))) | 1074 | &idm->element_xor_hash))) |
1066 | { | 1075 | { |
1067 | /* Other peer thinks we are done, but we disagree on the result! */ | 1076 | /* Other peer thinks we are done, but we disagree on the result! */ |
1068 | GNUNET_break_op(0); | 1077 | GNUNET_break_op (0); |
1069 | fail_intersection_operation(op); | 1078 | fail_intersection_operation (op); |
1070 | return; | 1079 | return; |
1071 | } | 1080 | } |
1072 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1081 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1073 | "Got IntersectionDoneMessage, have %u elements in intersection\n", | 1082 | "Got IntersectionDoneMessage, have %u elements in intersection\n", |
1074 | op->state->my_element_count); | 1083 | op->state->my_element_count); |
1075 | op->state->phase = PHASE_DONE_RECEIVED; | 1084 | op->state->phase = PHASE_DONE_RECEIVED; |
1076 | GNUNET_CADET_receive_done(op->channel); | 1085 | GNUNET_CADET_receive_done (op->channel); |
1077 | 1086 | ||
1078 | GNUNET_assert(GNUNET_NO == op->state->client_done_sent); | 1087 | GNUNET_assert (GNUNET_NO == op->state->client_done_sent); |
1079 | if (GNUNET_SET_RESULT_FULL == op->result_mode) | 1088 | if (GNUNET_SET_RESULT_FULL == op->result_mode) |
1080 | { | 1089 | { |
1081 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1090 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1082 | "Sending full result set to client (%u elements)\n", | 1091 | "Sending full result set to client (%u elements)\n", |
1083 | GNUNET_CONTAINER_multihashmap_size(op->state->my_elements)); | 1092 | GNUNET_CONTAINER_multihashmap_size (op->state->my_elements)); |
1084 | op->state->full_result_iter | 1093 | op->state->full_result_iter |
1085 | = GNUNET_CONTAINER_multihashmap_iterator_create(op->state->my_elements); | 1094 | = GNUNET_CONTAINER_multihashmap_iterator_create (op->state->my_elements); |
1086 | send_remaining_elements(op); | 1095 | send_remaining_elements (op); |
1087 | return; | 1096 | return; |
1088 | } | 1097 | } |
1089 | op->state->phase = PHASE_FINISHED; | 1098 | op->state->phase = PHASE_FINISHED; |
1090 | send_client_done_and_destroy(op); | 1099 | send_client_done_and_destroy (op); |
1091 | } | 1100 | } |
1092 | 1101 | ||
1093 | 1102 | ||
@@ -1101,43 +1110,43 @@ handle_intersection_p2p_done(void *cls, | |||
1101 | * @return operation-specific state to keep in @a op | 1110 | * @return operation-specific state to keep in @a op |
1102 | */ | 1111 | */ |
1103 | static struct OperationState * | 1112 | static struct OperationState * |
1104 | intersection_evaluate(struct Operation *op, | 1113 | intersection_evaluate (struct Operation *op, |
1105 | const struct GNUNET_MessageHeader *opaque_context) | 1114 | const struct GNUNET_MessageHeader *opaque_context) |
1106 | { | 1115 | { |
1107 | struct OperationState *state; | 1116 | struct OperationState *state; |
1108 | struct GNUNET_MQ_Envelope *ev; | 1117 | struct GNUNET_MQ_Envelope *ev; |
1109 | struct OperationRequestMessage *msg; | 1118 | struct OperationRequestMessage *msg; |
1110 | 1119 | ||
1111 | ev = GNUNET_MQ_msg_nested_mh(msg, | 1120 | ev = GNUNET_MQ_msg_nested_mh (msg, |
1112 | GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, | 1121 | GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, |
1113 | opaque_context); | 1122 | opaque_context); |
1114 | if (NULL == ev) | 1123 | if (NULL == ev) |
1115 | { | 1124 | { |
1116 | /* the context message is too large!? */ | 1125 | /* the context message is too large!? */ |
1117 | GNUNET_break(0); | 1126 | GNUNET_break (0); |
1118 | return NULL; | 1127 | return NULL; |
1119 | } | 1128 | } |
1120 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1129 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1121 | "Initiating intersection operation evaluation\n"); | 1130 | "Initiating intersection operation evaluation\n"); |
1122 | state = GNUNET_new(struct OperationState); | 1131 | state = GNUNET_new (struct OperationState); |
1123 | /* we started the operation, thus we have to send the operation request */ | 1132 | /* we started the operation, thus we have to send the operation request */ |
1124 | state->phase = PHASE_INITIAL; | 1133 | state->phase = PHASE_INITIAL; |
1125 | state->my_element_count = op->set->state->current_set_element_count; | 1134 | state->my_element_count = op->set->state->current_set_element_count; |
1126 | state->my_elements | 1135 | state->my_elements |
1127 | = GNUNET_CONTAINER_multihashmap_create(state->my_element_count, | 1136 | = GNUNET_CONTAINER_multihashmap_create (state->my_element_count, |
1128 | GNUNET_YES); | 1137 | GNUNET_YES); |
1129 | 1138 | ||
1130 | msg->operation = htonl(GNUNET_SET_OPERATION_INTERSECTION); | 1139 | msg->operation = htonl (GNUNET_SET_OPERATION_INTERSECTION); |
1131 | msg->element_count = htonl(state->my_element_count); | 1140 | msg->element_count = htonl (state->my_element_count); |
1132 | GNUNET_MQ_send(op->mq, | 1141 | GNUNET_MQ_send (op->mq, |
1133 | ev); | 1142 | ev); |
1134 | state->phase = PHASE_COUNT_SENT; | 1143 | state->phase = PHASE_COUNT_SENT; |
1135 | if (NULL != opaque_context) | 1144 | if (NULL != opaque_context) |
1136 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1145 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1137 | "Sent op request with context message\n"); | 1146 | "Sent op request with context message\n"); |
1138 | else | 1147 | else |
1139 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1148 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1140 | "Sent op request without context message\n"); | 1149 | "Sent op request without context message\n"); |
1141 | return state; | 1150 | return state; |
1142 | } | 1151 | } |
1143 | 1152 | ||
@@ -1149,31 +1158,31 @@ intersection_evaluate(struct Operation *op, | |||
1149 | * @param op operation that will be accepted as an intersection operation | 1158 | * @param op operation that will be accepted as an intersection operation |
1150 | */ | 1159 | */ |
1151 | static struct OperationState * | 1160 | static struct OperationState * |
1152 | intersection_accept(struct Operation *op) | 1161 | intersection_accept (struct Operation *op) |
1153 | { | 1162 | { |
1154 | struct OperationState *state; | 1163 | struct OperationState *state; |
1155 | 1164 | ||
1156 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1165 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1157 | "Accepting set intersection operation\n"); | 1166 | "Accepting set intersection operation\n"); |
1158 | state = GNUNET_new(struct OperationState); | 1167 | state = GNUNET_new (struct OperationState); |
1159 | state->phase = PHASE_INITIAL; | 1168 | state->phase = PHASE_INITIAL; |
1160 | state->my_element_count | 1169 | state->my_element_count |
1161 | = op->set->state->current_set_element_count; | 1170 | = op->set->state->current_set_element_count; |
1162 | state->my_elements | 1171 | state->my_elements |
1163 | = GNUNET_CONTAINER_multihashmap_create(GNUNET_MIN(state->my_element_count, | 1172 | = GNUNET_CONTAINER_multihashmap_create (GNUNET_MIN (state->my_element_count, |
1164 | op->remote_element_count), | 1173 | op->remote_element_count), |
1165 | GNUNET_YES); | 1174 | GNUNET_YES); |
1166 | op->state = state; | 1175 | op->state = state; |
1167 | if (op->remote_element_count < state->my_element_count) | 1176 | if (op->remote_element_count < state->my_element_count) |
1168 | { | 1177 | { |
1169 | /* If the other peer (Alice) has fewer elements than us (Bob), | 1178 | /* If the other peer (Alice) has fewer elements than us (Bob), |
1170 | we just send the count as Alice should send the first BF */ | 1179 | we just send the count as Alice should send the first BF */ |
1171 | send_element_count(op); | 1180 | send_element_count (op); |
1172 | state->phase = PHASE_COUNT_SENT; | 1181 | state->phase = PHASE_COUNT_SENT; |
1173 | return state; | 1182 | return state; |
1174 | } | 1183 | } |
1175 | /* We have fewer elements, so we start with the BF */ | 1184 | /* We have fewer elements, so we start with the BF */ |
1176 | begin_bf_exchange(op); | 1185 | begin_bf_exchange (op); |
1177 | return state; | 1186 | return state; |
1178 | } | 1187 | } |
1179 | 1188 | ||
@@ -1185,34 +1194,35 @@ intersection_accept(struct Operation *op) | |||
1185 | * @param op intersection operation to destroy | 1194 | * @param op intersection operation to destroy |
1186 | */ | 1195 | */ |
1187 | static void | 1196 | static void |
1188 | intersection_op_cancel(struct Operation *op) | 1197 | intersection_op_cancel (struct Operation *op) |
1189 | { | 1198 | { |
1190 | /* check if the op was canceled twice */ | 1199 | /* check if the op was canceled twice */ |
1191 | GNUNET_assert(NULL != op->state); | 1200 | GNUNET_assert (NULL != op->state); |
1192 | if (NULL != op->state->remote_bf) | 1201 | if (NULL != op->state->remote_bf) |
1193 | { | 1202 | { |
1194 | GNUNET_CONTAINER_bloomfilter_free(op->state->remote_bf); | 1203 | GNUNET_CONTAINER_bloomfilter_free (op->state->remote_bf); |
1195 | op->state->remote_bf = NULL; | 1204 | op->state->remote_bf = NULL; |
1196 | } | 1205 | } |
1197 | if (NULL != op->state->local_bf) | 1206 | if (NULL != op->state->local_bf) |
1198 | { | 1207 | { |
1199 | GNUNET_CONTAINER_bloomfilter_free(op->state->local_bf); | 1208 | GNUNET_CONTAINER_bloomfilter_free (op->state->local_bf); |
1200 | op->state->local_bf = NULL; | 1209 | op->state->local_bf = NULL; |
1201 | } | 1210 | } |
1202 | if (NULL != op->state->my_elements) | 1211 | if (NULL != op->state->my_elements) |
1203 | { | 1212 | { |
1204 | GNUNET_CONTAINER_multihashmap_destroy(op->state->my_elements); | 1213 | GNUNET_CONTAINER_multihashmap_destroy (op->state->my_elements); |
1205 | op->state->my_elements = NULL; | 1214 | op->state->my_elements = NULL; |
1206 | } | 1215 | } |
1207 | if (NULL != op->state->full_result_iter) | 1216 | if (NULL != op->state->full_result_iter) |
1208 | { | 1217 | { |
1209 | GNUNET_CONTAINER_multihashmap_iterator_destroy(op->state->full_result_iter); | 1218 | GNUNET_CONTAINER_multihashmap_iterator_destroy ( |
1210 | op->state->full_result_iter = NULL; | 1219 | op->state->full_result_iter); |
1211 | } | 1220 | op->state->full_result_iter = NULL; |
1212 | GNUNET_free(op->state); | 1221 | } |
1222 | GNUNET_free (op->state); | ||
1213 | op->state = NULL; | 1223 | op->state = NULL; |
1214 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1224 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1215 | "Destroying intersection op state done\n"); | 1225 | "Destroying intersection op state done\n"); |
1216 | } | 1226 | } |
1217 | 1227 | ||
1218 | 1228 | ||
@@ -1222,13 +1232,13 @@ intersection_op_cancel(struct Operation *op) | |||
1222 | * @return the newly created set | 1232 | * @return the newly created set |
1223 | */ | 1233 | */ |
1224 | static struct SetState * | 1234 | static struct SetState * |
1225 | intersection_set_create() | 1235 | intersection_set_create () |
1226 | { | 1236 | { |
1227 | struct SetState *set_state; | 1237 | struct SetState *set_state; |
1228 | 1238 | ||
1229 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1239 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1230 | "Intersection set created\n"); | 1240 | "Intersection set created\n"); |
1231 | set_state = GNUNET_new(struct SetState); | 1241 | set_state = GNUNET_new (struct SetState); |
1232 | set_state->current_set_element_count = 0; | 1242 | set_state->current_set_element_count = 0; |
1233 | 1243 | ||
1234 | return set_state; | 1244 | return set_state; |
@@ -1242,8 +1252,8 @@ intersection_set_create() | |||
1242 | * @param ee the element to add to the set | 1252 | * @param ee the element to add to the set |
1243 | */ | 1253 | */ |
1244 | static void | 1254 | static void |
1245 | intersection_add(struct SetState *set_state, | 1255 | intersection_add (struct SetState *set_state, |
1246 | struct ElementEntry *ee) | 1256 | struct ElementEntry *ee) |
1247 | { | 1257 | { |
1248 | set_state->current_set_element_count++; | 1258 | set_state->current_set_element_count++; |
1249 | } | 1259 | } |
@@ -1255,9 +1265,9 @@ intersection_add(struct SetState *set_state, | |||
1255 | * @param set_state the set to destroy | 1265 | * @param set_state the set to destroy |
1256 | */ | 1266 | */ |
1257 | static void | 1267 | static void |
1258 | intersection_set_destroy(struct SetState *set_state) | 1268 | intersection_set_destroy (struct SetState *set_state) |
1259 | { | 1269 | { |
1260 | GNUNET_free(set_state); | 1270 | GNUNET_free (set_state); |
1261 | } | 1271 | } |
1262 | 1272 | ||
1263 | 1273 | ||
@@ -1268,10 +1278,10 @@ intersection_set_destroy(struct SetState *set_state) | |||
1268 | * @param element set element to remove | 1278 | * @param element set element to remove |
1269 | */ | 1279 | */ |
1270 | static void | 1280 | static void |
1271 | intersection_remove(struct SetState *set_state, | 1281 | intersection_remove (struct SetState *set_state, |
1272 | struct ElementEntry *element) | 1282 | struct ElementEntry *element) |
1273 | { | 1283 | { |
1274 | GNUNET_assert(0 < set_state->current_set_element_count); | 1284 | GNUNET_assert (0 < set_state->current_set_element_count); |
1275 | set_state->current_set_element_count--; | 1285 | set_state->current_set_element_count--; |
1276 | } | 1286 | } |
1277 | 1287 | ||
@@ -1282,19 +1292,19 @@ intersection_remove(struct SetState *set_state, | |||
1282 | * @param op operation that lost the channel | 1292 | * @param op operation that lost the channel |
1283 | */ | 1293 | */ |
1284 | static void | 1294 | static void |
1285 | intersection_channel_death(struct Operation *op) | 1295 | intersection_channel_death (struct Operation *op) |
1286 | { | 1296 | { |
1287 | if (GNUNET_YES == op->state->channel_death_expected) | 1297 | if (GNUNET_YES == op->state->channel_death_expected) |
1288 | { | 1298 | { |
1289 | /* oh goodie, we are done! */ | 1299 | /* oh goodie, we are done! */ |
1290 | send_client_done_and_destroy(op); | 1300 | send_client_done_and_destroy (op); |
1291 | } | 1301 | } |
1292 | else | 1302 | else |
1293 | { | 1303 | { |
1294 | /* sorry, channel went down early, too bad. */ | 1304 | /* sorry, channel went down early, too bad. */ |
1295 | _GSS_operation_destroy(op, | 1305 | _GSS_operation_destroy (op, |
1296 | GNUNET_YES); | 1306 | GNUNET_YES); |
1297 | } | 1307 | } |
1298 | } | 1308 | } |
1299 | 1309 | ||
1300 | 1310 | ||
@@ -1304,7 +1314,7 @@ intersection_channel_death(struct Operation *op) | |||
1304 | * @return the operation specific VTable | 1314 | * @return the operation specific VTable |
1305 | */ | 1315 | */ |
1306 | const struct SetVT * | 1316 | const struct SetVT * |
1307 | _GSS_intersection_vt() | 1317 | _GSS_intersection_vt () |
1308 | { | 1318 | { |
1309 | static const struct SetVT intersection_vt = { | 1319 | static const struct SetVT intersection_vt = { |
1310 | .create = &intersection_set_create, | 1320 | .create = &intersection_set_create, |
diff --git a/src/set/gnunet-service-set_intersection.h b/src/set/gnunet-service-set_intersection.h index 1035cca3b..200e8f5ff 100644 --- a/src/set/gnunet-service-set_intersection.h +++ b/src/set/gnunet-service-set_intersection.h | |||
@@ -1,4 +1,3 @@ | |||
1 | |||
2 | /* | 1 | /* |
3 | This file is part of GNUnet | 2 | This file is part of GNUnet |
4 | Copyright (C) 2013-2017 GNUnet e.V. | 3 | Copyright (C) 2013-2017 GNUnet e.V. |
@@ -38,8 +37,8 @@ | |||
38 | * @return #GNUNET_OK if @a msg is well-formed | 37 | * @return #GNUNET_OK if @a msg is well-formed |
39 | */ | 38 | */ |
40 | int | 39 | int |
41 | check_intersection_p2p_bf(void *cls, | 40 | check_intersection_p2p_bf (void *cls, |
42 | const struct BFMessage *msg); | 41 | const struct BFMessage *msg); |
43 | 42 | ||
44 | 43 | ||
45 | /** | 44 | /** |
@@ -49,8 +48,8 @@ check_intersection_p2p_bf(void *cls, | |||
49 | * @param msg the header of the message | 48 | * @param msg the header of the message |
50 | */ | 49 | */ |
51 | void | 50 | void |
52 | handle_intersection_p2p_bf(void *cls, | 51 | handle_intersection_p2p_bf (void *cls, |
53 | const struct BFMessage *msg); | 52 | const struct BFMessage *msg); |
54 | 53 | ||
55 | 54 | ||
56 | /** | 55 | /** |
@@ -61,8 +60,9 @@ handle_intersection_p2p_bf(void *cls, | |||
61 | * @param mh the header of the message | 60 | * @param mh the header of the message |
62 | */ | 61 | */ |
63 | void | 62 | void |
64 | handle_intersection_p2p_element_info(void *cls, | 63 | handle_intersection_p2p_element_info (void *cls, |
65 | const struct IntersectionElementInfoMessage *msg); | 64 | const struct |
65 | IntersectionElementInfoMessage *msg); | ||
66 | 66 | ||
67 | 67 | ||
68 | /** | 68 | /** |
@@ -72,8 +72,8 @@ handle_intersection_p2p_element_info(void *cls, | |||
72 | * @param mh the message | 72 | * @param mh the message |
73 | */ | 73 | */ |
74 | void | 74 | void |
75 | handle_intersection_p2p_done(void *cls, | 75 | handle_intersection_p2p_done (void *cls, |
76 | const struct IntersectionDoneMessage *idm); | 76 | const struct IntersectionDoneMessage *idm); |
77 | 77 | ||
78 | 78 | ||
79 | #endif | 79 | #endif |
diff --git a/src/set/gnunet-service-set_protocol.h b/src/set/gnunet-service-set_protocol.h index 529fed64c..a2803ee47 100644 --- a/src/set/gnunet-service-set_protocol.h +++ b/src/set/gnunet-service-set_protocol.h | |||
@@ -32,7 +32,8 @@ | |||
32 | 32 | ||
33 | GNUNET_NETWORK_STRUCT_BEGIN | 33 | GNUNET_NETWORK_STRUCT_BEGIN |
34 | 34 | ||
35 | struct OperationRequestMessage { | 35 | struct OperationRequestMessage |
36 | { | ||
36 | /** | 37 | /** |
37 | * Type: #GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST | 38 | * Type: #GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST |
38 | */ | 39 | */ |
@@ -63,7 +64,8 @@ struct OperationRequestMessage { | |||
63 | * If an IBF has too many buckets for an IBF message, | 64 | * If an IBF has too many buckets for an IBF message, |
64 | * it is split into multiple messages. | 65 | * it is split into multiple messages. |
65 | */ | 66 | */ |
66 | struct IBFMessage { | 67 | struct IBFMessage |
68 | { | ||
67 | /** | 69 | /** |
68 | * Type: #GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF | 70 | * Type: #GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF |
69 | */ | 71 | */ |
@@ -99,7 +101,8 @@ struct IBFMessage { | |||
99 | }; | 101 | }; |
100 | 102 | ||
101 | 103 | ||
102 | struct InquiryMessage { | 104 | struct InquiryMessage |
105 | { | ||
103 | /** | 106 | /** |
104 | * Type: #GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF | 107 | * Type: #GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF |
105 | */ | 108 | */ |
@@ -124,7 +127,8 @@ struct InquiryMessage { | |||
124 | * send it the number of elements in the set, to allow the peers | 127 | * send it the number of elements in the set, to allow the peers |
125 | * to decide who should start with the Bloom filter. | 128 | * to decide who should start with the Bloom filter. |
126 | */ | 129 | */ |
127 | struct IntersectionElementInfoMessage { | 130 | struct IntersectionElementInfoMessage |
131 | { | ||
128 | /** | 132 | /** |
129 | * Type: #GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO | 133 | * Type: #GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO |
130 | */ | 134 | */ |
@@ -140,7 +144,8 @@ struct IntersectionElementInfoMessage { | |||
140 | /** | 144 | /** |
141 | * Bloom filter messages exchanged for set intersection calculation. | 145 | * Bloom filter messages exchanged for set intersection calculation. |
142 | */ | 146 | */ |
143 | struct BFMessage { | 147 | struct BFMessage |
148 | { | ||
144 | /** | 149 | /** |
145 | * Type: #GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF | 150 | * Type: #GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF |
146 | */ | 151 | */ |
@@ -184,7 +189,8 @@ struct BFMessage { | |||
184 | * by getting the empty set, which in that case also needs to be | 189 | * by getting the empty set, which in that case also needs to be |
185 | * communicated. | 190 | * communicated. |
186 | */ | 191 | */ |
187 | struct IntersectionDoneMessage { | 192 | struct IntersectionDoneMessage |
193 | { | ||
188 | /** | 194 | /** |
189 | * Type: #GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE | 195 | * Type: #GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE |
190 | */ | 196 | */ |
@@ -205,7 +211,8 @@ struct IntersectionDoneMessage { | |||
205 | /** | 211 | /** |
206 | * Strata estimator together with the peer's overall set size. | 212 | * Strata estimator together with the peer's overall set size. |
207 | */ | 213 | */ |
208 | struct StrataEstimatorMessage { | 214 | struct StrataEstimatorMessage |
215 | { | ||
209 | /** | 216 | /** |
210 | * Type: #GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE(C) | 217 | * Type: #GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE(C) |
211 | */ | 218 | */ |
diff --git a/src/set/gnunet-service-set_union.c b/src/set/gnunet-service-set_union.c index fd7bc24d4..ca4ef2092 100644 --- a/src/set/gnunet-service-set_union.c +++ b/src/set/gnunet-service-set_union.c | |||
@@ -34,7 +34,7 @@ | |||
34 | #include <gcrypt.h> | 34 | #include <gcrypt.h> |
35 | 35 | ||
36 | 36 | ||
37 | #define LOG(kind, ...) GNUNET_log_from(kind, "set-union", __VA_ARGS__) | 37 | #define LOG(kind, ...) GNUNET_log_from (kind, "set-union", __VA_ARGS__) |
38 | 38 | ||
39 | 39 | ||
40 | /** | 40 | /** |
@@ -74,7 +74,8 @@ | |||
74 | /** | 74 | /** |
75 | * Current phase we are in for a union operation. | 75 | * Current phase we are in for a union operation. |
76 | */ | 76 | */ |
77 | enum UnionOperationPhase { | 77 | enum UnionOperationPhase |
78 | { | ||
78 | /** | 79 | /** |
79 | * We sent the request message, and expect a strata estimator. | 80 | * We sent the request message, and expect a strata estimator. |
80 | */ | 81 | */ |
@@ -138,7 +139,8 @@ enum UnionOperationPhase { | |||
138 | /** | 139 | /** |
139 | * State of an evaluate operation with another peer. | 140 | * State of an evaluate operation with another peer. |
140 | */ | 141 | */ |
141 | struct OperationState { | 142 | struct OperationState |
143 | { | ||
142 | /** | 144 | /** |
143 | * Copy of the set's strata estimator at the time of | 145 | * Copy of the set's strata estimator at the time of |
144 | * creation of this operation. | 146 | * creation of this operation. |
@@ -214,7 +216,8 @@ struct OperationState { | |||
214 | /** | 216 | /** |
215 | * The key entry is used to associate an ibf key with an element. | 217 | * The key entry is used to associate an ibf key with an element. |
216 | */ | 218 | */ |
217 | struct KeyEntry { | 219 | struct KeyEntry |
220 | { | ||
218 | /** | 221 | /** |
219 | * IBF key for the entry, derived from the current salt. | 222 | * IBF key for the entry, derived from the current salt. |
220 | */ | 223 | */ |
@@ -242,7 +245,8 @@ struct KeyEntry { | |||
242 | * Used as a closure for sending elements | 245 | * Used as a closure for sending elements |
243 | * with a specific IBF key. | 246 | * with a specific IBF key. |
244 | */ | 247 | */ |
245 | struct SendElementClosure { | 248 | struct SendElementClosure |
249 | { | ||
246 | /** | 250 | /** |
247 | * The IBF key whose matching elements should be | 251 | * The IBF key whose matching elements should be |
248 | * sent. | 252 | * sent. |
@@ -260,7 +264,8 @@ struct SendElementClosure { | |||
260 | /** | 264 | /** |
261 | * Extra state required for efficient set union. | 265 | * Extra state required for efficient set union. |
262 | */ | 266 | */ |
263 | struct SetState { | 267 | struct SetState |
268 | { | ||
264 | /** | 269 | /** |
265 | * The strata estimator is only generated once for | 270 | * The strata estimator is only generated once for |
266 | * each set. | 271 | * each set. |
@@ -282,19 +287,19 @@ struct SetState { | |||
282 | * #GNUNET_NO if not. | 287 | * #GNUNET_NO if not. |
283 | */ | 288 | */ |
284 | static int | 289 | static int |
285 | destroy_key_to_element_iter(void *cls, | 290 | destroy_key_to_element_iter (void *cls, |
286 | uint32_t key, | 291 | uint32_t key, |
287 | void *value) | 292 | void *value) |
288 | { | 293 | { |
289 | struct KeyEntry *k = value; | 294 | struct KeyEntry *k = value; |
290 | 295 | ||
291 | GNUNET_assert(NULL != k); | 296 | GNUNET_assert (NULL != k); |
292 | if (GNUNET_YES == k->element->remote) | 297 | if (GNUNET_YES == k->element->remote) |
293 | { | 298 | { |
294 | GNUNET_free(k->element); | 299 | GNUNET_free (k->element); |
295 | k->element = NULL; | 300 | k->element = NULL; |
296 | } | 301 | } |
297 | GNUNET_free(k); | 302 | GNUNET_free (k); |
298 | return GNUNET_YES; | 303 | return GNUNET_YES; |
299 | } | 304 | } |
300 | 305 | ||
@@ -306,44 +311,44 @@ destroy_key_to_element_iter(void *cls, | |||
306 | * @param op union operation to destroy | 311 | * @param op union operation to destroy |
307 | */ | 312 | */ |
308 | static void | 313 | static void |
309 | union_op_cancel(struct Operation *op) | 314 | union_op_cancel (struct Operation *op) |
310 | { | 315 | { |
311 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 316 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
312 | "destroying union op\n"); | 317 | "destroying union op\n"); |
313 | /* check if the op was canceled twice */ | 318 | /* check if the op was canceled twice */ |
314 | GNUNET_assert(NULL != op->state); | 319 | GNUNET_assert (NULL != op->state); |
315 | if (NULL != op->state->remote_ibf) | 320 | if (NULL != op->state->remote_ibf) |
316 | { | 321 | { |
317 | ibf_destroy(op->state->remote_ibf); | 322 | ibf_destroy (op->state->remote_ibf); |
318 | op->state->remote_ibf = NULL; | 323 | op->state->remote_ibf = NULL; |
319 | } | 324 | } |
320 | if (NULL != op->state->demanded_hashes) | 325 | if (NULL != op->state->demanded_hashes) |
321 | { | 326 | { |
322 | GNUNET_CONTAINER_multihashmap_destroy(op->state->demanded_hashes); | 327 | GNUNET_CONTAINER_multihashmap_destroy (op->state->demanded_hashes); |
323 | op->state->demanded_hashes = NULL; | 328 | op->state->demanded_hashes = NULL; |
324 | } | 329 | } |
325 | if (NULL != op->state->local_ibf) | 330 | if (NULL != op->state->local_ibf) |
326 | { | 331 | { |
327 | ibf_destroy(op->state->local_ibf); | 332 | ibf_destroy (op->state->local_ibf); |
328 | op->state->local_ibf = NULL; | 333 | op->state->local_ibf = NULL; |
329 | } | 334 | } |
330 | if (NULL != op->state->se) | 335 | if (NULL != op->state->se) |
331 | { | 336 | { |
332 | strata_estimator_destroy(op->state->se); | 337 | strata_estimator_destroy (op->state->se); |
333 | op->state->se = NULL; | 338 | op->state->se = NULL; |
334 | } | 339 | } |
335 | if (NULL != op->state->key_to_element) | 340 | if (NULL != op->state->key_to_element) |
336 | { | 341 | { |
337 | GNUNET_CONTAINER_multihashmap32_iterate(op->state->key_to_element, | 342 | GNUNET_CONTAINER_multihashmap32_iterate (op->state->key_to_element, |
338 | &destroy_key_to_element_iter, | 343 | &destroy_key_to_element_iter, |
339 | NULL); | 344 | NULL); |
340 | GNUNET_CONTAINER_multihashmap32_destroy(op->state->key_to_element); | 345 | GNUNET_CONTAINER_multihashmap32_destroy (op->state->key_to_element); |
341 | op->state->key_to_element = NULL; | 346 | op->state->key_to_element = NULL; |
342 | } | 347 | } |
343 | GNUNET_free(op->state); | 348 | GNUNET_free (op->state); |
344 | op->state = NULL; | 349 | op->state = NULL; |
345 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 350 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
346 | "destroying union op done\n"); | 351 | "destroying union op done\n"); |
347 | } | 352 | } |
348 | 353 | ||
349 | 354 | ||
@@ -354,20 +359,20 @@ union_op_cancel(struct Operation *op) | |||
354 | * @param op the union operation to fail | 359 | * @param op the union operation to fail |
355 | */ | 360 | */ |
356 | static void | 361 | static void |
357 | fail_union_operation(struct Operation *op) | 362 | fail_union_operation (struct Operation *op) |
358 | { | 363 | { |
359 | struct GNUNET_MQ_Envelope *ev; | 364 | struct GNUNET_MQ_Envelope *ev; |
360 | struct GNUNET_SET_ResultMessage *msg; | 365 | struct GNUNET_SET_ResultMessage *msg; |
361 | 366 | ||
362 | LOG(GNUNET_ERROR_TYPE_WARNING, | 367 | LOG (GNUNET_ERROR_TYPE_WARNING, |
363 | "union operation failed\n"); | 368 | "union operation failed\n"); |
364 | ev = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_SET_RESULT); | 369 | ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SET_RESULT); |
365 | msg->result_status = htons(GNUNET_SET_STATUS_FAILURE); | 370 | msg->result_status = htons (GNUNET_SET_STATUS_FAILURE); |
366 | msg->request_id = htonl(op->client_request_id); | 371 | msg->request_id = htonl (op->client_request_id); |
367 | msg->element_type = htons(0); | 372 | msg->element_type = htons (0); |
368 | GNUNET_MQ_send(op->set->cs->mq, | 373 | GNUNET_MQ_send (op->set->cs->mq, |
369 | ev); | 374 | ev); |
370 | _GSS_operation_destroy(op, GNUNET_YES); | 375 | _GSS_operation_destroy (op, GNUNET_YES); |
371 | } | 376 | } |
372 | 377 | ||
373 | 378 | ||
@@ -379,16 +384,16 @@ fail_union_operation(struct Operation *op) | |||
379 | * @return the derived IBF key | 384 | * @return the derived IBF key |
380 | */ | 385 | */ |
381 | static struct IBF_Key | 386 | static struct IBF_Key |
382 | get_ibf_key(const struct GNUNET_HashCode *src) | 387 | get_ibf_key (const struct GNUNET_HashCode *src) |
383 | { | 388 | { |
384 | struct IBF_Key key; | 389 | struct IBF_Key key; |
385 | uint16_t salt = 0; | 390 | uint16_t salt = 0; |
386 | 391 | ||
387 | GNUNET_assert(GNUNET_OK == | 392 | GNUNET_assert (GNUNET_OK == |
388 | GNUNET_CRYPTO_kdf(&key, sizeof(key), | 393 | GNUNET_CRYPTO_kdf (&key, sizeof(key), |
389 | src, sizeof *src, | 394 | src, sizeof *src, |
390 | &salt, sizeof(salt), | 395 | &salt, sizeof(salt), |
391 | NULL, 0)); | 396 | NULL, 0)); |
392 | return key; | 397 | return key; |
393 | } | 398 | } |
394 | 399 | ||
@@ -396,7 +401,8 @@ get_ibf_key(const struct GNUNET_HashCode *src) | |||
396 | /** | 401 | /** |
397 | * Context for #op_get_element_iterator | 402 | * Context for #op_get_element_iterator |
398 | */ | 403 | */ |
399 | struct GetElementContext { | 404 | struct GetElementContext |
405 | { | ||
400 | /** | 406 | /** |
401 | * FIXME. | 407 | * FIXME. |
402 | */ | 408 | */ |
@@ -420,20 +426,20 @@ struct GetElementContext { | |||
420 | * #GNUNET_NO if we've found the element. | 426 | * #GNUNET_NO if we've found the element. |
421 | */ | 427 | */ |
422 | static int | 428 | static int |
423 | op_get_element_iterator(void *cls, | 429 | op_get_element_iterator (void *cls, |
424 | uint32_t key, | 430 | uint32_t key, |
425 | void *value) | 431 | void *value) |
426 | { | 432 | { |
427 | struct GetElementContext *ctx = cls; | 433 | struct GetElementContext *ctx = cls; |
428 | struct KeyEntry *k = value; | 434 | struct KeyEntry *k = value; |
429 | 435 | ||
430 | GNUNET_assert(NULL != k); | 436 | GNUNET_assert (NULL != k); |
431 | if (0 == GNUNET_CRYPTO_hash_cmp(&k->element->element_hash, | 437 | if (0 == GNUNET_CRYPTO_hash_cmp (&k->element->element_hash, |
432 | &ctx->hash)) | 438 | &ctx->hash)) |
433 | { | 439 | { |
434 | ctx->k = k; | 440 | ctx->k = k; |
435 | return GNUNET_NO; | 441 | return GNUNET_NO; |
436 | } | 442 | } |
437 | return GNUNET_YES; | 443 | return GNUNET_YES; |
438 | } | 444 | } |
439 | 445 | ||
@@ -447,8 +453,8 @@ op_get_element_iterator(void *cls, | |||
447 | * @return #GNUNET_YES if the element has been found, #GNUNET_NO otherwise | 453 | * @return #GNUNET_YES if the element has been found, #GNUNET_NO otherwise |
448 | */ | 454 | */ |
449 | static struct KeyEntry * | 455 | static struct KeyEntry * |
450 | op_get_element(struct Operation *op, | 456 | op_get_element (struct Operation *op, |
451 | const struct GNUNET_HashCode *element_hash) | 457 | const struct GNUNET_HashCode *element_hash) |
452 | { | 458 | { |
453 | int ret; | 459 | int ret; |
454 | struct IBF_Key ibf_key; | 460 | struct IBF_Key ibf_key; |
@@ -456,18 +462,18 @@ op_get_element(struct Operation *op, | |||
456 | 462 | ||
457 | ctx.hash = *element_hash; | 463 | ctx.hash = *element_hash; |
458 | 464 | ||
459 | ibf_key = get_ibf_key(element_hash); | 465 | ibf_key = get_ibf_key (element_hash); |
460 | ret = GNUNET_CONTAINER_multihashmap32_get_multiple(op->state->key_to_element, | 466 | ret = GNUNET_CONTAINER_multihashmap32_get_multiple (op->state->key_to_element, |
461 | (uint32_t)ibf_key.key_val, | 467 | (uint32_t) ibf_key.key_val, |
462 | op_get_element_iterator, | 468 | op_get_element_iterator, |
463 | &ctx); | 469 | &ctx); |
464 | 470 | ||
465 | /* was the iteration aborted because we found the element? */ | 471 | /* was the iteration aborted because we found the element? */ |
466 | if (GNUNET_SYSERR == ret) | 472 | if (GNUNET_SYSERR == ret) |
467 | { | 473 | { |
468 | GNUNET_assert(NULL != ctx.k); | 474 | GNUNET_assert (NULL != ctx.k); |
469 | return ctx.k; | 475 | return ctx.k; |
470 | } | 476 | } |
471 | return NULL; | 477 | return NULL; |
472 | } | 478 | } |
473 | 479 | ||
@@ -487,23 +493,23 @@ op_get_element(struct Operation *op, | |||
487 | * @parem received was this element received from the remote peer? | 493 | * @parem received was this element received from the remote peer? |
488 | */ | 494 | */ |
489 | static void | 495 | static void |
490 | op_register_element(struct Operation *op, | 496 | op_register_element (struct Operation *op, |
491 | struct ElementEntry *ee, | 497 | struct ElementEntry *ee, |
492 | int received) | 498 | int received) |
493 | { | 499 | { |
494 | struct IBF_Key ibf_key; | 500 | struct IBF_Key ibf_key; |
495 | struct KeyEntry *k; | 501 | struct KeyEntry *k; |
496 | 502 | ||
497 | ibf_key = get_ibf_key(&ee->element_hash); | 503 | ibf_key = get_ibf_key (&ee->element_hash); |
498 | k = GNUNET_new(struct KeyEntry); | 504 | k = GNUNET_new (struct KeyEntry); |
499 | k->element = ee; | 505 | k->element = ee; |
500 | k->ibf_key = ibf_key; | 506 | k->ibf_key = ibf_key; |
501 | k->received = received; | 507 | k->received = received; |
502 | GNUNET_assert(GNUNET_OK == | 508 | GNUNET_assert (GNUNET_OK == |
503 | GNUNET_CONTAINER_multihashmap32_put(op->state->key_to_element, | 509 | GNUNET_CONTAINER_multihashmap32_put (op->state->key_to_element, |
504 | (uint32_t)ibf_key.key_val, | 510 | (uint32_t) ibf_key.key_val, |
505 | k, | 511 | k, |
506 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); | 512 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); |
507 | } | 513 | } |
508 | 514 | ||
509 | 515 | ||
@@ -511,9 +517,9 @@ op_register_element(struct Operation *op, | |||
511 | * FIXME. | 517 | * FIXME. |
512 | */ | 518 | */ |
513 | static void | 519 | static void |
514 | salt_key(const struct IBF_Key *k_in, | 520 | salt_key (const struct IBF_Key *k_in, |
515 | uint32_t salt, | 521 | uint32_t salt, |
516 | struct IBF_Key *k_out) | 522 | struct IBF_Key *k_out) |
517 | { | 523 | { |
518 | int s = salt % 64; | 524 | int s = salt % 64; |
519 | uint64_t x = k_in->key_val; | 525 | uint64_t x = k_in->key_val; |
@@ -528,9 +534,9 @@ salt_key(const struct IBF_Key *k_in, | |||
528 | * FIXME. | 534 | * FIXME. |
529 | */ | 535 | */ |
530 | static void | 536 | static void |
531 | unsalt_key(const struct IBF_Key *k_in, | 537 | unsalt_key (const struct IBF_Key *k_in, |
532 | uint32_t salt, | 538 | uint32_t salt, |
533 | struct IBF_Key *k_out) | 539 | struct IBF_Key *k_out) |
534 | { | 540 | { |
535 | int s = salt % 64; | 541 | int s = salt % 64; |
536 | uint64_t x = k_in->key_val; | 542 | uint64_t x = k_in->key_val; |
@@ -548,23 +554,23 @@ unsalt_key(const struct IBF_Key *k_in, | |||
548 | * @param value the key entry to get the key from | 554 | * @param value the key entry to get the key from |
549 | */ | 555 | */ |
550 | static int | 556 | static int |
551 | prepare_ibf_iterator(void *cls, | 557 | prepare_ibf_iterator (void *cls, |
552 | uint32_t key, | 558 | uint32_t key, |
553 | void *value) | 559 | void *value) |
554 | { | 560 | { |
555 | struct Operation *op = cls; | 561 | struct Operation *op = cls; |
556 | struct KeyEntry *ke = value; | 562 | struct KeyEntry *ke = value; |
557 | struct IBF_Key salted_key; | 563 | struct IBF_Key salted_key; |
558 | 564 | ||
559 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 565 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
560 | "[OP %x] inserting %lx (hash %s) into ibf\n", | 566 | "[OP %x] inserting %lx (hash %s) into ibf\n", |
561 | (void *)op, | 567 | (void *) op, |
562 | (unsigned long)ke->ibf_key.key_val, | 568 | (unsigned long) ke->ibf_key.key_val, |
563 | GNUNET_h2s(&ke->element->element_hash)); | 569 | GNUNET_h2s (&ke->element->element_hash)); |
564 | salt_key(&ke->ibf_key, | 570 | salt_key (&ke->ibf_key, |
565 | op->state->salt_send, | 571 | op->state->salt_send, |
566 | &salted_key); | 572 | &salted_key); |
567 | ibf_insert(op->state->local_ibf, salted_key); | 573 | ibf_insert (op->state->local_ibf, salted_key); |
568 | return GNUNET_YES; | 574 | return GNUNET_YES; |
569 | } | 575 | } |
570 | 576 | ||
@@ -580,9 +586,9 @@ prepare_ibf_iterator(void *cls, | |||
580 | * @return #GNUNET_YES (to continue iterating) | 586 | * @return #GNUNET_YES (to continue iterating) |
581 | */ | 587 | */ |
582 | static int | 588 | static int |
583 | init_key_to_element_iterator(void *cls, | 589 | init_key_to_element_iterator (void *cls, |
584 | const struct GNUNET_HashCode *key, | 590 | const struct GNUNET_HashCode *key, |
585 | void *value) | 591 | void *value) |
586 | { | 592 | { |
587 | struct Operation *op = cls; | 593 | struct Operation *op = cls; |
588 | struct ElementEntry *ee = value; | 594 | struct ElementEntry *ee = value; |
@@ -590,13 +596,13 @@ init_key_to_element_iterator(void *cls, | |||
590 | /* make sure that the element belongs to the set at the time | 596 | /* make sure that the element belongs to the set at the time |
591 | * of creating the operation */ | 597 | * of creating the operation */ |
592 | if (GNUNET_NO == | 598 | if (GNUNET_NO == |
593 | _GSS_is_element_of_operation(ee, | 599 | _GSS_is_element_of_operation (ee, |
594 | op)) | 600 | op)) |
595 | return GNUNET_YES; | 601 | return GNUNET_YES; |
596 | GNUNET_assert(GNUNET_NO == ee->remote); | 602 | GNUNET_assert (GNUNET_NO == ee->remote); |
597 | op_register_element(op, | 603 | op_register_element (op, |
598 | ee, | 604 | ee, |
599 | GNUNET_NO); | 605 | GNUNET_NO); |
600 | return GNUNET_YES; | 606 | return GNUNET_YES; |
601 | } | 607 | } |
602 | 608 | ||
@@ -608,16 +614,16 @@ init_key_to_element_iterator(void *cls, | |||
608 | * @param op the set union operation | 614 | * @param op the set union operation |
609 | */ | 615 | */ |
610 | static void | 616 | static void |
611 | initialize_key_to_element(struct Operation *op) | 617 | initialize_key_to_element (struct Operation *op) |
612 | { | 618 | { |
613 | unsigned int len; | 619 | unsigned int len; |
614 | 620 | ||
615 | GNUNET_assert(NULL == op->state->key_to_element); | 621 | GNUNET_assert (NULL == op->state->key_to_element); |
616 | len = GNUNET_CONTAINER_multihashmap_size(op->set->content->elements); | 622 | len = GNUNET_CONTAINER_multihashmap_size (op->set->content->elements); |
617 | op->state->key_to_element = GNUNET_CONTAINER_multihashmap32_create(len + 1); | 623 | op->state->key_to_element = GNUNET_CONTAINER_multihashmap32_create (len + 1); |
618 | GNUNET_CONTAINER_multihashmap_iterate(op->set->content->elements, | 624 | GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements, |
619 | &init_key_to_element_iterator, | 625 | &init_key_to_element_iterator, |
620 | op); | 626 | op); |
621 | } | 627 | } |
622 | 628 | ||
623 | 629 | ||
@@ -630,23 +636,23 @@ initialize_key_to_element(struct Operation *op) | |||
630 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure | 636 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure |
631 | */ | 637 | */ |
632 | static int | 638 | static int |
633 | prepare_ibf(struct Operation *op, | 639 | prepare_ibf (struct Operation *op, |
634 | uint32_t size) | 640 | uint32_t size) |
635 | { | 641 | { |
636 | GNUNET_assert(NULL != op->state->key_to_element); | 642 | GNUNET_assert (NULL != op->state->key_to_element); |
637 | 643 | ||
638 | if (NULL != op->state->local_ibf) | 644 | if (NULL != op->state->local_ibf) |
639 | ibf_destroy(op->state->local_ibf); | 645 | ibf_destroy (op->state->local_ibf); |
640 | op->state->local_ibf = ibf_create(size, SE_IBF_HASH_NUM); | 646 | op->state->local_ibf = ibf_create (size, SE_IBF_HASH_NUM); |
641 | if (NULL == op->state->local_ibf) | 647 | if (NULL == op->state->local_ibf) |
642 | { | 648 | { |
643 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 649 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
644 | "Failed to allocate local IBF\n"); | 650 | "Failed to allocate local IBF\n"); |
645 | return GNUNET_SYSERR; | 651 | return GNUNET_SYSERR; |
646 | } | 652 | } |
647 | GNUNET_CONTAINER_multihashmap32_iterate(op->state->key_to_element, | 653 | GNUNET_CONTAINER_multihashmap32_iterate (op->state->key_to_element, |
648 | &prepare_ibf_iterator, | 654 | &prepare_ibf_iterator, |
649 | op); | 655 | op); |
650 | return GNUNET_OK; | 656 | return GNUNET_OK; |
651 | } | 657 | } |
652 | 658 | ||
@@ -661,60 +667,60 @@ prepare_ibf(struct Operation *op, | |||
661 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure | 667 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure |
662 | */ | 668 | */ |
663 | static int | 669 | static int |
664 | send_ibf(struct Operation *op, | 670 | send_ibf (struct Operation *op, |
665 | uint16_t ibf_order) | 671 | uint16_t ibf_order) |
666 | { | 672 | { |
667 | unsigned int buckets_sent = 0; | 673 | unsigned int buckets_sent = 0; |
668 | struct InvertibleBloomFilter *ibf; | 674 | struct InvertibleBloomFilter *ibf; |
669 | 675 | ||
670 | if (GNUNET_OK != | 676 | if (GNUNET_OK != |
671 | prepare_ibf(op, 1 << ibf_order)) | 677 | prepare_ibf (op, 1 << ibf_order)) |
672 | { | 678 | { |
673 | /* allocation failed */ | 679 | /* allocation failed */ |
674 | return GNUNET_SYSERR; | 680 | return GNUNET_SYSERR; |
675 | } | 681 | } |
676 | 682 | ||
677 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 683 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
678 | "sending ibf of size %u\n", | 684 | "sending ibf of size %u\n", |
679 | 1 << ibf_order); | 685 | 1 << ibf_order); |
680 | 686 | ||
681 | { | 687 | { |
682 | char name[64] = { 0 }; | 688 | char name[64] = { 0 }; |
683 | snprintf(name, sizeof(name), "# sent IBF (order %u)", ibf_order); | 689 | snprintf (name, sizeof(name), "# sent IBF (order %u)", ibf_order); |
684 | GNUNET_STATISTICS_update(_GSS_statistics, name, 1, GNUNET_NO); | 690 | GNUNET_STATISTICS_update (_GSS_statistics, name, 1, GNUNET_NO); |
685 | } | 691 | } |
686 | 692 | ||
687 | ibf = op->state->local_ibf; | 693 | ibf = op->state->local_ibf; |
688 | 694 | ||
689 | while (buckets_sent < (1 << ibf_order)) | 695 | while (buckets_sent < (1 << ibf_order)) |
690 | { | 696 | { |
691 | unsigned int buckets_in_message; | 697 | unsigned int buckets_in_message; |
692 | struct GNUNET_MQ_Envelope *ev; | 698 | struct GNUNET_MQ_Envelope *ev; |
693 | struct IBFMessage *msg; | 699 | struct IBFMessage *msg; |
694 | 700 | ||
695 | buckets_in_message = (1 << ibf_order) - buckets_sent; | 701 | buckets_in_message = (1 << ibf_order) - buckets_sent; |
696 | /* limit to maximum */ | 702 | /* limit to maximum */ |
697 | if (buckets_in_message > MAX_BUCKETS_PER_MESSAGE) | 703 | if (buckets_in_message > MAX_BUCKETS_PER_MESSAGE) |
698 | buckets_in_message = MAX_BUCKETS_PER_MESSAGE; | 704 | buckets_in_message = MAX_BUCKETS_PER_MESSAGE; |
699 | 705 | ||
700 | ev = GNUNET_MQ_msg_extra(msg, | 706 | ev = GNUNET_MQ_msg_extra (msg, |
701 | buckets_in_message * IBF_BUCKET_SIZE, | 707 | buckets_in_message * IBF_BUCKET_SIZE, |
702 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF); | 708 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF); |
703 | msg->reserved1 = 0; | 709 | msg->reserved1 = 0; |
704 | msg->reserved2 = 0; | 710 | msg->reserved2 = 0; |
705 | msg->order = ibf_order; | 711 | msg->order = ibf_order; |
706 | msg->offset = htonl(buckets_sent); | 712 | msg->offset = htonl (buckets_sent); |
707 | msg->salt = htonl(op->state->salt_send); | 713 | msg->salt = htonl (op->state->salt_send); |
708 | ibf_write_slice(ibf, buckets_sent, | 714 | ibf_write_slice (ibf, buckets_sent, |
709 | buckets_in_message, &msg[1]); | 715 | buckets_in_message, &msg[1]); |
710 | buckets_sent += buckets_in_message; | 716 | buckets_sent += buckets_in_message; |
711 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 717 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
712 | "ibf chunk size %u, %u/%u sent\n", | 718 | "ibf chunk size %u, %u/%u sent\n", |
713 | buckets_in_message, | 719 | buckets_in_message, |
714 | buckets_sent, | 720 | buckets_sent, |
715 | 1 << ibf_order); | 721 | 1 << ibf_order); |
716 | GNUNET_MQ_send(op->mq, ev); | 722 | GNUNET_MQ_send (op->mq, ev); |
717 | } | 723 | } |
718 | 724 | ||
719 | /* The other peer must decode the IBF, so | 725 | /* The other peer must decode the IBF, so |
720 | * we're passive. */ | 726 | * we're passive. */ |
@@ -731,7 +737,7 @@ send_ibf(struct Operation *op, | |||
731 | * @return the required size of the ibf | 737 | * @return the required size of the ibf |
732 | */ | 738 | */ |
733 | static unsigned int | 739 | static unsigned int |
734 | get_order_from_difference(unsigned int diff) | 740 | get_order_from_difference (unsigned int diff) |
735 | { | 741 | { |
736 | unsigned int ibf_order; | 742 | unsigned int ibf_order; |
737 | 743 | ||
@@ -755,9 +761,9 @@ get_order_from_difference(unsigned int diff) | |||
755 | * @return #GNUNET_YES (to continue iterating) | 761 | * @return #GNUNET_YES (to continue iterating) |
756 | */ | 762 | */ |
757 | static int | 763 | static int |
758 | send_full_element_iterator(void *cls, | 764 | send_full_element_iterator (void *cls, |
759 | const struct GNUNET_HashCode *key, | 765 | const struct GNUNET_HashCode *key, |
760 | void *value) | 766 | void *value) |
761 | { | 767 | { |
762 | struct Operation *op = cls; | 768 | struct Operation *op = cls; |
763 | struct GNUNET_SET_ElementMessage *emsg; | 769 | struct GNUNET_SET_ElementMessage *emsg; |
@@ -765,18 +771,18 @@ send_full_element_iterator(void *cls, | |||
765 | struct GNUNET_SET_Element *el = &ee->element; | 771 | struct GNUNET_SET_Element *el = &ee->element; |
766 | struct GNUNET_MQ_Envelope *ev; | 772 | struct GNUNET_MQ_Envelope *ev; |
767 | 773 | ||
768 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 774 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
769 | "Sending element %s\n", | 775 | "Sending element %s\n", |
770 | GNUNET_h2s(key)); | 776 | GNUNET_h2s (key)); |
771 | ev = GNUNET_MQ_msg_extra(emsg, | 777 | ev = GNUNET_MQ_msg_extra (emsg, |
772 | el->size, | 778 | el->size, |
773 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT); | 779 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT); |
774 | emsg->element_type = htons(el->element_type); | 780 | emsg->element_type = htons (el->element_type); |
775 | GNUNET_memcpy(&emsg[1], | 781 | GNUNET_memcpy (&emsg[1], |
776 | el->data, | 782 | el->data, |
777 | el->size); | 783 | el->size); |
778 | GNUNET_MQ_send(op->mq, | 784 | GNUNET_MQ_send (op->mq, |
779 | ev); | 785 | ev); |
780 | return GNUNET_YES; | 786 | return GNUNET_YES; |
781 | } | 787 | } |
782 | 788 | ||
@@ -787,21 +793,21 @@ send_full_element_iterator(void *cls, | |||
787 | * @param op operation to switch to full set transmission. | 793 | * @param op operation to switch to full set transmission. |
788 | */ | 794 | */ |
789 | static void | 795 | static void |
790 | send_full_set(struct Operation *op) | 796 | send_full_set (struct Operation *op) |
791 | { | 797 | { |
792 | struct GNUNET_MQ_Envelope *ev; | 798 | struct GNUNET_MQ_Envelope *ev; |
793 | 799 | ||
794 | op->state->phase = PHASE_FULL_SENDING; | 800 | op->state->phase = PHASE_FULL_SENDING; |
795 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 801 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
796 | "Dedicing to transmit the full set\n"); | 802 | "Dedicing to transmit the full set\n"); |
797 | /* FIXME: use a more memory-friendly way of doing this with an | 803 | /* FIXME: use a more memory-friendly way of doing this with an |
798 | iterator, just as we do in the non-full case! */ | 804 | iterator, just as we do in the non-full case! */ |
799 | (void)GNUNET_CONTAINER_multihashmap_iterate(op->set->content->elements, | 805 | (void) GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements, |
800 | &send_full_element_iterator, | 806 | &send_full_element_iterator, |
801 | op); | 807 | op); |
802 | ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE); | 808 | ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE); |
803 | GNUNET_MQ_send(op->mq, | 809 | GNUNET_MQ_send (op->mq, |
804 | ev); | 810 | ev); |
805 | } | 811 | } |
806 | 812 | ||
807 | 813 | ||
@@ -812,26 +818,27 @@ send_full_set(struct Operation *op) | |||
812 | * @param msg the message | 818 | * @param msg the message |
813 | */ | 819 | */ |
814 | int | 820 | int |
815 | check_union_p2p_strata_estimator(void *cls, | 821 | check_union_p2p_strata_estimator (void *cls, |
816 | const struct StrataEstimatorMessage *msg) | 822 | const struct StrataEstimatorMessage *msg) |
817 | { | 823 | { |
818 | struct Operation *op = cls; | 824 | struct Operation *op = cls; |
819 | int is_compressed; | 825 | int is_compressed; |
820 | size_t len; | 826 | size_t len; |
821 | 827 | ||
822 | if (op->state->phase != PHASE_EXPECT_SE) | 828 | if (op->state->phase != PHASE_EXPECT_SE) |
823 | { | 829 | { |
824 | GNUNET_break(0); | 830 | GNUNET_break (0); |
825 | return GNUNET_SYSERR; | 831 | return GNUNET_SYSERR; |
826 | } | 832 | } |
827 | is_compressed = (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC == htons(msg->header.type)); | 833 | is_compressed = (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC == htons ( |
828 | len = ntohs(msg->header.size) - sizeof(struct StrataEstimatorMessage); | 834 | msg->header.type)); |
835 | len = ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage); | ||
829 | if ((GNUNET_NO == is_compressed) && | 836 | if ((GNUNET_NO == is_compressed) && |
830 | (len != SE_STRATA_COUNT * SE_IBF_SIZE * IBF_BUCKET_SIZE)) | 837 | (len != SE_STRATA_COUNT * SE_IBF_SIZE * IBF_BUCKET_SIZE)) |
831 | { | 838 | { |
832 | GNUNET_break(0); | 839 | GNUNET_break (0); |
833 | return GNUNET_SYSERR; | 840 | return GNUNET_SYSERR; |
834 | } | 841 | } |
835 | return GNUNET_OK; | 842 | return GNUNET_OK; |
836 | } | 843 | } |
837 | 844 | ||
@@ -843,8 +850,8 @@ check_union_p2p_strata_estimator(void *cls, | |||
843 | * @param msg the message | 850 | * @param msg the message |
844 | */ | 851 | */ |
845 | void | 852 | void |
846 | handle_union_p2p_strata_estimator(void *cls, | 853 | handle_union_p2p_strata_estimator (void *cls, |
847 | const struct StrataEstimatorMessage *msg) | 854 | const struct StrataEstimatorMessage *msg) |
848 | { | 855 | { |
849 | struct Operation *op = cls; | 856 | struct Operation *op = cls; |
850 | struct StrataEstimator *remote_se; | 857 | struct StrataEstimator *remote_se; |
@@ -853,116 +860,118 @@ handle_union_p2p_strata_estimator(void *cls, | |||
853 | size_t len; | 860 | size_t len; |
854 | int is_compressed; | 861 | int is_compressed; |
855 | 862 | ||
856 | is_compressed = (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC == htons(msg->header.type)); | 863 | is_compressed = (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC == htons ( |
857 | GNUNET_STATISTICS_update(_GSS_statistics, | 864 | msg->header.type)); |
858 | "# bytes of SE received", | 865 | GNUNET_STATISTICS_update (_GSS_statistics, |
859 | ntohs(msg->header.size), | 866 | "# bytes of SE received", |
860 | GNUNET_NO); | 867 | ntohs (msg->header.size), |
861 | len = ntohs(msg->header.size) - sizeof(struct StrataEstimatorMessage); | 868 | GNUNET_NO); |
862 | other_size = GNUNET_ntohll(msg->set_size); | 869 | len = ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage); |
863 | remote_se = strata_estimator_create(SE_STRATA_COUNT, | 870 | other_size = GNUNET_ntohll (msg->set_size); |
864 | SE_IBF_SIZE, | 871 | remote_se = strata_estimator_create (SE_STRATA_COUNT, |
865 | SE_IBF_HASH_NUM); | 872 | SE_IBF_SIZE, |
873 | SE_IBF_HASH_NUM); | ||
866 | if (NULL == remote_se) | 874 | if (NULL == remote_se) |
867 | { | 875 | { |
868 | /* insufficient resources, fail */ | 876 | /* insufficient resources, fail */ |
869 | fail_union_operation(op); | 877 | fail_union_operation (op); |
870 | return; | 878 | return; |
871 | } | 879 | } |
872 | if (GNUNET_OK != | 880 | if (GNUNET_OK != |
873 | strata_estimator_read(&msg[1], | 881 | strata_estimator_read (&msg[1], |
874 | len, | 882 | len, |
875 | is_compressed, | 883 | is_compressed, |
876 | remote_se)) | 884 | remote_se)) |
877 | { | 885 | { |
878 | /* decompression failed */ | 886 | /* decompression failed */ |
879 | strata_estimator_destroy(remote_se); | 887 | strata_estimator_destroy (remote_se); |
880 | fail_union_operation(op); | 888 | fail_union_operation (op); |
881 | return; | 889 | return; |
882 | } | 890 | } |
883 | GNUNET_assert(NULL != op->state->se); | 891 | GNUNET_assert (NULL != op->state->se); |
884 | diff = strata_estimator_difference(remote_se, | 892 | diff = strata_estimator_difference (remote_se, |
885 | op->state->se); | 893 | op->state->se); |
886 | 894 | ||
887 | if (diff > 200) | 895 | if (diff > 200) |
888 | diff = diff * 3 / 2; | 896 | diff = diff * 3 / 2; |
889 | 897 | ||
890 | strata_estimator_destroy(remote_se); | 898 | strata_estimator_destroy (remote_se); |
891 | strata_estimator_destroy(op->state->se); | 899 | strata_estimator_destroy (op->state->se); |
892 | op->state->se = NULL; | 900 | op->state->se = NULL; |
893 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 901 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
894 | "got se diff=%d, using ibf size %d\n", | 902 | "got se diff=%d, using ibf size %d\n", |
895 | diff, | 903 | diff, |
896 | 1U << get_order_from_difference(diff)); | 904 | 1U << get_order_from_difference (diff)); |
897 | 905 | ||
898 | { | 906 | { |
899 | char *set_debug; | 907 | char *set_debug; |
900 | 908 | ||
901 | set_debug = getenv("GNUNET_SET_BENCHMARK"); | 909 | set_debug = getenv ("GNUNET_SET_BENCHMARK"); |
902 | if ((NULL != set_debug) && | 910 | if ((NULL != set_debug) && |
903 | (0 == strcmp(set_debug, "1"))) | 911 | (0 == strcmp (set_debug, "1"))) |
904 | { | 912 | { |
905 | FILE *f = fopen("set.log", "a"); | 913 | FILE *f = fopen ("set.log", "a"); |
906 | fprintf(f, "%llu\n", (unsigned long long)diff); | 914 | fprintf (f, "%llu\n", (unsigned long long) diff); |
907 | fclose(f); | 915 | fclose (f); |
908 | } | 916 | } |
909 | } | 917 | } |
910 | 918 | ||
911 | if ((GNUNET_YES == op->byzantine) && | 919 | if ((GNUNET_YES == op->byzantine) && |
912 | (other_size < op->byzantine_lower_bound)) | 920 | (other_size < op->byzantine_lower_bound)) |
913 | { | 921 | { |
914 | GNUNET_break(0); | 922 | GNUNET_break (0); |
915 | fail_union_operation(op); | 923 | fail_union_operation (op); |
916 | return; | 924 | return; |
917 | } | 925 | } |
918 | 926 | ||
919 | if ((GNUNET_YES == op->force_full) || | 927 | if ((GNUNET_YES == op->force_full) || |
920 | (diff > op->state->initial_size / 4) || | 928 | (diff > op->state->initial_size / 4) || |
921 | (0 == other_size)) | 929 | (0 == other_size)) |
930 | { | ||
931 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
932 | "Deciding to go for full set transmission (diff=%d, own set=%u)\n", | ||
933 | diff, | ||
934 | op->state->initial_size); | ||
935 | GNUNET_STATISTICS_update (_GSS_statistics, | ||
936 | "# of full sends", | ||
937 | 1, | ||
938 | GNUNET_NO); | ||
939 | if ((op->state->initial_size <= other_size) || | ||
940 | (0 == other_size)) | ||
922 | { | 941 | { |
923 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 942 | send_full_set (op); |
924 | "Deciding to go for full set transmission (diff=%d, own set=%u)\n", | ||
925 | diff, | ||
926 | op->state->initial_size); | ||
927 | GNUNET_STATISTICS_update(_GSS_statistics, | ||
928 | "# of full sends", | ||
929 | 1, | ||
930 | GNUNET_NO); | ||
931 | if ((op->state->initial_size <= other_size) || | ||
932 | (0 == other_size)) | ||
933 | { | ||
934 | send_full_set(op); | ||
935 | } | ||
936 | else | ||
937 | { | ||
938 | struct GNUNET_MQ_Envelope *ev; | ||
939 | |||
940 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
941 | "Telling other peer that we expect its full set\n"); | ||
942 | op->state->phase = PHASE_EXPECT_IBF; | ||
943 | ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL); | ||
944 | GNUNET_MQ_send(op->mq, | ||
945 | ev); | ||
946 | } | ||
947 | } | 943 | } |
948 | else | 944 | else |
949 | { | 945 | { |
950 | GNUNET_STATISTICS_update(_GSS_statistics, | 946 | struct GNUNET_MQ_Envelope *ev; |
951 | "# of ibf sends", | 947 | |
952 | 1, | 948 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
953 | GNUNET_NO); | 949 | "Telling other peer that we expect its full set\n"); |
954 | if (GNUNET_OK != | 950 | op->state->phase = PHASE_EXPECT_IBF; |
955 | send_ibf(op, | 951 | ev = GNUNET_MQ_msg_header ( |
956 | get_order_from_difference(diff))) | 952 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL); |
957 | { | 953 | GNUNET_MQ_send (op->mq, |
958 | /* Internal error, best we can do is shut the connection */ | 954 | ev); |
959 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
960 | "Failed to send IBF, closing connection\n"); | ||
961 | fail_union_operation(op); | ||
962 | return; | ||
963 | } | ||
964 | } | 955 | } |
965 | GNUNET_CADET_receive_done(op->channel); | 956 | } |
957 | else | ||
958 | { | ||
959 | GNUNET_STATISTICS_update (_GSS_statistics, | ||
960 | "# of ibf sends", | ||
961 | 1, | ||
962 | GNUNET_NO); | ||
963 | if (GNUNET_OK != | ||
964 | send_ibf (op, | ||
965 | get_order_from_difference (diff))) | ||
966 | { | ||
967 | /* Internal error, best we can do is shut the connection */ | ||
968 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
969 | "Failed to send IBF, closing connection\n"); | ||
970 | fail_union_operation (op); | ||
971 | return; | ||
972 | } | ||
973 | } | ||
974 | GNUNET_CADET_receive_done (op->channel); | ||
966 | } | 975 | } |
967 | 976 | ||
968 | 977 | ||
@@ -974,9 +983,9 @@ handle_union_p2p_strata_estimator(void *cls, | |||
974 | * @param value the key entry | 983 | * @param value the key entry |
975 | */ | 984 | */ |
976 | static int | 985 | static int |
977 | send_offers_iterator(void *cls, | 986 | send_offers_iterator (void *cls, |
978 | uint32_t key, | 987 | uint32_t key, |
979 | void *value) | 988 | void *value) |
980 | { | 989 | { |
981 | struct SendElementClosure *sec = cls; | 990 | struct SendElementClosure *sec = cls; |
982 | struct Operation *op = sec->op; | 991 | struct Operation *op = sec->op; |
@@ -988,17 +997,17 @@ send_offers_iterator(void *cls, | |||
988 | if (ke->ibf_key.key_val != sec->ibf_key.key_val) | 997 | if (ke->ibf_key.key_val != sec->ibf_key.key_val) |
989 | return GNUNET_YES; | 998 | return GNUNET_YES; |
990 | 999 | ||
991 | ev = GNUNET_MQ_msg_header_extra(mh, | 1000 | ev = GNUNET_MQ_msg_header_extra (mh, |
992 | sizeof(struct GNUNET_HashCode), | 1001 | sizeof(struct GNUNET_HashCode), |
993 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER); | 1002 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER); |
994 | 1003 | ||
995 | GNUNET_assert(NULL != ev); | 1004 | GNUNET_assert (NULL != ev); |
996 | *(struct GNUNET_HashCode *)&mh[1] = ke->element->element_hash; | 1005 | *(struct GNUNET_HashCode *) &mh[1] = ke->element->element_hash; |
997 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1006 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
998 | "[OP %x] sending element offer (%s) to peer\n", | 1007 | "[OP %x] sending element offer (%s) to peer\n", |
999 | (void *)op, | 1008 | (void *) op, |
1000 | GNUNET_h2s(&ke->element->element_hash)); | 1009 | GNUNET_h2s (&ke->element->element_hash)); |
1001 | GNUNET_MQ_send(op->mq, ev); | 1010 | GNUNET_MQ_send (op->mq, ev); |
1002 | return GNUNET_YES; | 1011 | return GNUNET_YES; |
1003 | } | 1012 | } |
1004 | 1013 | ||
@@ -1010,17 +1019,19 @@ send_offers_iterator(void *cls, | |||
1010 | * @param ibf_key IBF key of interest | 1019 | * @param ibf_key IBF key of interest |
1011 | */ | 1020 | */ |
1012 | static void | 1021 | static void |
1013 | send_offers_for_key(struct Operation *op, | 1022 | send_offers_for_key (struct Operation *op, |
1014 | struct IBF_Key ibf_key) | 1023 | struct IBF_Key ibf_key) |
1015 | { | 1024 | { |
1016 | struct SendElementClosure send_cls; | 1025 | struct SendElementClosure send_cls; |
1017 | 1026 | ||
1018 | send_cls.ibf_key = ibf_key; | 1027 | send_cls.ibf_key = ibf_key; |
1019 | send_cls.op = op; | 1028 | send_cls.op = op; |
1020 | (void)GNUNET_CONTAINER_multihashmap32_get_multiple(op->state->key_to_element, | 1029 | (void) GNUNET_CONTAINER_multihashmap32_get_multiple ( |
1021 | (uint32_t)ibf_key.key_val, | 1030 | op->state->key_to_element, |
1022 | &send_offers_iterator, | 1031 | (uint32_t) ibf_key. |
1023 | &send_cls); | 1032 | key_val, |
1033 | &send_offers_iterator, | ||
1034 | &send_cls); | ||
1024 | } | 1035 | } |
1025 | 1036 | ||
1026 | 1037 | ||
@@ -1032,7 +1043,7 @@ send_offers_for_key(struct Operation *op, | |||
1032 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure | 1043 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure |
1033 | */ | 1044 | */ |
1034 | static int | 1045 | static int |
1035 | decode_and_send(struct Operation *op) | 1046 | decode_and_send (struct Operation *op) |
1036 | { | 1047 | { |
1037 | struct IBF_Key key; | 1048 | struct IBF_Key key; |
1038 | struct IBF_Key last_key; | 1049 | struct IBF_Key last_key; |
@@ -1040,147 +1051,147 @@ decode_and_send(struct Operation *op) | |||
1040 | unsigned int num_decoded; | 1051 | unsigned int num_decoded; |
1041 | struct InvertibleBloomFilter *diff_ibf; | 1052 | struct InvertibleBloomFilter *diff_ibf; |
1042 | 1053 | ||
1043 | GNUNET_assert(PHASE_INVENTORY_ACTIVE == op->state->phase); | 1054 | GNUNET_assert (PHASE_INVENTORY_ACTIVE == op->state->phase); |
1044 | 1055 | ||
1045 | if (GNUNET_OK != | 1056 | if (GNUNET_OK != |
1046 | prepare_ibf(op, | 1057 | prepare_ibf (op, |
1047 | op->state->remote_ibf->size)) | 1058 | op->state->remote_ibf->size)) |
1048 | { | 1059 | { |
1049 | GNUNET_break(0); | 1060 | GNUNET_break (0); |
1050 | /* allocation failed */ | 1061 | /* allocation failed */ |
1051 | return GNUNET_SYSERR; | 1062 | return GNUNET_SYSERR; |
1052 | } | 1063 | } |
1053 | diff_ibf = ibf_dup(op->state->local_ibf); | 1064 | diff_ibf = ibf_dup (op->state->local_ibf); |
1054 | ibf_subtract(diff_ibf, | 1065 | ibf_subtract (diff_ibf, |
1055 | op->state->remote_ibf); | 1066 | op->state->remote_ibf); |
1056 | 1067 | ||
1057 | ibf_destroy(op->state->remote_ibf); | 1068 | ibf_destroy (op->state->remote_ibf); |
1058 | op->state->remote_ibf = NULL; | 1069 | op->state->remote_ibf = NULL; |
1059 | 1070 | ||
1060 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1071 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1061 | "decoding IBF (size=%u)\n", | 1072 | "decoding IBF (size=%u)\n", |
1062 | diff_ibf->size); | 1073 | diff_ibf->size); |
1063 | 1074 | ||
1064 | num_decoded = 0; | 1075 | num_decoded = 0; |
1065 | key.key_val = 0; /* just to avoid compiler thinking we use undef'ed variable */ | 1076 | key.key_val = 0; /* just to avoid compiler thinking we use undef'ed variable */ |
1066 | 1077 | ||
1067 | while (1) | 1078 | while (1) |
1068 | { | 1079 | { |
1069 | int res; | 1080 | int res; |
1070 | int cycle_detected = GNUNET_NO; | 1081 | int cycle_detected = GNUNET_NO; |
1071 | |||
1072 | last_key = key; | ||
1073 | 1082 | ||
1074 | res = ibf_decode(diff_ibf, &side, &key); | 1083 | last_key = key; |
1075 | if (res == GNUNET_OK) | ||
1076 | { | ||
1077 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1078 | "decoded ibf key %lx\n", | ||
1079 | (unsigned long)key.key_val); | ||
1080 | num_decoded += 1; | ||
1081 | if ((num_decoded > diff_ibf->size) || | ||
1082 | ((num_decoded > 1) && | ||
1083 | (last_key.key_val == key.key_val))) | ||
1084 | { | ||
1085 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1086 | "detected cyclic ibf (decoded %u/%u)\n", | ||
1087 | num_decoded, | ||
1088 | diff_ibf->size); | ||
1089 | cycle_detected = GNUNET_YES; | ||
1090 | } | ||
1091 | } | ||
1092 | if ((GNUNET_SYSERR == res) || | ||
1093 | (GNUNET_YES == cycle_detected)) | ||
1094 | { | ||
1095 | int next_order; | ||
1096 | next_order = 0; | ||
1097 | while (1 << next_order < diff_ibf->size) | ||
1098 | next_order++; | ||
1099 | next_order++; | ||
1100 | if (next_order <= MAX_IBF_ORDER) | ||
1101 | { | ||
1102 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1103 | "decoding failed, sending larger ibf (size %u)\n", | ||
1104 | 1 << next_order); | ||
1105 | GNUNET_STATISTICS_update(_GSS_statistics, | ||
1106 | "# of IBF retries", | ||
1107 | 1, | ||
1108 | GNUNET_NO); | ||
1109 | op->state->salt_send++; | ||
1110 | if (GNUNET_OK != | ||
1111 | send_ibf(op, next_order)) | ||
1112 | { | ||
1113 | /* Internal error, best we can do is shut the connection */ | ||
1114 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
1115 | "Failed to send IBF, closing connection\n"); | ||
1116 | fail_union_operation(op); | ||
1117 | ibf_destroy(diff_ibf); | ||
1118 | return GNUNET_SYSERR; | ||
1119 | } | ||
1120 | } | ||
1121 | else | ||
1122 | { | ||
1123 | GNUNET_STATISTICS_update(_GSS_statistics, | ||
1124 | "# of failed union operations (too large)", | ||
1125 | 1, | ||
1126 | GNUNET_NO); | ||
1127 | // XXX: Send the whole set, element-by-element | ||
1128 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
1129 | "set union failed: reached ibf limit\n"); | ||
1130 | fail_union_operation(op); | ||
1131 | ibf_destroy(diff_ibf); | ||
1132 | return GNUNET_SYSERR; | ||
1133 | } | ||
1134 | break; | ||
1135 | } | ||
1136 | if (GNUNET_NO == res) | ||
1137 | { | ||
1138 | struct GNUNET_MQ_Envelope *ev; | ||
1139 | |||
1140 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1141 | "transmitted all values, sending DONE\n"); | ||
1142 | ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE); | ||
1143 | GNUNET_MQ_send(op->mq, ev); | ||
1144 | /* We now wait until we get a DONE message back | ||
1145 | * and then wait for our MQ to be flushed and all our | ||
1146 | * demands be delivered. */ | ||
1147 | break; | ||
1148 | } | ||
1149 | if (1 == side) | ||
1150 | { | ||
1151 | struct IBF_Key unsalted_key; | ||
1152 | 1084 | ||
1153 | unsalt_key(&key, | 1085 | res = ibf_decode (diff_ibf, &side, &key); |
1154 | op->state->salt_receive, | 1086 | if (res == GNUNET_OK) |
1155 | &unsalted_key); | 1087 | { |
1156 | send_offers_for_key(op, | 1088 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1157 | unsalted_key); | 1089 | "decoded ibf key %lx\n", |
1158 | } | 1090 | (unsigned long) key.key_val); |
1159 | else if (-1 == side) | 1091 | num_decoded += 1; |
1092 | if ((num_decoded > diff_ibf->size) || | ||
1093 | ((num_decoded > 1) && | ||
1094 | (last_key.key_val == key.key_val))) | ||
1095 | { | ||
1096 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1097 | "detected cyclic ibf (decoded %u/%u)\n", | ||
1098 | num_decoded, | ||
1099 | diff_ibf->size); | ||
1100 | cycle_detected = GNUNET_YES; | ||
1101 | } | ||
1102 | } | ||
1103 | if ((GNUNET_SYSERR == res) || | ||
1104 | (GNUNET_YES == cycle_detected)) | ||
1105 | { | ||
1106 | int next_order; | ||
1107 | next_order = 0; | ||
1108 | while (1 << next_order < diff_ibf->size) | ||
1109 | next_order++; | ||
1110 | next_order++; | ||
1111 | if (next_order <= MAX_IBF_ORDER) | ||
1112 | { | ||
1113 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1114 | "decoding failed, sending larger ibf (size %u)\n", | ||
1115 | 1 << next_order); | ||
1116 | GNUNET_STATISTICS_update (_GSS_statistics, | ||
1117 | "# of IBF retries", | ||
1118 | 1, | ||
1119 | GNUNET_NO); | ||
1120 | op->state->salt_send++; | ||
1121 | if (GNUNET_OK != | ||
1122 | send_ibf (op, next_order)) | ||
1160 | { | 1123 | { |
1161 | struct GNUNET_MQ_Envelope *ev; | 1124 | /* Internal error, best we can do is shut the connection */ |
1162 | struct InquiryMessage *msg; | 1125 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1163 | 1126 | "Failed to send IBF, closing connection\n"); | |
1164 | /* It may be nice to merge multiple requests, but with CADET's corking it is not worth | 1127 | fail_union_operation (op); |
1165 | * the effort additional complexity. */ | 1128 | ibf_destroy (diff_ibf); |
1166 | ev = GNUNET_MQ_msg_extra(msg, | 1129 | return GNUNET_SYSERR; |
1167 | sizeof(struct IBF_Key), | ||
1168 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY); | ||
1169 | msg->salt = htonl(op->state->salt_receive); | ||
1170 | GNUNET_memcpy(&msg[1], | ||
1171 | &key, | ||
1172 | sizeof(struct IBF_Key)); | ||
1173 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1174 | "sending element inquiry for IBF key %lx\n", | ||
1175 | (unsigned long)key.key_val); | ||
1176 | GNUNET_MQ_send(op->mq, ev); | ||
1177 | } | 1130 | } |
1131 | } | ||
1178 | else | 1132 | else |
1179 | { | 1133 | { |
1180 | GNUNET_assert(0); | 1134 | GNUNET_STATISTICS_update (_GSS_statistics, |
1181 | } | 1135 | "# of failed union operations (too large)", |
1136 | 1, | ||
1137 | GNUNET_NO); | ||
1138 | // XXX: Send the whole set, element-by-element | ||
1139 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
1140 | "set union failed: reached ibf limit\n"); | ||
1141 | fail_union_operation (op); | ||
1142 | ibf_destroy (diff_ibf); | ||
1143 | return GNUNET_SYSERR; | ||
1144 | } | ||
1145 | break; | ||
1146 | } | ||
1147 | if (GNUNET_NO == res) | ||
1148 | { | ||
1149 | struct GNUNET_MQ_Envelope *ev; | ||
1150 | |||
1151 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1152 | "transmitted all values, sending DONE\n"); | ||
1153 | ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE); | ||
1154 | GNUNET_MQ_send (op->mq, ev); | ||
1155 | /* We now wait until we get a DONE message back | ||
1156 | * and then wait for our MQ to be flushed and all our | ||
1157 | * demands be delivered. */ | ||
1158 | break; | ||
1182 | } | 1159 | } |
1183 | ibf_destroy(diff_ibf); | 1160 | if (1 == side) |
1161 | { | ||
1162 | struct IBF_Key unsalted_key; | ||
1163 | |||
1164 | unsalt_key (&key, | ||
1165 | op->state->salt_receive, | ||
1166 | &unsalted_key); | ||
1167 | send_offers_for_key (op, | ||
1168 | unsalted_key); | ||
1169 | } | ||
1170 | else if (-1 == side) | ||
1171 | { | ||
1172 | struct GNUNET_MQ_Envelope *ev; | ||
1173 | struct InquiryMessage *msg; | ||
1174 | |||
1175 | /* It may be nice to merge multiple requests, but with CADET's corking it is not worth | ||
1176 | * the effort additional complexity. */ | ||
1177 | ev = GNUNET_MQ_msg_extra (msg, | ||
1178 | sizeof(struct IBF_Key), | ||
1179 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY); | ||
1180 | msg->salt = htonl (op->state->salt_receive); | ||
1181 | GNUNET_memcpy (&msg[1], | ||
1182 | &key, | ||
1183 | sizeof(struct IBF_Key)); | ||
1184 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1185 | "sending element inquiry for IBF key %lx\n", | ||
1186 | (unsigned long) key.key_val); | ||
1187 | GNUNET_MQ_send (op->mq, ev); | ||
1188 | } | ||
1189 | else | ||
1190 | { | ||
1191 | GNUNET_assert (0); | ||
1192 | } | ||
1193 | } | ||
1194 | ibf_destroy (diff_ibf); | ||
1184 | return GNUNET_OK; | 1195 | return GNUNET_OK; |
1185 | } | 1196 | } |
1186 | 1197 | ||
@@ -1196,52 +1207,54 @@ decode_and_send(struct Operation *op) | |||
1196 | * @return #GNUNET_OK if @a msg is well-formed | 1207 | * @return #GNUNET_OK if @a msg is well-formed |
1197 | */ | 1208 | */ |
1198 | int | 1209 | int |
1199 | check_union_p2p_ibf(void *cls, | 1210 | check_union_p2p_ibf (void *cls, |
1200 | const struct IBFMessage *msg) | 1211 | const struct IBFMessage *msg) |
1201 | { | 1212 | { |
1202 | struct Operation *op = cls; | 1213 | struct Operation *op = cls; |
1203 | unsigned int buckets_in_message; | 1214 | unsigned int buckets_in_message; |
1204 | 1215 | ||
1205 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) | 1216 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) |
1206 | { | 1217 | { |
1207 | GNUNET_break_op(0); | 1218 | GNUNET_break_op (0); |
1208 | return GNUNET_SYSERR; | 1219 | return GNUNET_SYSERR; |
1209 | } | 1220 | } |
1210 | buckets_in_message = (ntohs(msg->header.size) - sizeof *msg) / IBF_BUCKET_SIZE; | 1221 | buckets_in_message = (ntohs (msg->header.size) - sizeof *msg) |
1222 | / IBF_BUCKET_SIZE; | ||
1211 | if (0 == buckets_in_message) | 1223 | if (0 == buckets_in_message) |
1224 | { | ||
1225 | GNUNET_break_op (0); | ||
1226 | return GNUNET_SYSERR; | ||
1227 | } | ||
1228 | if ((ntohs (msg->header.size) - sizeof *msg) != buckets_in_message | ||
1229 | * IBF_BUCKET_SIZE) | ||
1230 | { | ||
1231 | GNUNET_break_op (0); | ||
1232 | return GNUNET_SYSERR; | ||
1233 | } | ||
1234 | if (op->state->phase == PHASE_EXPECT_IBF_CONT) | ||
1235 | { | ||
1236 | if (ntohl (msg->offset) != op->state->ibf_buckets_received) | ||
1212 | { | 1237 | { |
1213 | GNUNET_break_op(0); | 1238 | GNUNET_break_op (0); |
1214 | return GNUNET_SYSERR; | 1239 | return GNUNET_SYSERR; |
1215 | } | 1240 | } |
1216 | if ((ntohs(msg->header.size) - sizeof *msg) != buckets_in_message * IBF_BUCKET_SIZE) | 1241 | if (1 << msg->order != op->state->remote_ibf->size) |
1217 | { | 1242 | { |
1218 | GNUNET_break_op(0); | 1243 | GNUNET_break_op (0); |
1219 | return GNUNET_SYSERR; | 1244 | return GNUNET_SYSERR; |
1220 | } | 1245 | } |
1221 | if (op->state->phase == PHASE_EXPECT_IBF_CONT) | 1246 | if (ntohl (msg->salt) != op->state->salt_receive) |
1222 | { | 1247 | { |
1223 | if (ntohl(msg->offset) != op->state->ibf_buckets_received) | 1248 | GNUNET_break_op (0); |
1224 | { | 1249 | return GNUNET_SYSERR; |
1225 | GNUNET_break_op(0); | ||
1226 | return GNUNET_SYSERR; | ||
1227 | } | ||
1228 | if (1 << msg->order != op->state->remote_ibf->size) | ||
1229 | { | ||
1230 | GNUNET_break_op(0); | ||
1231 | return GNUNET_SYSERR; | ||
1232 | } | ||
1233 | if (ntohl(msg->salt) != op->state->salt_receive) | ||
1234 | { | ||
1235 | GNUNET_break_op(0); | ||
1236 | return GNUNET_SYSERR; | ||
1237 | } | ||
1238 | } | 1250 | } |
1251 | } | ||
1239 | else if ((op->state->phase != PHASE_INVENTORY_PASSIVE) && | 1252 | else if ((op->state->phase != PHASE_INVENTORY_PASSIVE) && |
1240 | (op->state->phase != PHASE_EXPECT_IBF)) | 1253 | (op->state->phase != PHASE_EXPECT_IBF)) |
1241 | { | 1254 | { |
1242 | GNUNET_break_op(0); | 1255 | GNUNET_break_op (0); |
1243 | return GNUNET_SYSERR; | 1256 | return GNUNET_SYSERR; |
1244 | } | 1257 | } |
1245 | 1258 | ||
1246 | return GNUNET_OK; | 1259 | return GNUNET_OK; |
1247 | } | 1260 | } |
@@ -1257,71 +1270,72 @@ check_union_p2p_ibf(void *cls, | |||
1257 | * @param msg the header of the message | 1270 | * @param msg the header of the message |
1258 | */ | 1271 | */ |
1259 | void | 1272 | void |
1260 | handle_union_p2p_ibf(void *cls, | 1273 | handle_union_p2p_ibf (void *cls, |
1261 | const struct IBFMessage *msg) | 1274 | const struct IBFMessage *msg) |
1262 | { | 1275 | { |
1263 | struct Operation *op = cls; | 1276 | struct Operation *op = cls; |
1264 | unsigned int buckets_in_message; | 1277 | unsigned int buckets_in_message; |
1265 | 1278 | ||
1266 | buckets_in_message = (ntohs(msg->header.size) - sizeof *msg) / IBF_BUCKET_SIZE; | 1279 | buckets_in_message = (ntohs (msg->header.size) - sizeof *msg) |
1280 | / IBF_BUCKET_SIZE; | ||
1267 | if ((op->state->phase == PHASE_INVENTORY_PASSIVE) || | 1281 | if ((op->state->phase == PHASE_INVENTORY_PASSIVE) || |
1268 | (op->state->phase == PHASE_EXPECT_IBF)) | 1282 | (op->state->phase == PHASE_EXPECT_IBF)) |
1269 | { | 1283 | { |
1270 | op->state->phase = PHASE_EXPECT_IBF_CONT; | 1284 | op->state->phase = PHASE_EXPECT_IBF_CONT; |
1271 | GNUNET_assert(NULL == op->state->remote_ibf); | 1285 | GNUNET_assert (NULL == op->state->remote_ibf); |
1272 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1286 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1273 | "Creating new ibf of size %u\n", | 1287 | "Creating new ibf of size %u\n", |
1274 | 1 << msg->order); | 1288 | 1 << msg->order); |
1275 | op->state->remote_ibf = ibf_create(1 << msg->order, SE_IBF_HASH_NUM); | 1289 | op->state->remote_ibf = ibf_create (1 << msg->order, SE_IBF_HASH_NUM); |
1276 | op->state->salt_receive = ntohl(msg->salt); | 1290 | op->state->salt_receive = ntohl (msg->salt); |
1277 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1291 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1278 | "Receiving new IBF with salt %u\n", | 1292 | "Receiving new IBF with salt %u\n", |
1279 | op->state->salt_receive); | 1293 | op->state->salt_receive); |
1280 | if (NULL == op->state->remote_ibf) | 1294 | if (NULL == op->state->remote_ibf) |
1281 | { | 1295 | { |
1282 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 1296 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1283 | "Failed to parse remote IBF, closing connection\n"); | 1297 | "Failed to parse remote IBF, closing connection\n"); |
1284 | fail_union_operation(op); | 1298 | fail_union_operation (op); |
1285 | return; | 1299 | return; |
1286 | } | ||
1287 | op->state->ibf_buckets_received = 0; | ||
1288 | if (0 != ntohl(msg->offset)) | ||
1289 | { | ||
1290 | GNUNET_break_op(0); | ||
1291 | fail_union_operation(op); | ||
1292 | return; | ||
1293 | } | ||
1294 | } | 1300 | } |
1295 | else | 1301 | op->state->ibf_buckets_received = 0; |
1302 | if (0 != ntohl (msg->offset)) | ||
1296 | { | 1303 | { |
1297 | GNUNET_assert(op->state->phase == PHASE_EXPECT_IBF_CONT); | 1304 | GNUNET_break_op (0); |
1298 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1305 | fail_union_operation (op); |
1299 | "Received more of IBF\n"); | 1306 | return; |
1300 | } | 1307 | } |
1301 | GNUNET_assert(NULL != op->state->remote_ibf); | 1308 | } |
1309 | else | ||
1310 | { | ||
1311 | GNUNET_assert (op->state->phase == PHASE_EXPECT_IBF_CONT); | ||
1312 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1313 | "Received more of IBF\n"); | ||
1314 | } | ||
1315 | GNUNET_assert (NULL != op->state->remote_ibf); | ||
1302 | 1316 | ||
1303 | ibf_read_slice(&msg[1], | 1317 | ibf_read_slice (&msg[1], |
1304 | op->state->ibf_buckets_received, | 1318 | op->state->ibf_buckets_received, |
1305 | buckets_in_message, | 1319 | buckets_in_message, |
1306 | op->state->remote_ibf); | 1320 | op->state->remote_ibf); |
1307 | op->state->ibf_buckets_received += buckets_in_message; | 1321 | op->state->ibf_buckets_received += buckets_in_message; |
1308 | 1322 | ||
1309 | if (op->state->ibf_buckets_received == op->state->remote_ibf->size) | 1323 | if (op->state->ibf_buckets_received == op->state->remote_ibf->size) |
1310 | { | 1324 | { |
1311 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1325 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1312 | "received full ibf\n"); | 1326 | "received full ibf\n"); |
1313 | op->state->phase = PHASE_INVENTORY_ACTIVE; | 1327 | op->state->phase = PHASE_INVENTORY_ACTIVE; |
1314 | if (GNUNET_OK != | 1328 | if (GNUNET_OK != |
1315 | decode_and_send(op)) | 1329 | decode_and_send (op)) |
1316 | { | 1330 | { |
1317 | /* Internal error, best we can do is shut down */ | 1331 | /* Internal error, best we can do is shut down */ |
1318 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 1332 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1319 | "Failed to decode IBF, closing connection\n"); | 1333 | "Failed to decode IBF, closing connection\n"); |
1320 | fail_union_operation(op); | 1334 | fail_union_operation (op); |
1321 | return; | 1335 | return; |
1322 | } | ||
1323 | } | 1336 | } |
1324 | GNUNET_CADET_receive_done(op->channel); | 1337 | } |
1338 | GNUNET_CADET_receive_done (op->channel); | ||
1325 | } | 1339 | } |
1326 | 1340 | ||
1327 | 1341 | ||
@@ -1334,33 +1348,34 @@ handle_union_p2p_ibf(void *cls, | |||
1334 | * @param status status to send with the new element | 1348 | * @param status status to send with the new element |
1335 | */ | 1349 | */ |
1336 | static void | 1350 | static void |
1337 | send_client_element(struct Operation *op, | 1351 | send_client_element (struct Operation *op, |
1338 | struct GNUNET_SET_Element *element, | 1352 | struct GNUNET_SET_Element *element, |
1339 | int status) | 1353 | int status) |
1340 | { | 1354 | { |
1341 | struct GNUNET_MQ_Envelope *ev; | 1355 | struct GNUNET_MQ_Envelope *ev; |
1342 | struct GNUNET_SET_ResultMessage *rm; | 1356 | struct GNUNET_SET_ResultMessage *rm; |
1343 | 1357 | ||
1344 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1358 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1345 | "sending element (size %u) to client\n", | 1359 | "sending element (size %u) to client\n", |
1346 | element->size); | 1360 | element->size); |
1347 | GNUNET_assert(0 != op->client_request_id); | 1361 | GNUNET_assert (0 != op->client_request_id); |
1348 | ev = GNUNET_MQ_msg_extra(rm, element->size, GNUNET_MESSAGE_TYPE_SET_RESULT); | 1362 | ev = GNUNET_MQ_msg_extra (rm, element->size, GNUNET_MESSAGE_TYPE_SET_RESULT); |
1349 | if (NULL == ev) | 1363 | if (NULL == ev) |
1350 | { | 1364 | { |
1351 | GNUNET_MQ_discard(ev); | 1365 | GNUNET_MQ_discard (ev); |
1352 | GNUNET_break(0); | 1366 | GNUNET_break (0); |
1353 | return; | 1367 | return; |
1354 | } | 1368 | } |
1355 | rm->result_status = htons(status); | 1369 | rm->result_status = htons (status); |
1356 | rm->request_id = htonl(op->client_request_id); | 1370 | rm->request_id = htonl (op->client_request_id); |
1357 | rm->element_type = htons(element->element_type); | 1371 | rm->element_type = htons (element->element_type); |
1358 | rm->current_size = GNUNET_htonll(GNUNET_CONTAINER_multihashmap32_size(op->state->key_to_element)); | 1372 | rm->current_size = GNUNET_htonll (GNUNET_CONTAINER_multihashmap32_size ( |
1359 | GNUNET_memcpy(&rm[1], | 1373 | op->state->key_to_element)); |
1360 | element->data, | 1374 | GNUNET_memcpy (&rm[1], |
1361 | element->size); | 1375 | element->data, |
1362 | GNUNET_MQ_send(op->set->cs->mq, | 1376 | element->size); |
1363 | ev); | 1377 | GNUNET_MQ_send (op->set->cs->mq, |
1378 | ev); | ||
1364 | } | 1379 | } |
1365 | 1380 | ||
1366 | 1381 | ||
@@ -1371,50 +1386,51 @@ send_client_element(struct Operation *op, | |||
1371 | * @param cls operation to destroy | 1386 | * @param cls operation to destroy |
1372 | */ | 1387 | */ |
1373 | static void | 1388 | static void |
1374 | send_client_done(void *cls) | 1389 | send_client_done (void *cls) |
1375 | { | 1390 | { |
1376 | struct Operation *op = cls; | 1391 | struct Operation *op = cls; |
1377 | struct GNUNET_MQ_Envelope *ev; | 1392 | struct GNUNET_MQ_Envelope *ev; |
1378 | struct GNUNET_SET_ResultMessage *rm; | 1393 | struct GNUNET_SET_ResultMessage *rm; |
1379 | 1394 | ||
1380 | if (GNUNET_YES == op->state->client_done_sent) | 1395 | if (GNUNET_YES == op->state->client_done_sent) |
1381 | { | 1396 | { |
1382 | return; | 1397 | return; |
1383 | } | 1398 | } |
1384 | 1399 | ||
1385 | if (PHASE_DONE != op->state->phase) | 1400 | if (PHASE_DONE != op->state->phase) |
1386 | { | 1401 | { |
1387 | LOG(GNUNET_ERROR_TYPE_WARNING, | 1402 | LOG (GNUNET_ERROR_TYPE_WARNING, |
1388 | "Union operation failed\n"); | 1403 | "Union operation failed\n"); |
1389 | GNUNET_STATISTICS_update(_GSS_statistics, | 1404 | GNUNET_STATISTICS_update (_GSS_statistics, |
1390 | "# Union operations failed", | 1405 | "# Union operations failed", |
1391 | 1, | 1406 | 1, |
1392 | GNUNET_NO); | 1407 | GNUNET_NO); |
1393 | ev = GNUNET_MQ_msg(rm, GNUNET_MESSAGE_TYPE_SET_RESULT); | 1408 | ev = GNUNET_MQ_msg (rm, GNUNET_MESSAGE_TYPE_SET_RESULT); |
1394 | rm->result_status = htons(GNUNET_SET_STATUS_FAILURE); | 1409 | rm->result_status = htons (GNUNET_SET_STATUS_FAILURE); |
1395 | rm->request_id = htonl(op->client_request_id); | 1410 | rm->request_id = htonl (op->client_request_id); |
1396 | rm->element_type = htons(0); | 1411 | rm->element_type = htons (0); |
1397 | GNUNET_MQ_send(op->set->cs->mq, | 1412 | GNUNET_MQ_send (op->set->cs->mq, |
1398 | ev); | 1413 | ev); |
1399 | return; | 1414 | return; |
1400 | } | 1415 | } |
1401 | 1416 | ||
1402 | op->state->client_done_sent = GNUNET_YES; | 1417 | op->state->client_done_sent = GNUNET_YES; |
1403 | 1418 | ||
1404 | GNUNET_STATISTICS_update(_GSS_statistics, | 1419 | GNUNET_STATISTICS_update (_GSS_statistics, |
1405 | "# Union operations succeeded", | 1420 | "# Union operations succeeded", |
1406 | 1, | 1421 | 1, |
1407 | GNUNET_NO); | 1422 | GNUNET_NO); |
1408 | LOG(GNUNET_ERROR_TYPE_INFO, | 1423 | LOG (GNUNET_ERROR_TYPE_INFO, |
1409 | "Signalling client that union operation is done\n"); | 1424 | "Signalling client that union operation is done\n"); |
1410 | ev = GNUNET_MQ_msg(rm, | 1425 | ev = GNUNET_MQ_msg (rm, |
1411 | GNUNET_MESSAGE_TYPE_SET_RESULT); | 1426 | GNUNET_MESSAGE_TYPE_SET_RESULT); |
1412 | rm->request_id = htonl(op->client_request_id); | 1427 | rm->request_id = htonl (op->client_request_id); |
1413 | rm->result_status = htons(GNUNET_SET_STATUS_DONE); | 1428 | rm->result_status = htons (GNUNET_SET_STATUS_DONE); |
1414 | rm->element_type = htons(0); | 1429 | rm->element_type = htons (0); |
1415 | rm->current_size = GNUNET_htonll(GNUNET_CONTAINER_multihashmap32_size(op->state->key_to_element)); | 1430 | rm->current_size = GNUNET_htonll (GNUNET_CONTAINER_multihashmap32_size ( |
1416 | GNUNET_MQ_send(op->set->cs->mq, | 1431 | op->state->key_to_element)); |
1417 | ev); | 1432 | GNUNET_MQ_send (op->set->cs->mq, |
1433 | ev); | ||
1418 | } | 1434 | } |
1419 | 1435 | ||
1420 | 1436 | ||
@@ -1424,41 +1440,42 @@ send_client_done(void *cls) | |||
1424 | * @param op operation to check | 1440 | * @param op operation to check |
1425 | */ | 1441 | */ |
1426 | static void | 1442 | static void |
1427 | maybe_finish(struct Operation *op) | 1443 | maybe_finish (struct Operation *op) |
1428 | { | 1444 | { |
1429 | unsigned int num_demanded; | 1445 | unsigned int num_demanded; |
1430 | 1446 | ||
1431 | num_demanded = GNUNET_CONTAINER_multihashmap_size(op->state->demanded_hashes); | 1447 | num_demanded = GNUNET_CONTAINER_multihashmap_size ( |
1448 | op->state->demanded_hashes); | ||
1432 | 1449 | ||
1433 | if (PHASE_FINISH_WAITING == op->state->phase) | 1450 | if (PHASE_FINISH_WAITING == op->state->phase) |
1451 | { | ||
1452 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1453 | "In PHASE_FINISH_WAITING, pending %u demands\n", | ||
1454 | num_demanded); | ||
1455 | if (0 == num_demanded) | ||
1434 | { | 1456 | { |
1435 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1457 | struct GNUNET_MQ_Envelope *ev; |
1436 | "In PHASE_FINISH_WAITING, pending %u demands\n", | 1458 | |
1437 | num_demanded); | 1459 | op->state->phase = PHASE_DONE; |
1438 | if (0 == num_demanded) | 1460 | ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE); |
1439 | { | 1461 | GNUNET_MQ_send (op->mq, |
1440 | struct GNUNET_MQ_Envelope *ev; | 1462 | ev); |
1441 | 1463 | /* We now wait until the other peer sends P2P_OVER | |
1442 | op->state->phase = PHASE_DONE; | 1464 | * after it got all elements from us. */ |
1443 | ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE); | ||
1444 | GNUNET_MQ_send(op->mq, | ||
1445 | ev); | ||
1446 | /* We now wait until the other peer sends P2P_OVER | ||
1447 | * after it got all elements from us. */ | ||
1448 | } | ||
1449 | } | 1465 | } |
1466 | } | ||
1450 | if (PHASE_FINISH_CLOSING == op->state->phase) | 1467 | if (PHASE_FINISH_CLOSING == op->state->phase) |
1468 | { | ||
1469 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1470 | "In PHASE_FINISH_CLOSING, pending %u demands\n", | ||
1471 | num_demanded); | ||
1472 | if (0 == num_demanded) | ||
1451 | { | 1473 | { |
1452 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1474 | op->state->phase = PHASE_DONE; |
1453 | "In PHASE_FINISH_CLOSING, pending %u demands\n", | 1475 | send_client_done (op); |
1454 | num_demanded); | 1476 | _GSS_operation_destroy2 (op); |
1455 | if (0 == num_demanded) | ||
1456 | { | ||
1457 | op->state->phase = PHASE_DONE; | ||
1458 | send_client_done(op); | ||
1459 | _GSS_operation_destroy2(op); | ||
1460 | } | ||
1461 | } | 1477 | } |
1478 | } | ||
1462 | } | 1479 | } |
1463 | 1480 | ||
1464 | 1481 | ||
@@ -1469,21 +1486,21 @@ maybe_finish(struct Operation *op) | |||
1469 | * @param emsg the message | 1486 | * @param emsg the message |
1470 | */ | 1487 | */ |
1471 | int | 1488 | int |
1472 | check_union_p2p_elements(void *cls, | 1489 | check_union_p2p_elements (void *cls, |
1473 | const struct GNUNET_SET_ElementMessage *emsg) | 1490 | const struct GNUNET_SET_ElementMessage *emsg) |
1474 | { | 1491 | { |
1475 | struct Operation *op = cls; | 1492 | struct Operation *op = cls; |
1476 | 1493 | ||
1477 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) | 1494 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) |
1478 | { | 1495 | { |
1479 | GNUNET_break_op(0); | 1496 | GNUNET_break_op (0); |
1480 | return GNUNET_SYSERR; | 1497 | return GNUNET_SYSERR; |
1481 | } | 1498 | } |
1482 | if (0 == GNUNET_CONTAINER_multihashmap_size(op->state->demanded_hashes)) | 1499 | if (0 == GNUNET_CONTAINER_multihashmap_size (op->state->demanded_hashes)) |
1483 | { | 1500 | { |
1484 | GNUNET_break_op(0); | 1501 | GNUNET_break_op (0); |
1485 | return GNUNET_SYSERR; | 1502 | return GNUNET_SYSERR; |
1486 | } | 1503 | } |
1487 | return GNUNET_OK; | 1504 | return GNUNET_OK; |
1488 | } | 1505 | } |
1489 | 1506 | ||
@@ -1497,98 +1514,99 @@ check_union_p2p_elements(void *cls, | |||
1497 | * @param emsg the message | 1514 | * @param emsg the message |
1498 | */ | 1515 | */ |
1499 | void | 1516 | void |
1500 | handle_union_p2p_elements(void *cls, | 1517 | handle_union_p2p_elements (void *cls, |
1501 | const struct GNUNET_SET_ElementMessage *emsg) | 1518 | const struct GNUNET_SET_ElementMessage *emsg) |
1502 | { | 1519 | { |
1503 | struct Operation *op = cls; | 1520 | struct Operation *op = cls; |
1504 | struct ElementEntry *ee; | 1521 | struct ElementEntry *ee; |
1505 | struct KeyEntry *ke; | 1522 | struct KeyEntry *ke; |
1506 | uint16_t element_size; | 1523 | uint16_t element_size; |
1507 | 1524 | ||
1508 | element_size = ntohs(emsg->header.size) - sizeof(struct GNUNET_SET_ElementMessage); | 1525 | element_size = ntohs (emsg->header.size) - sizeof(struct |
1509 | ee = GNUNET_malloc(sizeof(struct ElementEntry) + element_size); | 1526 | GNUNET_SET_ElementMessage); |
1510 | GNUNET_memcpy(&ee[1], | 1527 | ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size); |
1511 | &emsg[1], | 1528 | GNUNET_memcpy (&ee[1], |
1512 | element_size); | 1529 | &emsg[1], |
1530 | element_size); | ||
1513 | ee->element.size = element_size; | 1531 | ee->element.size = element_size; |
1514 | ee->element.data = &ee[1]; | 1532 | ee->element.data = &ee[1]; |
1515 | ee->element.element_type = ntohs(emsg->element_type); | 1533 | ee->element.element_type = ntohs (emsg->element_type); |
1516 | ee->remote = GNUNET_YES; | 1534 | ee->remote = GNUNET_YES; |
1517 | GNUNET_SET_element_hash(&ee->element, | 1535 | GNUNET_SET_element_hash (&ee->element, |
1518 | &ee->element_hash); | 1536 | &ee->element_hash); |
1519 | if (GNUNET_NO == | 1537 | if (GNUNET_NO == |
1520 | GNUNET_CONTAINER_multihashmap_remove(op->state->demanded_hashes, | 1538 | GNUNET_CONTAINER_multihashmap_remove (op->state->demanded_hashes, |
1521 | &ee->element_hash, | 1539 | &ee->element_hash, |
1522 | NULL)) | 1540 | NULL)) |
1523 | { | 1541 | { |
1524 | /* We got something we didn't demand, since it's not in our map. */ | 1542 | /* We got something we didn't demand, since it's not in our map. */ |
1525 | GNUNET_break_op(0); | 1543 | GNUNET_break_op (0); |
1526 | fail_union_operation(op); | 1544 | fail_union_operation (op); |
1527 | return; | 1545 | return; |
1528 | } | 1546 | } |
1529 | 1547 | ||
1530 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1548 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1531 | "Got element (size %u, hash %s) from peer\n", | 1549 | "Got element (size %u, hash %s) from peer\n", |
1532 | (unsigned int)element_size, | 1550 | (unsigned int) element_size, |
1533 | GNUNET_h2s(&ee->element_hash)); | 1551 | GNUNET_h2s (&ee->element_hash)); |
1534 | 1552 | ||
1535 | GNUNET_STATISTICS_update(_GSS_statistics, | 1553 | GNUNET_STATISTICS_update (_GSS_statistics, |
1536 | "# received elements", | 1554 | "# received elements", |
1537 | 1, | 1555 | 1, |
1538 | GNUNET_NO); | 1556 | GNUNET_NO); |
1539 | GNUNET_STATISTICS_update(_GSS_statistics, | 1557 | GNUNET_STATISTICS_update (_GSS_statistics, |
1540 | "# exchanged elements", | 1558 | "# exchanged elements", |
1541 | 1, | 1559 | 1, |
1542 | GNUNET_NO); | 1560 | GNUNET_NO); |
1543 | 1561 | ||
1544 | op->state->received_total++; | 1562 | op->state->received_total++; |
1545 | 1563 | ||
1546 | ke = op_get_element(op, &ee->element_hash); | 1564 | ke = op_get_element (op, &ee->element_hash); |
1547 | if (NULL != ke) | 1565 | if (NULL != ke) |
1548 | { | 1566 | { |
1549 | /* Got repeated element. Should not happen since | 1567 | /* Got repeated element. Should not happen since |
1550 | * we track demands. */ | 1568 | * we track demands. */ |
1551 | GNUNET_STATISTICS_update(_GSS_statistics, | 1569 | GNUNET_STATISTICS_update (_GSS_statistics, |
1552 | "# repeated elements", | 1570 | "# repeated elements", |
1553 | 1, | 1571 | 1, |
1554 | GNUNET_NO); | 1572 | GNUNET_NO); |
1555 | ke->received = GNUNET_YES; | 1573 | ke->received = GNUNET_YES; |
1556 | GNUNET_free(ee); | 1574 | GNUNET_free (ee); |
1557 | } | 1575 | } |
1558 | else | 1576 | else |
1577 | { | ||
1578 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1579 | "Registering new element from remote peer\n"); | ||
1580 | op->state->received_fresh++; | ||
1581 | op_register_element (op, ee, GNUNET_YES); | ||
1582 | /* only send results immediately if the client wants it */ | ||
1583 | switch (op->result_mode) | ||
1559 | { | 1584 | { |
1560 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1585 | case GNUNET_SET_RESULT_ADDED: |
1561 | "Registering new element from remote peer\n"); | 1586 | send_client_element (op, &ee->element, GNUNET_SET_STATUS_OK); |
1562 | op->state->received_fresh++; | 1587 | break; |
1563 | op_register_element(op, ee, GNUNET_YES); | 1588 | |
1564 | /* only send results immediately if the client wants it */ | 1589 | case GNUNET_SET_RESULT_SYMMETRIC: |
1565 | switch (op->result_mode) | 1590 | send_client_element (op, &ee->element, GNUNET_SET_STATUS_ADD_LOCAL); |
1566 | { | 1591 | break; |
1567 | case GNUNET_SET_RESULT_ADDED: | 1592 | |
1568 | send_client_element(op, &ee->element, GNUNET_SET_STATUS_OK); | 1593 | default: |
1569 | break; | 1594 | /* Result mode not supported, should have been caught earlier. */ |
1570 | 1595 | GNUNET_break (0); | |
1571 | case GNUNET_SET_RESULT_SYMMETRIC: | 1596 | break; |
1572 | send_client_element(op, &ee->element, GNUNET_SET_STATUS_ADD_LOCAL); | ||
1573 | break; | ||
1574 | |||
1575 | default: | ||
1576 | /* Result mode not supported, should have been caught earlier. */ | ||
1577 | GNUNET_break(0); | ||
1578 | break; | ||
1579 | } | ||
1580 | } | 1597 | } |
1598 | } | ||
1581 | 1599 | ||
1582 | if ((op->state->received_total > 8) && | 1600 | if ((op->state->received_total > 8) && |
1583 | (op->state->received_fresh < op->state->received_total / 3)) | 1601 | (op->state->received_fresh < op->state->received_total / 3)) |
1584 | { | 1602 | { |
1585 | /* The other peer gave us lots of old elements, there's something wrong. */ | 1603 | /* The other peer gave us lots of old elements, there's something wrong. */ |
1586 | GNUNET_break_op(0); | 1604 | GNUNET_break_op (0); |
1587 | fail_union_operation(op); | 1605 | fail_union_operation (op); |
1588 | return; | 1606 | return; |
1589 | } | 1607 | } |
1590 | GNUNET_CADET_receive_done(op->channel); | 1608 | GNUNET_CADET_receive_done (op->channel); |
1591 | maybe_finish(op); | 1609 | maybe_finish (op); |
1592 | } | 1610 | } |
1593 | 1611 | ||
1594 | 1612 | ||
@@ -1599,16 +1617,16 @@ handle_union_p2p_elements(void *cls, | |||
1599 | * @param emsg the message | 1617 | * @param emsg the message |
1600 | */ | 1618 | */ |
1601 | int | 1619 | int |
1602 | check_union_p2p_full_element(void *cls, | 1620 | check_union_p2p_full_element (void *cls, |
1603 | const struct GNUNET_SET_ElementMessage *emsg) | 1621 | const struct GNUNET_SET_ElementMessage *emsg) |
1604 | { | 1622 | { |
1605 | struct Operation *op = cls; | 1623 | struct Operation *op = cls; |
1606 | 1624 | ||
1607 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) | 1625 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) |
1608 | { | 1626 | { |
1609 | GNUNET_break_op(0); | 1627 | GNUNET_break_op (0); |
1610 | return GNUNET_SYSERR; | 1628 | return GNUNET_SYSERR; |
1611 | } | 1629 | } |
1612 | // FIXME: check that we expect full elements here? | 1630 | // FIXME: check that we expect full elements here? |
1613 | return GNUNET_OK; | 1631 | return GNUNET_OK; |
1614 | } | 1632 | } |
@@ -1621,89 +1639,90 @@ check_union_p2p_full_element(void *cls, | |||
1621 | * @param emsg the message | 1639 | * @param emsg the message |
1622 | */ | 1640 | */ |
1623 | void | 1641 | void |
1624 | handle_union_p2p_full_element(void *cls, | 1642 | handle_union_p2p_full_element (void *cls, |
1625 | const struct GNUNET_SET_ElementMessage *emsg) | 1643 | const struct GNUNET_SET_ElementMessage *emsg) |
1626 | { | 1644 | { |
1627 | struct Operation *op = cls; | 1645 | struct Operation *op = cls; |
1628 | struct ElementEntry *ee; | 1646 | struct ElementEntry *ee; |
1629 | struct KeyEntry *ke; | 1647 | struct KeyEntry *ke; |
1630 | uint16_t element_size; | 1648 | uint16_t element_size; |
1631 | 1649 | ||
1632 | element_size = ntohs(emsg->header.size) - sizeof(struct GNUNET_SET_ElementMessage); | 1650 | element_size = ntohs (emsg->header.size) - sizeof(struct |
1633 | ee = GNUNET_malloc(sizeof(struct ElementEntry) + element_size); | 1651 | GNUNET_SET_ElementMessage); |
1634 | GNUNET_memcpy(&ee[1], &emsg[1], element_size); | 1652 | ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size); |
1653 | GNUNET_memcpy (&ee[1], &emsg[1], element_size); | ||
1635 | ee->element.size = element_size; | 1654 | ee->element.size = element_size; |
1636 | ee->element.data = &ee[1]; | 1655 | ee->element.data = &ee[1]; |
1637 | ee->element.element_type = ntohs(emsg->element_type); | 1656 | ee->element.element_type = ntohs (emsg->element_type); |
1638 | ee->remote = GNUNET_YES; | 1657 | ee->remote = GNUNET_YES; |
1639 | GNUNET_SET_element_hash(&ee->element, &ee->element_hash); | 1658 | GNUNET_SET_element_hash (&ee->element, &ee->element_hash); |
1640 | 1659 | ||
1641 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1660 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1642 | "Got element (full diff, size %u, hash %s) from peer\n", | 1661 | "Got element (full diff, size %u, hash %s) from peer\n", |
1643 | (unsigned int)element_size, | 1662 | (unsigned int) element_size, |
1644 | GNUNET_h2s(&ee->element_hash)); | 1663 | GNUNET_h2s (&ee->element_hash)); |
1645 | 1664 | ||
1646 | GNUNET_STATISTICS_update(_GSS_statistics, | 1665 | GNUNET_STATISTICS_update (_GSS_statistics, |
1647 | "# received elements", | 1666 | "# received elements", |
1648 | 1, | 1667 | 1, |
1649 | GNUNET_NO); | 1668 | GNUNET_NO); |
1650 | GNUNET_STATISTICS_update(_GSS_statistics, | 1669 | GNUNET_STATISTICS_update (_GSS_statistics, |
1651 | "# exchanged elements", | 1670 | "# exchanged elements", |
1652 | 1, | 1671 | 1, |
1653 | GNUNET_NO); | 1672 | GNUNET_NO); |
1654 | 1673 | ||
1655 | op->state->received_total++; | 1674 | op->state->received_total++; |
1656 | 1675 | ||
1657 | ke = op_get_element(op, &ee->element_hash); | 1676 | ke = op_get_element (op, &ee->element_hash); |
1658 | if (NULL != ke) | 1677 | if (NULL != ke) |
1659 | { | 1678 | { |
1660 | /* Got repeated element. Should not happen since | 1679 | /* Got repeated element. Should not happen since |
1661 | * we track demands. */ | 1680 | * we track demands. */ |
1662 | GNUNET_STATISTICS_update(_GSS_statistics, | 1681 | GNUNET_STATISTICS_update (_GSS_statistics, |
1663 | "# repeated elements", | 1682 | "# repeated elements", |
1664 | 1, | 1683 | 1, |
1665 | GNUNET_NO); | 1684 | GNUNET_NO); |
1666 | ke->received = GNUNET_YES; | 1685 | ke->received = GNUNET_YES; |
1667 | GNUNET_free(ee); | 1686 | GNUNET_free (ee); |
1668 | } | 1687 | } |
1669 | else | 1688 | else |
1689 | { | ||
1690 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
1691 | "Registering new element from remote peer\n"); | ||
1692 | op->state->received_fresh++; | ||
1693 | op_register_element (op, ee, GNUNET_YES); | ||
1694 | /* only send results immediately if the client wants it */ | ||
1695 | switch (op->result_mode) | ||
1670 | { | 1696 | { |
1671 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1697 | case GNUNET_SET_RESULT_ADDED: |
1672 | "Registering new element from remote peer\n"); | 1698 | send_client_element (op, &ee->element, GNUNET_SET_STATUS_OK); |
1673 | op->state->received_fresh++; | 1699 | break; |
1674 | op_register_element(op, ee, GNUNET_YES); | 1700 | |
1675 | /* only send results immediately if the client wants it */ | 1701 | case GNUNET_SET_RESULT_SYMMETRIC: |
1676 | switch (op->result_mode) | 1702 | send_client_element (op, &ee->element, GNUNET_SET_STATUS_ADD_LOCAL); |
1677 | { | 1703 | break; |
1678 | case GNUNET_SET_RESULT_ADDED: | 1704 | |
1679 | send_client_element(op, &ee->element, GNUNET_SET_STATUS_OK); | 1705 | default: |
1680 | break; | 1706 | /* Result mode not supported, should have been caught earlier. */ |
1681 | 1707 | GNUNET_break (0); | |
1682 | case GNUNET_SET_RESULT_SYMMETRIC: | 1708 | break; |
1683 | send_client_element(op, &ee->element, GNUNET_SET_STATUS_ADD_LOCAL); | ||
1684 | break; | ||
1685 | |||
1686 | default: | ||
1687 | /* Result mode not supported, should have been caught earlier. */ | ||
1688 | GNUNET_break(0); | ||
1689 | break; | ||
1690 | } | ||
1691 | } | 1709 | } |
1710 | } | ||
1692 | 1711 | ||
1693 | if ((GNUNET_YES == op->byzantine) && | 1712 | if ((GNUNET_YES == op->byzantine) && |
1694 | (op->state->received_total > 384 + op->state->received_fresh * 4) && | 1713 | (op->state->received_total > 384 + op->state->received_fresh * 4) && |
1695 | (op->state->received_fresh < op->state->received_total / 6)) | 1714 | (op->state->received_fresh < op->state->received_total / 6)) |
1696 | { | 1715 | { |
1697 | /* The other peer gave us lots of old elements, there's something wrong. */ | 1716 | /* The other peer gave us lots of old elements, there's something wrong. */ |
1698 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1717 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1699 | "Other peer sent only %llu/%llu fresh elements, failing operation\n", | 1718 | "Other peer sent only %llu/%llu fresh elements, failing operation\n", |
1700 | (unsigned long long)op->state->received_fresh, | 1719 | (unsigned long long) op->state->received_fresh, |
1701 | (unsigned long long)op->state->received_total); | 1720 | (unsigned long long) op->state->received_total); |
1702 | GNUNET_break_op(0); | 1721 | GNUNET_break_op (0); |
1703 | fail_union_operation(op); | 1722 | fail_union_operation (op); |
1704 | return; | 1723 | return; |
1705 | } | 1724 | } |
1706 | GNUNET_CADET_receive_done(op->channel); | 1725 | GNUNET_CADET_receive_done (op->channel); |
1707 | } | 1726 | } |
1708 | 1727 | ||
1709 | 1728 | ||
@@ -1715,30 +1734,30 @@ handle_union_p2p_full_element(void *cls, | |||
1715 | * @param msg the message | 1734 | * @param msg the message |
1716 | */ | 1735 | */ |
1717 | int | 1736 | int |
1718 | check_union_p2p_inquiry(void *cls, | 1737 | check_union_p2p_inquiry (void *cls, |
1719 | const struct InquiryMessage *msg) | 1738 | const struct InquiryMessage *msg) |
1720 | { | 1739 | { |
1721 | struct Operation *op = cls; | 1740 | struct Operation *op = cls; |
1722 | unsigned int num_keys; | 1741 | unsigned int num_keys; |
1723 | 1742 | ||
1724 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) | 1743 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) |
1725 | { | 1744 | { |
1726 | GNUNET_break_op(0); | 1745 | GNUNET_break_op (0); |
1727 | return GNUNET_SYSERR; | 1746 | return GNUNET_SYSERR; |
1728 | } | 1747 | } |
1729 | if (op->state->phase != PHASE_INVENTORY_PASSIVE) | 1748 | if (op->state->phase != PHASE_INVENTORY_PASSIVE) |
1730 | { | 1749 | { |
1731 | GNUNET_break_op(0); | 1750 | GNUNET_break_op (0); |
1732 | return GNUNET_SYSERR; | 1751 | return GNUNET_SYSERR; |
1733 | } | 1752 | } |
1734 | num_keys = (ntohs(msg->header.size) - sizeof(struct InquiryMessage)) | 1753 | num_keys = (ntohs (msg->header.size) - sizeof(struct InquiryMessage)) |
1735 | / sizeof(struct IBF_Key); | 1754 | / sizeof(struct IBF_Key); |
1736 | if ((ntohs(msg->header.size) - sizeof(struct InquiryMessage)) | 1755 | if ((ntohs (msg->header.size) - sizeof(struct InquiryMessage)) |
1737 | != num_keys * sizeof(struct IBF_Key)) | 1756 | != num_keys * sizeof(struct IBF_Key)) |
1738 | { | 1757 | { |
1739 | GNUNET_break_op(0); | 1758 | GNUNET_break_op (0); |
1740 | return GNUNET_SYSERR; | 1759 | return GNUNET_SYSERR; |
1741 | } | 1760 | } |
1742 | return GNUNET_OK; | 1761 | return GNUNET_OK; |
1743 | } | 1762 | } |
1744 | 1763 | ||
@@ -1751,30 +1770,30 @@ check_union_p2p_inquiry(void *cls, | |||
1751 | * @param msg the message | 1770 | * @param msg the message |
1752 | */ | 1771 | */ |
1753 | void | 1772 | void |
1754 | handle_union_p2p_inquiry(void *cls, | 1773 | handle_union_p2p_inquiry (void *cls, |
1755 | const struct InquiryMessage *msg) | 1774 | const struct InquiryMessage *msg) |
1756 | { | 1775 | { |
1757 | struct Operation *op = cls; | 1776 | struct Operation *op = cls; |
1758 | const struct IBF_Key *ibf_key; | 1777 | const struct IBF_Key *ibf_key; |
1759 | unsigned int num_keys; | 1778 | unsigned int num_keys; |
1760 | 1779 | ||
1761 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1780 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1762 | "Received union inquiry\n"); | 1781 | "Received union inquiry\n"); |
1763 | num_keys = (ntohs(msg->header.size) - sizeof(struct InquiryMessage)) | 1782 | num_keys = (ntohs (msg->header.size) - sizeof(struct InquiryMessage)) |
1764 | / sizeof(struct IBF_Key); | 1783 | / sizeof(struct IBF_Key); |
1765 | ibf_key = (const struct IBF_Key *)&msg[1]; | 1784 | ibf_key = (const struct IBF_Key *) &msg[1]; |
1766 | while (0 != num_keys--) | 1785 | while (0 != num_keys--) |
1767 | { | 1786 | { |
1768 | struct IBF_Key unsalted_key; | 1787 | struct IBF_Key unsalted_key; |
1769 | 1788 | ||
1770 | unsalt_key(ibf_key, | 1789 | unsalt_key (ibf_key, |
1771 | ntohl(msg->salt), | 1790 | ntohl (msg->salt), |
1772 | &unsalted_key); | 1791 | &unsalted_key); |
1773 | send_offers_for_key(op, | 1792 | send_offers_for_key (op, |
1774 | unsalted_key); | 1793 | unsalted_key); |
1775 | ibf_key++; | 1794 | ibf_key++; |
1776 | } | 1795 | } |
1777 | GNUNET_CADET_receive_done(op->channel); | 1796 | GNUNET_CADET_receive_done (op->channel); |
1778 | } | 1797 | } |
1779 | 1798 | ||
1780 | 1799 | ||
@@ -1789,9 +1808,9 @@ handle_union_p2p_inquiry(void *cls, | |||
1789 | * #GNUNET_NO if not. | 1808 | * #GNUNET_NO if not. |
1790 | */ | 1809 | */ |
1791 | static int | 1810 | static int |
1792 | send_missing_full_elements_iter(void *cls, | 1811 | send_missing_full_elements_iter (void *cls, |
1793 | uint32_t key, | 1812 | uint32_t key, |
1794 | void *value) | 1813 | void *value) |
1795 | { | 1814 | { |
1796 | struct Operation *op = cls; | 1815 | struct Operation *op = cls; |
1797 | struct KeyEntry *ke = value; | 1816 | struct KeyEntry *ke = value; |
@@ -1801,15 +1820,15 @@ send_missing_full_elements_iter(void *cls, | |||
1801 | 1820 | ||
1802 | if (GNUNET_YES == ke->received) | 1821 | if (GNUNET_YES == ke->received) |
1803 | return GNUNET_YES; | 1822 | return GNUNET_YES; |
1804 | ev = GNUNET_MQ_msg_extra(emsg, | 1823 | ev = GNUNET_MQ_msg_extra (emsg, |
1805 | ee->element.size, | 1824 | ee->element.size, |
1806 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT); | 1825 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT); |
1807 | GNUNET_memcpy(&emsg[1], | 1826 | GNUNET_memcpy (&emsg[1], |
1808 | ee->element.data, | 1827 | ee->element.data, |
1809 | ee->element.size); | 1828 | ee->element.size); |
1810 | emsg->element_type = htons(ee->element.element_type); | 1829 | emsg->element_type = htons (ee->element.element_type); |
1811 | GNUNET_MQ_send(op->mq, | 1830 | GNUNET_MQ_send (op->mq, |
1812 | ev); | 1831 | ev); |
1813 | return GNUNET_YES; | 1832 | return GNUNET_YES; |
1814 | } | 1833 | } |
1815 | 1834 | ||
@@ -1821,30 +1840,30 @@ send_missing_full_elements_iter(void *cls, | |||
1821 | * @param mh the demand message | 1840 | * @param mh the demand message |
1822 | */ | 1841 | */ |
1823 | void | 1842 | void |
1824 | handle_union_p2p_request_full(void *cls, | 1843 | handle_union_p2p_request_full (void *cls, |
1825 | const struct GNUNET_MessageHeader *mh) | 1844 | const struct GNUNET_MessageHeader *mh) |
1826 | { | 1845 | { |
1827 | struct Operation *op = cls; | 1846 | struct Operation *op = cls; |
1828 | 1847 | ||
1829 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1848 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1830 | "Received request for full set transmission\n"); | 1849 | "Received request for full set transmission\n"); |
1831 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) | 1850 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) |
1832 | { | 1851 | { |
1833 | GNUNET_break_op(0); | 1852 | GNUNET_break_op (0); |
1834 | fail_union_operation(op); | 1853 | fail_union_operation (op); |
1835 | return; | 1854 | return; |
1836 | } | 1855 | } |
1837 | if (PHASE_EXPECT_IBF != op->state->phase) | 1856 | if (PHASE_EXPECT_IBF != op->state->phase) |
1838 | { | 1857 | { |
1839 | GNUNET_break_op(0); | 1858 | GNUNET_break_op (0); |
1840 | fail_union_operation(op); | 1859 | fail_union_operation (op); |
1841 | return; | 1860 | return; |
1842 | } | 1861 | } |
1843 | 1862 | ||
1844 | // FIXME: we need to check that our set is larger than the | 1863 | // FIXME: we need to check that our set is larger than the |
1845 | // byzantine_lower_bound by some threshold | 1864 | // byzantine_lower_bound by some threshold |
1846 | send_full_set(op); | 1865 | send_full_set (op); |
1847 | GNUNET_CADET_receive_done(op->channel); | 1866 | GNUNET_CADET_receive_done (op->channel); |
1848 | } | 1867 | } |
1849 | 1868 | ||
1850 | 1869 | ||
@@ -1855,55 +1874,55 @@ handle_union_p2p_request_full(void *cls, | |||
1855 | * @param mh the demand message | 1874 | * @param mh the demand message |
1856 | */ | 1875 | */ |
1857 | void | 1876 | void |
1858 | handle_union_p2p_full_done(void *cls, | 1877 | handle_union_p2p_full_done (void *cls, |
1859 | const struct GNUNET_MessageHeader *mh) | 1878 | const struct GNUNET_MessageHeader *mh) |
1860 | { | 1879 | { |
1861 | struct Operation *op = cls; | 1880 | struct Operation *op = cls; |
1862 | 1881 | ||
1863 | switch (op->state->phase) | 1882 | switch (op->state->phase) |
1864 | { | 1883 | { |
1865 | case PHASE_EXPECT_IBF: | 1884 | case PHASE_EXPECT_IBF: |
1866 | { | 1885 | { |
1867 | struct GNUNET_MQ_Envelope *ev; | 1886 | struct GNUNET_MQ_Envelope *ev; |
1868 | 1887 | ||
1869 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1888 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1870 | "got FULL DONE, sending elements that other peer is missing\n"); | 1889 | "got FULL DONE, sending elements that other peer is missing\n"); |
1871 | 1890 | ||
1872 | /* send all the elements that did not come from the remote peer */ | 1891 | /* send all the elements that did not come from the remote peer */ |
1873 | GNUNET_CONTAINER_multihashmap32_iterate(op->state->key_to_element, | 1892 | GNUNET_CONTAINER_multihashmap32_iterate (op->state->key_to_element, |
1874 | &send_missing_full_elements_iter, | 1893 | &send_missing_full_elements_iter, |
1875 | op); | 1894 | op); |
1876 | 1895 | ||
1877 | ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE); | 1896 | ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE); |
1878 | GNUNET_MQ_send(op->mq, | 1897 | GNUNET_MQ_send (op->mq, |
1879 | ev); | 1898 | ev); |
1880 | op->state->phase = PHASE_DONE; | 1899 | op->state->phase = PHASE_DONE; |
1881 | /* we now wait until the other peer sends us the OVER message*/ | 1900 | /* we now wait until the other peer sends us the OVER message*/ |
1882 | } | 1901 | } |
1883 | break; | 1902 | break; |
1884 | 1903 | ||
1885 | case PHASE_FULL_SENDING: | 1904 | case PHASE_FULL_SENDING: |
1886 | { | 1905 | { |
1887 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1906 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1888 | "got FULL DONE, finishing\n"); | 1907 | "got FULL DONE, finishing\n"); |
1889 | /* We sent the full set, and got the response for that. We're done. */ | 1908 | /* We sent the full set, and got the response for that. We're done. */ |
1890 | op->state->phase = PHASE_DONE; | 1909 | op->state->phase = PHASE_DONE; |
1891 | GNUNET_CADET_receive_done(op->channel); | 1910 | GNUNET_CADET_receive_done (op->channel); |
1892 | send_client_done(op); | 1911 | send_client_done (op); |
1893 | _GSS_operation_destroy2(op); | 1912 | _GSS_operation_destroy2 (op); |
1894 | return; | 1913 | return; |
1895 | } | 1914 | } |
1896 | break; | 1915 | break; |
1897 | 1916 | ||
1898 | default: | 1917 | default: |
1899 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 1918 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1900 | "Handle full done phase is %u\n", | 1919 | "Handle full done phase is %u\n", |
1901 | (unsigned)op->state->phase); | 1920 | (unsigned) op->state->phase); |
1902 | GNUNET_break_op(0); | 1921 | GNUNET_break_op (0); |
1903 | fail_union_operation(op); | 1922 | fail_union_operation (op); |
1904 | return; | 1923 | return; |
1905 | } | 1924 | } |
1906 | GNUNET_CADET_receive_done(op->channel); | 1925 | GNUNET_CADET_receive_done (op->channel); |
1907 | } | 1926 | } |
1908 | 1927 | ||
1909 | 1928 | ||
@@ -1916,25 +1935,25 @@ handle_union_p2p_full_done(void *cls, | |||
1916 | * @return #GNUNET_OK if @a mh is well-formed | 1935 | * @return #GNUNET_OK if @a mh is well-formed |
1917 | */ | 1936 | */ |
1918 | int | 1937 | int |
1919 | check_union_p2p_demand(void *cls, | 1938 | check_union_p2p_demand (void *cls, |
1920 | const struct GNUNET_MessageHeader *mh) | 1939 | const struct GNUNET_MessageHeader *mh) |
1921 | { | 1940 | { |
1922 | struct Operation *op = cls; | 1941 | struct Operation *op = cls; |
1923 | unsigned int num_hashes; | 1942 | unsigned int num_hashes; |
1924 | 1943 | ||
1925 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) | 1944 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) |
1926 | { | 1945 | { |
1927 | GNUNET_break_op(0); | 1946 | GNUNET_break_op (0); |
1928 | return GNUNET_SYSERR; | 1947 | return GNUNET_SYSERR; |
1929 | } | 1948 | } |
1930 | num_hashes = (ntohs(mh->size) - sizeof(struct GNUNET_MessageHeader)) | 1949 | num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader)) |
1931 | / sizeof(struct GNUNET_HashCode); | 1950 | / sizeof(struct GNUNET_HashCode); |
1932 | if ((ntohs(mh->size) - sizeof(struct GNUNET_MessageHeader)) | 1951 | if ((ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader)) |
1933 | != num_hashes * sizeof(struct GNUNET_HashCode)) | 1952 | != num_hashes * sizeof(struct GNUNET_HashCode)) |
1934 | { | 1953 | { |
1935 | GNUNET_break_op(0); | 1954 | GNUNET_break_op (0); |
1936 | return GNUNET_SYSERR; | 1955 | return GNUNET_SYSERR; |
1937 | } | 1956 | } |
1938 | return GNUNET_OK; | 1957 | return GNUNET_OK; |
1939 | } | 1958 | } |
1940 | 1959 | ||
@@ -1947,8 +1966,8 @@ check_union_p2p_demand(void *cls, | |||
1947 | * @param mh the demand message | 1966 | * @param mh the demand message |
1948 | */ | 1967 | */ |
1949 | void | 1968 | void |
1950 | handle_union_p2p_demand(void *cls, | 1969 | handle_union_p2p_demand (void *cls, |
1951 | const struct GNUNET_MessageHeader *mh) | 1970 | const struct GNUNET_MessageHeader *mh) |
1952 | { | 1971 | { |
1953 | struct Operation *op = cls; | 1972 | struct Operation *op = cls; |
1954 | struct ElementEntry *ee; | 1973 | struct ElementEntry *ee; |
@@ -1957,60 +1976,61 @@ handle_union_p2p_demand(void *cls, | |||
1957 | unsigned int num_hashes; | 1976 | unsigned int num_hashes; |
1958 | struct GNUNET_MQ_Envelope *ev; | 1977 | struct GNUNET_MQ_Envelope *ev; |
1959 | 1978 | ||
1960 | num_hashes = (ntohs(mh->size) - sizeof(struct GNUNET_MessageHeader)) | 1979 | num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader)) |
1961 | / sizeof(struct GNUNET_HashCode); | 1980 | / sizeof(struct GNUNET_HashCode); |
1962 | for (hash = (const struct GNUNET_HashCode *)&mh[1]; | 1981 | for (hash = (const struct GNUNET_HashCode *) &mh[1]; |
1963 | num_hashes > 0; | 1982 | num_hashes > 0; |
1964 | hash++, num_hashes--) | 1983 | hash++, num_hashes--) |
1984 | { | ||
1985 | ee = GNUNET_CONTAINER_multihashmap_get (op->set->content->elements, | ||
1986 | hash); | ||
1987 | if (NULL == ee) | ||
1965 | { | 1988 | { |
1966 | ee = GNUNET_CONTAINER_multihashmap_get(op->set->content->elements, | 1989 | /* Demand for non-existing element. */ |
1967 | hash); | 1990 | GNUNET_break_op (0); |
1968 | if (NULL == ee) | 1991 | fail_union_operation (op); |
1969 | { | 1992 | return; |
1970 | /* Demand for non-existing element. */ | 1993 | } |
1971 | GNUNET_break_op(0); | 1994 | if (GNUNET_NO == _GSS_is_element_of_operation (ee, op)) |
1972 | fail_union_operation(op); | 1995 | { |
1973 | return; | 1996 | /* Probably confused lazily copied sets. */ |
1974 | } | 1997 | GNUNET_break_op (0); |
1975 | if (GNUNET_NO == _GSS_is_element_of_operation(ee, op)) | 1998 | fail_union_operation (op); |
1976 | { | 1999 | return; |
1977 | /* Probably confused lazily copied sets. */ | ||
1978 | GNUNET_break_op(0); | ||
1979 | fail_union_operation(op); | ||
1980 | return; | ||
1981 | } | ||
1982 | ev = GNUNET_MQ_msg_extra(emsg, ee->element.size, GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS); | ||
1983 | GNUNET_memcpy(&emsg[1], ee->element.data, ee->element.size); | ||
1984 | emsg->reserved = htons(0); | ||
1985 | emsg->element_type = htons(ee->element.element_type); | ||
1986 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
1987 | "[OP %x] Sending demanded element (size %u, hash %s) to peer\n", | ||
1988 | (void *)op, | ||
1989 | (unsigned int)ee->element.size, | ||
1990 | GNUNET_h2s(&ee->element_hash)); | ||
1991 | GNUNET_MQ_send(op->mq, ev); | ||
1992 | GNUNET_STATISTICS_update(_GSS_statistics, | ||
1993 | "# exchanged elements", | ||
1994 | 1, | ||
1995 | GNUNET_NO); | ||
1996 | |||
1997 | switch (op->result_mode) | ||
1998 | { | ||
1999 | case GNUNET_SET_RESULT_ADDED: | ||
2000 | /* Nothing to do. */ | ||
2001 | break; | ||
2002 | |||
2003 | case GNUNET_SET_RESULT_SYMMETRIC: | ||
2004 | send_client_element(op, &ee->element, GNUNET_SET_STATUS_ADD_REMOTE); | ||
2005 | break; | ||
2006 | |||
2007 | default: | ||
2008 | /* Result mode not supported, should have been caught earlier. */ | ||
2009 | GNUNET_break(0); | ||
2010 | break; | ||
2011 | } | ||
2012 | } | 2000 | } |
2013 | GNUNET_CADET_receive_done(op->channel); | 2001 | ev = GNUNET_MQ_msg_extra (emsg, ee->element.size, |
2002 | GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS); | ||
2003 | GNUNET_memcpy (&emsg[1], ee->element.data, ee->element.size); | ||
2004 | emsg->reserved = htons (0); | ||
2005 | emsg->element_type = htons (ee->element.element_type); | ||
2006 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
2007 | "[OP %x] Sending demanded element (size %u, hash %s) to peer\n", | ||
2008 | (void *) op, | ||
2009 | (unsigned int) ee->element.size, | ||
2010 | GNUNET_h2s (&ee->element_hash)); | ||
2011 | GNUNET_MQ_send (op->mq, ev); | ||
2012 | GNUNET_STATISTICS_update (_GSS_statistics, | ||
2013 | "# exchanged elements", | ||
2014 | 1, | ||
2015 | GNUNET_NO); | ||
2016 | |||
2017 | switch (op->result_mode) | ||
2018 | { | ||
2019 | case GNUNET_SET_RESULT_ADDED: | ||
2020 | /* Nothing to do. */ | ||
2021 | break; | ||
2022 | |||
2023 | case GNUNET_SET_RESULT_SYMMETRIC: | ||
2024 | send_client_element (op, &ee->element, GNUNET_SET_STATUS_ADD_REMOTE); | ||
2025 | break; | ||
2026 | |||
2027 | default: | ||
2028 | /* Result mode not supported, should have been caught earlier. */ | ||
2029 | GNUNET_break (0); | ||
2030 | break; | ||
2031 | } | ||
2032 | } | ||
2033 | GNUNET_CADET_receive_done (op->channel); | ||
2014 | } | 2034 | } |
2015 | 2035 | ||
2016 | 2036 | ||
@@ -2022,32 +2042,32 @@ handle_union_p2p_demand(void *cls, | |||
2022 | * @return #GNUNET_OK if @a mh is well-formed | 2042 | * @return #GNUNET_OK if @a mh is well-formed |
2023 | */ | 2043 | */ |
2024 | int | 2044 | int |
2025 | check_union_p2p_offer(void *cls, | 2045 | check_union_p2p_offer (void *cls, |
2026 | const struct GNUNET_MessageHeader *mh) | 2046 | const struct GNUNET_MessageHeader *mh) |
2027 | { | 2047 | { |
2028 | struct Operation *op = cls; | 2048 | struct Operation *op = cls; |
2029 | unsigned int num_hashes; | 2049 | unsigned int num_hashes; |
2030 | 2050 | ||
2031 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) | 2051 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) |
2032 | { | 2052 | { |
2033 | GNUNET_break_op(0); | 2053 | GNUNET_break_op (0); |
2034 | return GNUNET_SYSERR; | 2054 | return GNUNET_SYSERR; |
2035 | } | 2055 | } |
2036 | /* look up elements and send them */ | 2056 | /* look up elements and send them */ |
2037 | if ((op->state->phase != PHASE_INVENTORY_PASSIVE) && | 2057 | if ((op->state->phase != PHASE_INVENTORY_PASSIVE) && |
2038 | (op->state->phase != PHASE_INVENTORY_ACTIVE)) | 2058 | (op->state->phase != PHASE_INVENTORY_ACTIVE)) |
2039 | { | 2059 | { |
2040 | GNUNET_break_op(0); | 2060 | GNUNET_break_op (0); |
2041 | return GNUNET_SYSERR; | 2061 | return GNUNET_SYSERR; |
2042 | } | 2062 | } |
2043 | num_hashes = (ntohs(mh->size) - sizeof(struct GNUNET_MessageHeader)) | 2063 | num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader)) |
2044 | / sizeof(struct GNUNET_HashCode); | 2064 | / sizeof(struct GNUNET_HashCode); |
2045 | if ((ntohs(mh->size) - sizeof(struct GNUNET_MessageHeader)) != | 2065 | if ((ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader)) != |
2046 | num_hashes * sizeof(struct GNUNET_HashCode)) | 2066 | num_hashes * sizeof(struct GNUNET_HashCode)) |
2047 | { | 2067 | { |
2048 | GNUNET_break_op(0); | 2068 | GNUNET_break_op (0); |
2049 | return GNUNET_SYSERR; | 2069 | return GNUNET_SYSERR; |
2050 | } | 2070 | } |
2051 | return GNUNET_OK; | 2071 | return GNUNET_OK; |
2052 | } | 2072 | } |
2053 | 2073 | ||
@@ -2060,56 +2080,57 @@ check_union_p2p_offer(void *cls, | |||
2060 | * @param mh the message | 2080 | * @param mh the message |
2061 | */ | 2081 | */ |
2062 | void | 2082 | void |
2063 | handle_union_p2p_offer(void *cls, | 2083 | handle_union_p2p_offer (void *cls, |
2064 | const struct GNUNET_MessageHeader *mh) | 2084 | const struct GNUNET_MessageHeader *mh) |
2065 | { | 2085 | { |
2066 | struct Operation *op = cls; | 2086 | struct Operation *op = cls; |
2067 | const struct GNUNET_HashCode *hash; | 2087 | const struct GNUNET_HashCode *hash; |
2068 | unsigned int num_hashes; | 2088 | unsigned int num_hashes; |
2069 | 2089 | ||
2070 | num_hashes = (ntohs(mh->size) - sizeof(struct GNUNET_MessageHeader)) | 2090 | num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader)) |
2071 | / sizeof(struct GNUNET_HashCode); | 2091 | / sizeof(struct GNUNET_HashCode); |
2072 | for (hash = (const struct GNUNET_HashCode *)&mh[1]; | 2092 | for (hash = (const struct GNUNET_HashCode *) &mh[1]; |
2073 | num_hashes > 0; | 2093 | num_hashes > 0; |
2074 | hash++, num_hashes--) | 2094 | hash++, num_hashes--) |
2075 | { | 2095 | { |
2076 | struct ElementEntry *ee; | 2096 | struct ElementEntry *ee; |
2077 | struct GNUNET_MessageHeader *demands; | 2097 | struct GNUNET_MessageHeader *demands; |
2078 | struct GNUNET_MQ_Envelope *ev; | 2098 | struct GNUNET_MQ_Envelope *ev; |
2079 | 2099 | ||
2080 | ee = GNUNET_CONTAINER_multihashmap_get(op->set->content->elements, | 2100 | ee = GNUNET_CONTAINER_multihashmap_get (op->set->content->elements, |
2081 | hash); | 2101 | hash); |
2082 | if (NULL != ee) | 2102 | if (NULL != ee) |
2083 | if (GNUNET_YES == _GSS_is_element_of_operation(ee, op)) | 2103 | if (GNUNET_YES == _GSS_is_element_of_operation (ee, op)) |
2084 | continue; | 2104 | continue; |
2085 | 2105 | ||
2086 | if (GNUNET_YES == | 2106 | if (GNUNET_YES == |
2087 | GNUNET_CONTAINER_multihashmap_contains(op->state->demanded_hashes, | 2107 | GNUNET_CONTAINER_multihashmap_contains (op->state->demanded_hashes, |
2088 | hash)) | 2108 | hash)) |
2089 | { | 2109 | { |
2090 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2110 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2091 | "Skipped sending duplicate demand\n"); | 2111 | "Skipped sending duplicate demand\n"); |
2092 | continue; | 2112 | continue; |
2093 | } | 2113 | } |
2094 | 2114 | ||
2095 | GNUNET_assert(GNUNET_OK == | 2115 | GNUNET_assert (GNUNET_OK == |
2096 | GNUNET_CONTAINER_multihashmap_put(op->state->demanded_hashes, | 2116 | GNUNET_CONTAINER_multihashmap_put ( |
2097 | hash, | 2117 | op->state->demanded_hashes, |
2098 | NULL, | 2118 | hash, |
2099 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); | 2119 | NULL, |
2100 | 2120 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)); | |
2101 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2121 | |
2102 | "[OP %x] Requesting element (hash %s)\n", | 2122 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2103 | (void *)op, GNUNET_h2s(hash)); | 2123 | "[OP %x] Requesting element (hash %s)\n", |
2104 | ev = GNUNET_MQ_msg_header_extra(demands, | 2124 | (void *) op, GNUNET_h2s (hash)); |
2105 | sizeof(struct GNUNET_HashCode), | 2125 | ev = GNUNET_MQ_msg_header_extra (demands, |
2106 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND); | 2126 | sizeof(struct GNUNET_HashCode), |
2107 | GNUNET_memcpy(&demands[1], | 2127 | GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND); |
2108 | hash, | 2128 | GNUNET_memcpy (&demands[1], |
2109 | sizeof(struct GNUNET_HashCode)); | 2129 | hash, |
2110 | GNUNET_MQ_send(op->mq, ev); | 2130 | sizeof(struct GNUNET_HashCode)); |
2111 | } | 2131 | GNUNET_MQ_send (op->mq, ev); |
2112 | GNUNET_CADET_receive_done(op->channel); | 2132 | } |
2133 | GNUNET_CADET_receive_done (op->channel); | ||
2113 | } | 2134 | } |
2114 | 2135 | ||
2115 | 2136 | ||
@@ -2120,58 +2141,58 @@ handle_union_p2p_offer(void *cls, | |||
2120 | * @param mh the message | 2141 | * @param mh the message |
2121 | */ | 2142 | */ |
2122 | void | 2143 | void |
2123 | handle_union_p2p_done(void *cls, | 2144 | handle_union_p2p_done (void *cls, |
2124 | const struct GNUNET_MessageHeader *mh) | 2145 | const struct GNUNET_MessageHeader *mh) |
2125 | { | 2146 | { |
2126 | struct Operation *op = cls; | 2147 | struct Operation *op = cls; |
2127 | 2148 | ||
2128 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) | 2149 | if (GNUNET_SET_OPERATION_UNION != op->set->operation) |
2129 | { | 2150 | { |
2130 | GNUNET_break_op(0); | 2151 | GNUNET_break_op (0); |
2131 | fail_union_operation(op); | 2152 | fail_union_operation (op); |
2132 | return; | 2153 | return; |
2133 | } | 2154 | } |
2134 | switch (op->state->phase) | 2155 | switch (op->state->phase) |
2135 | { | 2156 | { |
2136 | case PHASE_INVENTORY_PASSIVE: | 2157 | case PHASE_INVENTORY_PASSIVE: |
2137 | /* We got all requests, but still have to send our elements in response. */ | 2158 | /* We got all requests, but still have to send our elements in response. */ |
2138 | op->state->phase = PHASE_FINISH_WAITING; | 2159 | op->state->phase = PHASE_FINISH_WAITING; |
2139 | 2160 | ||
2140 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2161 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2141 | "got DONE (as passive partner), waiting for our demands to be satisfied\n"); | 2162 | "got DONE (as passive partner), waiting for our demands to be satisfied\n"); |
2142 | /* The active peer is done sending offers | 2163 | /* The active peer is done sending offers |
2143 | * and inquiries. This means that all | 2164 | * and inquiries. This means that all |
2144 | * our responses to that (demands and offers) | 2165 | * our responses to that (demands and offers) |
2145 | * must be in flight (queued or in mesh). | 2166 | * must be in flight (queued or in mesh). |
2146 | * | 2167 | * |
2147 | * We should notify the active peer once | 2168 | * We should notify the active peer once |
2148 | * all our demands are satisfied, so that the active | 2169 | * all our demands are satisfied, so that the active |
2149 | * peer can quit if we gave it everything. | 2170 | * peer can quit if we gave it everything. |
2150 | */ | 2171 | */ |
2151 | GNUNET_CADET_receive_done(op->channel); | 2172 | GNUNET_CADET_receive_done (op->channel); |
2152 | maybe_finish(op); | 2173 | maybe_finish (op); |
2153 | return; | 2174 | return; |
2154 | 2175 | ||
2155 | case PHASE_INVENTORY_ACTIVE: | 2176 | case PHASE_INVENTORY_ACTIVE: |
2156 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2177 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2157 | "got DONE (as active partner), waiting to finish\n"); | 2178 | "got DONE (as active partner), waiting to finish\n"); |
2158 | /* All demands of the other peer are satisfied, | 2179 | /* All demands of the other peer are satisfied, |
2159 | * and we processed all offers, thus we know | 2180 | * and we processed all offers, thus we know |
2160 | * exactly what our demands must be. | 2181 | * exactly what our demands must be. |
2161 | * | 2182 | * |
2162 | * We'll close the channel | 2183 | * We'll close the channel |
2163 | * to the other peer once our demands are met. | 2184 | * to the other peer once our demands are met. |
2164 | */ | 2185 | */ |
2165 | op->state->phase = PHASE_FINISH_CLOSING; | 2186 | op->state->phase = PHASE_FINISH_CLOSING; |
2166 | GNUNET_CADET_receive_done(op->channel); | 2187 | GNUNET_CADET_receive_done (op->channel); |
2167 | maybe_finish(op); | 2188 | maybe_finish (op); |
2168 | return; | 2189 | return; |
2169 | 2190 | ||
2170 | default: | 2191 | default: |
2171 | GNUNET_break_op(0); | 2192 | GNUNET_break_op (0); |
2172 | fail_union_operation(op); | 2193 | fail_union_operation (op); |
2173 | return; | 2194 | return; |
2174 | } | 2195 | } |
2175 | } | 2196 | } |
2176 | 2197 | ||
2177 | /** | 2198 | /** |
@@ -2181,10 +2202,10 @@ handle_union_p2p_done(void *cls, | |||
2181 | * @param mh the message | 2202 | * @param mh the message |
2182 | */ | 2203 | */ |
2183 | void | 2204 | void |
2184 | handle_union_p2p_over(void *cls, | 2205 | handle_union_p2p_over (void *cls, |
2185 | const struct GNUNET_MessageHeader *mh) | 2206 | const struct GNUNET_MessageHeader *mh) |
2186 | { | 2207 | { |
2187 | send_client_done(cls); | 2208 | send_client_done (cls); |
2188 | } | 2209 | } |
2189 | 2210 | ||
2190 | 2211 | ||
@@ -2196,54 +2217,55 @@ handle_union_p2p_over(void *cls, | |||
2196 | * to convince it to accept, may be NULL | 2217 | * to convince it to accept, may be NULL |
2197 | */ | 2218 | */ |
2198 | static struct OperationState * | 2219 | static struct OperationState * |
2199 | union_evaluate(struct Operation *op, | 2220 | union_evaluate (struct Operation *op, |
2200 | const struct GNUNET_MessageHeader *opaque_context) | 2221 | const struct GNUNET_MessageHeader *opaque_context) |
2201 | { | 2222 | { |
2202 | struct OperationState *state; | 2223 | struct OperationState *state; |
2203 | struct GNUNET_MQ_Envelope *ev; | 2224 | struct GNUNET_MQ_Envelope *ev; |
2204 | struct OperationRequestMessage *msg; | 2225 | struct OperationRequestMessage *msg; |
2205 | 2226 | ||
2206 | ev = GNUNET_MQ_msg_nested_mh(msg, | 2227 | ev = GNUNET_MQ_msg_nested_mh (msg, |
2207 | GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, | 2228 | GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST, |
2208 | opaque_context); | 2229 | opaque_context); |
2209 | if (NULL == ev) | 2230 | if (NULL == ev) |
2210 | { | 2231 | { |
2211 | /* the context message is too large */ | 2232 | /* the context message is too large */ |
2212 | GNUNET_break(0); | 2233 | GNUNET_break (0); |
2213 | return NULL; | 2234 | return NULL; |
2214 | } | 2235 | } |
2215 | state = GNUNET_new(struct OperationState); | 2236 | state = GNUNET_new (struct OperationState); |
2216 | state->demanded_hashes = GNUNET_CONTAINER_multihashmap_create(32, | 2237 | state->demanded_hashes = GNUNET_CONTAINER_multihashmap_create (32, |
2217 | GNUNET_NO); | 2238 | GNUNET_NO); |
2218 | /* copy the current generation's strata estimator for this operation */ | 2239 | /* copy the current generation's strata estimator for this operation */ |
2219 | state->se = strata_estimator_dup(op->set->state->se); | 2240 | state->se = strata_estimator_dup (op->set->state->se); |
2220 | /* we started the operation, thus we have to send the operation request */ | 2241 | /* we started the operation, thus we have to send the operation request */ |
2221 | state->phase = PHASE_EXPECT_SE; | 2242 | state->phase = PHASE_EXPECT_SE; |
2222 | state->salt_receive = state->salt_send = 42; // FIXME????? | 2243 | state->salt_receive = state->salt_send = 42; // FIXME????? |
2223 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2244 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2224 | "Initiating union operation evaluation\n"); | 2245 | "Initiating union operation evaluation\n"); |
2225 | GNUNET_STATISTICS_update(_GSS_statistics, | 2246 | GNUNET_STATISTICS_update (_GSS_statistics, |
2226 | "# of total union operations", | 2247 | "# of total union operations", |
2227 | 1, | 2248 | 1, |
2228 | GNUNET_NO); | 2249 | GNUNET_NO); |
2229 | GNUNET_STATISTICS_update(_GSS_statistics, | 2250 | GNUNET_STATISTICS_update (_GSS_statistics, |
2230 | "# of initiated union operations", | 2251 | "# of initiated union operations", |
2231 | 1, | 2252 | 1, |
2232 | GNUNET_NO); | 2253 | GNUNET_NO); |
2233 | msg->operation = htonl(GNUNET_SET_OPERATION_UNION); | 2254 | msg->operation = htonl (GNUNET_SET_OPERATION_UNION); |
2234 | GNUNET_MQ_send(op->mq, | 2255 | GNUNET_MQ_send (op->mq, |
2235 | ev); | 2256 | ev); |
2236 | 2257 | ||
2237 | if (NULL != opaque_context) | 2258 | if (NULL != opaque_context) |
2238 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2259 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2239 | "sent op request with context message\n"); | 2260 | "sent op request with context message\n"); |
2240 | else | 2261 | else |
2241 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2262 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2242 | "sent op request without context message\n"); | 2263 | "sent op request without context message\n"); |
2243 | 2264 | ||
2244 | op->state = state; | 2265 | op->state = state; |
2245 | initialize_key_to_element(op); | 2266 | initialize_key_to_element (op); |
2246 | state->initial_size = GNUNET_CONTAINER_multihashmap32_size(state->key_to_element); | 2267 | state->initial_size = GNUNET_CONTAINER_multihashmap32_size ( |
2268 | state->key_to_element); | ||
2247 | return state; | 2269 | return state; |
2248 | } | 2270 | } |
2249 | 2271 | ||
@@ -2255,7 +2277,7 @@ union_evaluate(struct Operation *op, | |||
2255 | * @param op operation that will be accepted as a union operation | 2277 | * @param op operation that will be accepted as a union operation |
2256 | */ | 2278 | */ |
2257 | static struct OperationState * | 2279 | static struct OperationState * |
2258 | union_accept(struct Operation *op) | 2280 | union_accept (struct Operation *op) |
2259 | { | 2281 | { |
2260 | struct OperationState *state; | 2282 | struct OperationState *state; |
2261 | const struct StrataEstimator *se; | 2283 | const struct StrataEstimator *se; |
@@ -2265,46 +2287,48 @@ union_accept(struct Operation *op) | |||
2265 | size_t len; | 2287 | size_t len; |
2266 | uint16_t type; | 2288 | uint16_t type; |
2267 | 2289 | ||
2268 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2290 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2269 | "accepting set union operation\n"); | 2291 | "accepting set union operation\n"); |
2270 | GNUNET_STATISTICS_update(_GSS_statistics, | 2292 | GNUNET_STATISTICS_update (_GSS_statistics, |
2271 | "# of accepted union operations", | 2293 | "# of accepted union operations", |
2272 | 1, | 2294 | 1, |
2273 | GNUNET_NO); | 2295 | GNUNET_NO); |
2274 | GNUNET_STATISTICS_update(_GSS_statistics, | 2296 | GNUNET_STATISTICS_update (_GSS_statistics, |
2275 | "# of total union operations", | 2297 | "# of total union operations", |
2276 | 1, | 2298 | 1, |
2277 | GNUNET_NO); | 2299 | GNUNET_NO); |
2278 | 2300 | ||
2279 | state = GNUNET_new(struct OperationState); | 2301 | state = GNUNET_new (struct OperationState); |
2280 | state->se = strata_estimator_dup(op->set->state->se); | 2302 | state->se = strata_estimator_dup (op->set->state->se); |
2281 | state->demanded_hashes = GNUNET_CONTAINER_multihashmap_create(32, | 2303 | state->demanded_hashes = GNUNET_CONTAINER_multihashmap_create (32, |
2282 | GNUNET_NO); | 2304 | GNUNET_NO); |
2283 | state->salt_receive = state->salt_send = 42; // FIXME????? | 2305 | state->salt_receive = state->salt_send = 42; // FIXME????? |
2284 | op->state = state; | 2306 | op->state = state; |
2285 | initialize_key_to_element(op); | 2307 | initialize_key_to_element (op); |
2286 | state->initial_size = GNUNET_CONTAINER_multihashmap32_size(state->key_to_element); | 2308 | state->initial_size = GNUNET_CONTAINER_multihashmap32_size ( |
2309 | state->key_to_element); | ||
2287 | 2310 | ||
2288 | /* kick off the operation */ | 2311 | /* kick off the operation */ |
2289 | se = state->se; | 2312 | se = state->se; |
2290 | buf = GNUNET_malloc(se->strata_count * IBF_BUCKET_SIZE * se->ibf_size); | 2313 | buf = GNUNET_malloc (se->strata_count * IBF_BUCKET_SIZE * se->ibf_size); |
2291 | len = strata_estimator_write(se, | 2314 | len = strata_estimator_write (se, |
2292 | buf); | 2315 | buf); |
2293 | if (len < se->strata_count * IBF_BUCKET_SIZE * se->ibf_size) | 2316 | if (len < se->strata_count * IBF_BUCKET_SIZE * se->ibf_size) |
2294 | type = GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC; | 2317 | type = GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC; |
2295 | else | 2318 | else |
2296 | type = GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE; | 2319 | type = GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE; |
2297 | ev = GNUNET_MQ_msg_extra(strata_msg, | 2320 | ev = GNUNET_MQ_msg_extra (strata_msg, |
2298 | len, | 2321 | len, |
2299 | type); | 2322 | type); |
2300 | GNUNET_memcpy(&strata_msg[1], | 2323 | GNUNET_memcpy (&strata_msg[1], |
2301 | buf, | 2324 | buf, |
2302 | len); | 2325 | len); |
2303 | GNUNET_free(buf); | 2326 | GNUNET_free (buf); |
2304 | strata_msg->set_size | 2327 | strata_msg->set_size |
2305 | = GNUNET_htonll(GNUNET_CONTAINER_multihashmap_size(op->set->content->elements)); | 2328 | = GNUNET_htonll (GNUNET_CONTAINER_multihashmap_size ( |
2306 | GNUNET_MQ_send(op->mq, | 2329 | op->set->content->elements)); |
2307 | ev); | 2330 | GNUNET_MQ_send (op->mq, |
2331 | ev); | ||
2308 | state->phase = PHASE_EXPECT_IBF; | 2332 | state->phase = PHASE_EXPECT_IBF; |
2309 | return state; | 2333 | return state; |
2310 | } | 2334 | } |
@@ -2319,22 +2343,22 @@ union_accept(struct Operation *op) | |||
2319 | * @return the newly created set, NULL on error | 2343 | * @return the newly created set, NULL on error |
2320 | */ | 2344 | */ |
2321 | static struct SetState * | 2345 | static struct SetState * |
2322 | union_set_create(void) | 2346 | union_set_create (void) |
2323 | { | 2347 | { |
2324 | struct SetState *set_state; | 2348 | struct SetState *set_state; |
2325 | 2349 | ||
2326 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 2350 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
2327 | "union set created\n"); | 2351 | "union set created\n"); |
2328 | set_state = GNUNET_new(struct SetState); | 2352 | set_state = GNUNET_new (struct SetState); |
2329 | set_state->se = strata_estimator_create(SE_STRATA_COUNT, | 2353 | set_state->se = strata_estimator_create (SE_STRATA_COUNT, |
2330 | SE_IBF_SIZE, SE_IBF_HASH_NUM); | 2354 | SE_IBF_SIZE, SE_IBF_HASH_NUM); |
2331 | if (NULL == set_state->se) | 2355 | if (NULL == set_state->se) |
2332 | { | 2356 | { |
2333 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 2357 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
2334 | "Failed to allocate strata estimator\n"); | 2358 | "Failed to allocate strata estimator\n"); |
2335 | GNUNET_free(set_state); | 2359 | GNUNET_free (set_state); |
2336 | return NULL; | 2360 | return NULL; |
2337 | } | 2361 | } |
2338 | return set_state; | 2362 | return set_state; |
2339 | } | 2363 | } |
2340 | 2364 | ||
@@ -2346,11 +2370,11 @@ union_set_create(void) | |||
2346 | * @param ee the element to add to the set | 2370 | * @param ee the element to add to the set |
2347 | */ | 2371 | */ |
2348 | static void | 2372 | static void |
2349 | union_add(struct SetState *set_state, | 2373 | union_add (struct SetState *set_state, |
2350 | struct ElementEntry *ee) | 2374 | struct ElementEntry *ee) |
2351 | { | 2375 | { |
2352 | strata_estimator_insert(set_state->se, | 2376 | strata_estimator_insert (set_state->se, |
2353 | get_ibf_key(&ee->element_hash)); | 2377 | get_ibf_key (&ee->element_hash)); |
2354 | } | 2378 | } |
2355 | 2379 | ||
2356 | 2380 | ||
@@ -2362,11 +2386,11 @@ union_add(struct SetState *set_state, | |||
2362 | * @param ee set element to remove | 2386 | * @param ee set element to remove |
2363 | */ | 2387 | */ |
2364 | static void | 2388 | static void |
2365 | union_remove(struct SetState *set_state, | 2389 | union_remove (struct SetState *set_state, |
2366 | struct ElementEntry *ee) | 2390 | struct ElementEntry *ee) |
2367 | { | 2391 | { |
2368 | strata_estimator_remove(set_state->se, | 2392 | strata_estimator_remove (set_state->se, |
2369 | get_ibf_key(&ee->element_hash)); | 2393 | get_ibf_key (&ee->element_hash)); |
2370 | } | 2394 | } |
2371 | 2395 | ||
2372 | 2396 | ||
@@ -2376,14 +2400,14 @@ union_remove(struct SetState *set_state, | |||
2376 | * @param set_state the set to destroy | 2400 | * @param set_state the set to destroy |
2377 | */ | 2401 | */ |
2378 | static void | 2402 | static void |
2379 | union_set_destroy(struct SetState *set_state) | 2403 | union_set_destroy (struct SetState *set_state) |
2380 | { | 2404 | { |
2381 | if (NULL != set_state->se) | 2405 | if (NULL != set_state->se) |
2382 | { | 2406 | { |
2383 | strata_estimator_destroy(set_state->se); | 2407 | strata_estimator_destroy (set_state->se); |
2384 | set_state->se = NULL; | 2408 | set_state->se = NULL; |
2385 | } | 2409 | } |
2386 | GNUNET_free(set_state); | 2410 | GNUNET_free (set_state); |
2387 | } | 2411 | } |
2388 | 2412 | ||
2389 | 2413 | ||
@@ -2394,14 +2418,14 @@ union_set_destroy(struct SetState *set_state) | |||
2394 | * @return a copy of the union-specific set state | 2418 | * @return a copy of the union-specific set state |
2395 | */ | 2419 | */ |
2396 | static struct SetState * | 2420 | static struct SetState * |
2397 | union_copy_state(struct SetState *state) | 2421 | union_copy_state (struct SetState *state) |
2398 | { | 2422 | { |
2399 | struct SetState *new_state; | 2423 | struct SetState *new_state; |
2400 | 2424 | ||
2401 | GNUNET_assert((NULL != state) && | 2425 | GNUNET_assert ((NULL != state) && |
2402 | (NULL != state->se)); | 2426 | (NULL != state->se)); |
2403 | new_state = GNUNET_new(struct SetState); | 2427 | new_state = GNUNET_new (struct SetState); |
2404 | new_state->se = strata_estimator_dup(state->se); | 2428 | new_state->se = strata_estimator_dup (state->se); |
2405 | 2429 | ||
2406 | return new_state; | 2430 | return new_state; |
2407 | } | 2431 | } |
@@ -2413,11 +2437,11 @@ union_copy_state(struct SetState *state) | |||
2413 | * @param op operation that lost the channel | 2437 | * @param op operation that lost the channel |
2414 | */ | 2438 | */ |
2415 | static void | 2439 | static void |
2416 | union_channel_death(struct Operation *op) | 2440 | union_channel_death (struct Operation *op) |
2417 | { | 2441 | { |
2418 | send_client_done(op); | 2442 | send_client_done (op); |
2419 | _GSS_operation_destroy(op, | 2443 | _GSS_operation_destroy (op, |
2420 | GNUNET_YES); | 2444 | GNUNET_YES); |
2421 | } | 2445 | } |
2422 | 2446 | ||
2423 | 2447 | ||
@@ -2428,7 +2452,7 @@ union_channel_death(struct Operation *op) | |||
2428 | * @return the operation specific VTable | 2452 | * @return the operation specific VTable |
2429 | */ | 2453 | */ |
2430 | const struct SetVT * | 2454 | const struct SetVT * |
2431 | _GSS_union_vt() | 2455 | _GSS_union_vt () |
2432 | { | 2456 | { |
2433 | static const struct SetVT union_vt = { | 2457 | static const struct SetVT union_vt = { |
2434 | .create = &union_set_create, | 2458 | .create = &union_set_create, |
diff --git a/src/set/gnunet-service-set_union.h b/src/set/gnunet-service-set_union.h index b56d59ef9..5da5b7254 100644 --- a/src/set/gnunet-service-set_union.h +++ b/src/set/gnunet-service-set_union.h | |||
@@ -1,4 +1,3 @@ | |||
1 | |||
2 | /* | 1 | /* |
3 | This file is part of GNUnet | 2 | This file is part of GNUnet |
4 | Copyright (C) 2013-2017 GNUnet e.V. | 3 | Copyright (C) 2013-2017 GNUnet e.V. |
@@ -38,8 +37,8 @@ | |||
38 | * @param msg the message | 37 | * @param msg the message |
39 | */ | 38 | */ |
40 | int | 39 | int |
41 | check_union_p2p_strata_estimator(void *cls, | 40 | check_union_p2p_strata_estimator (void *cls, |
42 | const struct StrataEstimatorMessage *msg); | 41 | const struct StrataEstimatorMessage *msg); |
43 | 42 | ||
44 | 43 | ||
45 | /** | 44 | /** |
@@ -49,8 +48,8 @@ check_union_p2p_strata_estimator(void *cls, | |||
49 | * @param msg the message | 48 | * @param msg the message |
50 | */ | 49 | */ |
51 | void | 50 | void |
52 | handle_union_p2p_strata_estimator(void *cls, | 51 | handle_union_p2p_strata_estimator (void *cls, |
53 | const struct StrataEstimatorMessage *msg); | 52 | const struct StrataEstimatorMessage *msg); |
54 | 53 | ||
55 | 54 | ||
56 | /** | 55 | /** |
@@ -64,8 +63,8 @@ handle_union_p2p_strata_estimator(void *cls, | |||
64 | * @return #GNUNET_OK if @a msg is well-formed | 63 | * @return #GNUNET_OK if @a msg is well-formed |
65 | */ | 64 | */ |
66 | int | 65 | int |
67 | check_union_p2p_ibf(void *cls, | 66 | check_union_p2p_ibf (void *cls, |
68 | const struct IBFMessage *msg); | 67 | const struct IBFMessage *msg); |
69 | 68 | ||
70 | 69 | ||
71 | /** | 70 | /** |
@@ -78,8 +77,8 @@ check_union_p2p_ibf(void *cls, | |||
78 | * @param msg the header of the message | 77 | * @param msg the header of the message |
79 | */ | 78 | */ |
80 | void | 79 | void |
81 | handle_union_p2p_ibf(void *cls, | 80 | handle_union_p2p_ibf (void *cls, |
82 | const struct IBFMessage *msg); | 81 | const struct IBFMessage *msg); |
83 | 82 | ||
84 | 83 | ||
85 | /** | 84 | /** |
@@ -89,8 +88,8 @@ handle_union_p2p_ibf(void *cls, | |||
89 | * @param emsg the message | 88 | * @param emsg the message |
90 | */ | 89 | */ |
91 | int | 90 | int |
92 | check_union_p2p_elements(void *cls, | 91 | check_union_p2p_elements (void *cls, |
93 | const struct GNUNET_SET_ElementMessage *emsg); | 92 | const struct GNUNET_SET_ElementMessage *emsg); |
94 | 93 | ||
95 | 94 | ||
96 | /** | 95 | /** |
@@ -102,8 +101,8 @@ check_union_p2p_elements(void *cls, | |||
102 | * @param emsg the message | 101 | * @param emsg the message |
103 | */ | 102 | */ |
104 | void | 103 | void |
105 | handle_union_p2p_elements(void *cls, | 104 | handle_union_p2p_elements (void *cls, |
106 | const struct GNUNET_SET_ElementMessage *emsg); | 105 | const struct GNUNET_SET_ElementMessage *emsg); |
107 | 106 | ||
108 | 107 | ||
109 | /** | 108 | /** |
@@ -113,8 +112,8 @@ handle_union_p2p_elements(void *cls, | |||
113 | * @param emsg the message | 112 | * @param emsg the message |
114 | */ | 113 | */ |
115 | int | 114 | int |
116 | check_union_p2p_full_element(void *cls, | 115 | check_union_p2p_full_element (void *cls, |
117 | const struct GNUNET_SET_ElementMessage *emsg); | 116 | const struct GNUNET_SET_ElementMessage *emsg); |
118 | 117 | ||
119 | 118 | ||
120 | /** | 119 | /** |
@@ -124,8 +123,8 @@ check_union_p2p_full_element(void *cls, | |||
124 | * @param emsg the message | 123 | * @param emsg the message |
125 | */ | 124 | */ |
126 | void | 125 | void |
127 | handle_union_p2p_full_element(void *cls, | 126 | handle_union_p2p_full_element (void *cls, |
128 | const struct GNUNET_SET_ElementMessage *emsg); | 127 | const struct GNUNET_SET_ElementMessage *emsg); |
129 | 128 | ||
130 | 129 | ||
131 | /** | 130 | /** |
@@ -136,8 +135,8 @@ handle_union_p2p_full_element(void *cls, | |||
136 | * @param msg the message | 135 | * @param msg the message |
137 | */ | 136 | */ |
138 | int | 137 | int |
139 | check_union_p2p_inquiry(void *cls, | 138 | check_union_p2p_inquiry (void *cls, |
140 | const struct InquiryMessage *msg); | 139 | const struct InquiryMessage *msg); |
141 | 140 | ||
142 | 141 | ||
143 | /** | 142 | /** |
@@ -148,8 +147,8 @@ check_union_p2p_inquiry(void *cls, | |||
148 | * @param msg the message | 147 | * @param msg the message |
149 | */ | 148 | */ |
150 | void | 149 | void |
151 | handle_union_p2p_inquiry(void *cls, | 150 | handle_union_p2p_inquiry (void *cls, |
152 | const struct InquiryMessage *msg); | 151 | const struct InquiryMessage *msg); |
153 | 152 | ||
154 | 153 | ||
155 | 154 | ||
@@ -160,8 +159,8 @@ handle_union_p2p_inquiry(void *cls, | |||
160 | * @param mh the demand message | 159 | * @param mh the demand message |
161 | */ | 160 | */ |
162 | void | 161 | void |
163 | handle_union_p2p_request_full(void *cls, | 162 | handle_union_p2p_request_full (void *cls, |
164 | const struct GNUNET_MessageHeader *mh); | 163 | const struct GNUNET_MessageHeader *mh); |
165 | 164 | ||
166 | 165 | ||
167 | 166 | ||
@@ -172,8 +171,8 @@ handle_union_p2p_request_full(void *cls, | |||
172 | * @param mh the demand message | 171 | * @param mh the demand message |
173 | */ | 172 | */ |
174 | void | 173 | void |
175 | handle_union_p2p_full_done(void *cls, | 174 | handle_union_p2p_full_done (void *cls, |
176 | const struct GNUNET_MessageHeader *mh); | 175 | const struct GNUNET_MessageHeader *mh); |
177 | 176 | ||
178 | 177 | ||
179 | /** | 178 | /** |
@@ -185,8 +184,8 @@ handle_union_p2p_full_done(void *cls, | |||
185 | * @return #GNUNET_OK if @a mh is well-formed | 184 | * @return #GNUNET_OK if @a mh is well-formed |
186 | */ | 185 | */ |
187 | int | 186 | int |
188 | check_union_p2p_demand(void *cls, | 187 | check_union_p2p_demand (void *cls, |
189 | const struct GNUNET_MessageHeader *mh); | 188 | const struct GNUNET_MessageHeader *mh); |
190 | 189 | ||
191 | 190 | ||
192 | /** | 191 | /** |
@@ -197,8 +196,8 @@ check_union_p2p_demand(void *cls, | |||
197 | * @param mh the demand message | 196 | * @param mh the demand message |
198 | */ | 197 | */ |
199 | void | 198 | void |
200 | handle_union_p2p_demand(void *cls, | 199 | handle_union_p2p_demand (void *cls, |
201 | const struct GNUNET_MessageHeader *mh); | 200 | const struct GNUNET_MessageHeader *mh); |
202 | 201 | ||
203 | 202 | ||
204 | /** | 203 | /** |
@@ -209,8 +208,8 @@ handle_union_p2p_demand(void *cls, | |||
209 | * @return #GNUNET_OK if @a mh is well-formed | 208 | * @return #GNUNET_OK if @a mh is well-formed |
210 | */ | 209 | */ |
211 | int | 210 | int |
212 | check_union_p2p_offer(void *cls, | 211 | check_union_p2p_offer (void *cls, |
213 | const struct GNUNET_MessageHeader *mh); | 212 | const struct GNUNET_MessageHeader *mh); |
214 | 213 | ||
215 | 214 | ||
216 | /** | 215 | /** |
@@ -221,8 +220,8 @@ check_union_p2p_offer(void *cls, | |||
221 | * @param mh the message | 220 | * @param mh the message |
222 | */ | 221 | */ |
223 | void | 222 | void |
224 | handle_union_p2p_offer(void *cls, | 223 | handle_union_p2p_offer (void *cls, |
225 | const struct GNUNET_MessageHeader *mh); | 224 | const struct GNUNET_MessageHeader *mh); |
226 | 225 | ||
227 | 226 | ||
228 | /** | 227 | /** |
@@ -232,8 +231,8 @@ handle_union_p2p_offer(void *cls, | |||
232 | * @param mh the message | 231 | * @param mh the message |
233 | */ | 232 | */ |
234 | void | 233 | void |
235 | handle_union_p2p_done(void *cls, | 234 | handle_union_p2p_done (void *cls, |
236 | const struct GNUNET_MessageHeader *mh); | 235 | const struct GNUNET_MessageHeader *mh); |
237 | 236 | ||
238 | /** | 237 | /** |
239 | * Handle an over message from a remote peer | 238 | * Handle an over message from a remote peer |
@@ -242,8 +241,8 @@ handle_union_p2p_done(void *cls, | |||
242 | * @param mh the message | 241 | * @param mh the message |
243 | */ | 242 | */ |
244 | void | 243 | void |
245 | handle_union_p2p_over(void *cls, | 244 | handle_union_p2p_over (void *cls, |
246 | const struct GNUNET_MessageHeader *mh); | 245 | const struct GNUNET_MessageHeader *mh); |
247 | 246 | ||
248 | 247 | ||
249 | #endif | 248 | #endif |
diff --git a/src/set/gnunet-service-set_union_strata_estimator.c b/src/set/gnunet-service-set_union_strata_estimator.c index dcc00a680..eee0ec8d3 100644 --- a/src/set/gnunet-service-set_union_strata_estimator.c +++ b/src/set/gnunet-service-set_union_strata_estimator.c | |||
@@ -44,21 +44,21 @@ | |||
44 | * @return number of bytes written to @a buf | 44 | * @return number of bytes written to @a buf |
45 | */ | 45 | */ |
46 | size_t | 46 | size_t |
47 | strata_estimator_write(const struct StrataEstimator *se, | 47 | strata_estimator_write (const struct StrataEstimator *se, |
48 | void *buf) | 48 | void *buf) |
49 | { | 49 | { |
50 | char *sbuf = buf; | 50 | char *sbuf = buf; |
51 | unsigned int i; | 51 | unsigned int i; |
52 | size_t osize; | 52 | size_t osize; |
53 | 53 | ||
54 | GNUNET_assert(NULL != se); | 54 | GNUNET_assert (NULL != se); |
55 | for (i = 0; i < se->strata_count; i++) | 55 | for (i = 0; i < se->strata_count; i++) |
56 | { | 56 | { |
57 | ibf_write_slice(se->strata[i], | 57 | ibf_write_slice (se->strata[i], |
58 | 0, | 58 | 0, |
59 | se->ibf_size, | 59 | se->ibf_size, |
60 | &sbuf[se->ibf_size * IBF_BUCKET_SIZE * i]); | 60 | &sbuf[se->ibf_size * IBF_BUCKET_SIZE * i]); |
61 | } | 61 | } |
62 | osize = se->ibf_size * IBF_BUCKET_SIZE * se->strata_count; | 62 | osize = se->ibf_size * IBF_BUCKET_SIZE * se->strata_count; |
63 | #if FAIL_10_1_COMPATIBILTIY | 63 | #if FAIL_10_1_COMPATIBILTIY |
64 | { | 64 | { |
@@ -66,15 +66,15 @@ strata_estimator_write(const struct StrataEstimator *se, | |||
66 | size_t nsize; | 66 | size_t nsize; |
67 | 67 | ||
68 | if (GNUNET_YES == | 68 | if (GNUNET_YES == |
69 | GNUNET_try_compression(buf, | 69 | GNUNET_try_compression (buf, |
70 | osize, | 70 | osize, |
71 | &cbuf, | 71 | &cbuf, |
72 | &nsize)) | 72 | &nsize)) |
73 | { | 73 | { |
74 | GNUNET_memcpy(buf, cbuf, nsize); | 74 | GNUNET_memcpy (buf, cbuf, nsize); |
75 | osize = nsize; | 75 | osize = nsize; |
76 | GNUNET_free(cbuf); | 76 | GNUNET_free (cbuf); |
77 | } | 77 | } |
78 | } | 78 | } |
79 | #endif | 79 | #endif |
80 | return osize; | 80 | return osize; |
@@ -92,10 +92,10 @@ strata_estimator_write(const struct StrataEstimator *se, | |||
92 | * @return #GNUNET_OK on success | 92 | * @return #GNUNET_OK on success |
93 | */ | 93 | */ |
94 | int | 94 | int |
95 | strata_estimator_read(const void *buf, | 95 | strata_estimator_read (const void *buf, |
96 | size_t buf_len, | 96 | size_t buf_len, |
97 | int is_compressed, | 97 | int is_compressed, |
98 | struct StrataEstimator *se) | 98 | struct StrataEstimator *se) |
99 | { | 99 | { |
100 | unsigned int i; | 100 | unsigned int i; |
101 | size_t osize; | 101 | size_t osize; |
@@ -103,33 +103,33 @@ strata_estimator_read(const void *buf, | |||
103 | 103 | ||
104 | dbuf = NULL; | 104 | dbuf = NULL; |
105 | if (GNUNET_YES == is_compressed) | 105 | if (GNUNET_YES == is_compressed) |
106 | { | ||
107 | osize = se->ibf_size * IBF_BUCKET_SIZE * se->strata_count; | ||
108 | dbuf = GNUNET_decompress (buf, | ||
109 | buf_len, | ||
110 | osize); | ||
111 | if (NULL == dbuf) | ||
106 | { | 112 | { |
107 | osize = se->ibf_size * IBF_BUCKET_SIZE * se->strata_count; | 113 | GNUNET_break_op (0); /* bad compressed input data */ |
108 | dbuf = GNUNET_decompress(buf, | 114 | return GNUNET_SYSERR; |
109 | buf_len, | ||
110 | osize); | ||
111 | if (NULL == dbuf) | ||
112 | { | ||
113 | GNUNET_break_op(0); /* bad compressed input data */ | ||
114 | return GNUNET_SYSERR; | ||
115 | } | ||
116 | buf = dbuf; | ||
117 | buf_len = osize; | ||
118 | } | 115 | } |
116 | buf = dbuf; | ||
117 | buf_len = osize; | ||
118 | } | ||
119 | 119 | ||
120 | if (buf_len != se->strata_count * se->ibf_size * IBF_BUCKET_SIZE) | 120 | if (buf_len != se->strata_count * se->ibf_size * IBF_BUCKET_SIZE) |
121 | { | 121 | { |
122 | GNUNET_break(0); /* very odd error */ | 122 | GNUNET_break (0); /* very odd error */ |
123 | GNUNET_free_non_null(dbuf); | 123 | GNUNET_free_non_null (dbuf); |
124 | return GNUNET_SYSERR; | 124 | return GNUNET_SYSERR; |
125 | } | 125 | } |
126 | 126 | ||
127 | for (i = 0; i < se->strata_count; i++) | 127 | for (i = 0; i < se->strata_count; i++) |
128 | { | 128 | { |
129 | ibf_read_slice(buf, 0, se->ibf_size, se->strata[i]); | 129 | ibf_read_slice (buf, 0, se->ibf_size, se->strata[i]); |
130 | buf += se->ibf_size * IBF_BUCKET_SIZE; | 130 | buf += se->ibf_size * IBF_BUCKET_SIZE; |
131 | } | 131 | } |
132 | GNUNET_free_non_null(dbuf); | 132 | GNUNET_free_non_null (dbuf); |
133 | return GNUNET_OK; | 133 | return GNUNET_OK; |
134 | } | 134 | } |
135 | 135 | ||
@@ -141,8 +141,8 @@ strata_estimator_read(const void *buf, | |||
141 | * @param key key to add | 141 | * @param key key to add |
142 | */ | 142 | */ |
143 | void | 143 | void |
144 | strata_estimator_insert(struct StrataEstimator *se, | 144 | strata_estimator_insert (struct StrataEstimator *se, |
145 | struct IBF_Key key) | 145 | struct IBF_Key key) |
146 | { | 146 | { |
147 | uint64_t v; | 147 | uint64_t v; |
148 | unsigned int i; | 148 | unsigned int i; |
@@ -151,7 +151,7 @@ strata_estimator_insert(struct StrataEstimator *se, | |||
151 | /* count trailing '1'-bits of v */ | 151 | /* count trailing '1'-bits of v */ |
152 | for (i = 0; v & 1; v >>= 1, i++) | 152 | for (i = 0; v & 1; v >>= 1, i++) |
153 | /* empty */; | 153 | /* empty */; |
154 | ibf_insert(se->strata[i], key); | 154 | ibf_insert (se->strata[i], key); |
155 | } | 155 | } |
156 | 156 | ||
157 | 157 | ||
@@ -162,8 +162,8 @@ strata_estimator_insert(struct StrataEstimator *se, | |||
162 | * @param key key to remove | 162 | * @param key key to remove |
163 | */ | 163 | */ |
164 | void | 164 | void |
165 | strata_estimator_remove(struct StrataEstimator *se, | 165 | strata_estimator_remove (struct StrataEstimator *se, |
166 | struct IBF_Key key) | 166 | struct IBF_Key key) |
167 | { | 167 | { |
168 | uint64_t v; | 168 | uint64_t v; |
169 | unsigned int i; | 169 | unsigned int i; |
@@ -172,7 +172,7 @@ strata_estimator_remove(struct StrataEstimator *se, | |||
172 | /* count trailing '1'-bits of v */ | 172 | /* count trailing '1'-bits of v */ |
173 | for (i = 0; v & 1; v >>= 1, i++) | 173 | for (i = 0; v & 1; v >>= 1, i++) |
174 | /* empty */; | 174 | /* empty */; |
175 | ibf_remove(se->strata[i], key); | 175 | ibf_remove (se->strata[i], key); |
176 | } | 176 | } |
177 | 177 | ||
178 | 178 | ||
@@ -185,32 +185,32 @@ strata_estimator_remove(struct StrataEstimator *se, | |||
185 | * @return a freshly allocated, empty strata estimator, NULL on error | 185 | * @return a freshly allocated, empty strata estimator, NULL on error |
186 | */ | 186 | */ |
187 | struct StrataEstimator * | 187 | struct StrataEstimator * |
188 | strata_estimator_create(unsigned int strata_count, | 188 | strata_estimator_create (unsigned int strata_count, |
189 | uint32_t ibf_size, | 189 | uint32_t ibf_size, |
190 | uint8_t ibf_hashnum) | 190 | uint8_t ibf_hashnum) |
191 | { | 191 | { |
192 | struct StrataEstimator *se; | 192 | struct StrataEstimator *se; |
193 | unsigned int i; | 193 | unsigned int i; |
194 | unsigned int j; | 194 | unsigned int j; |
195 | 195 | ||
196 | se = GNUNET_new(struct StrataEstimator); | 196 | se = GNUNET_new (struct StrataEstimator); |
197 | se->strata_count = strata_count; | 197 | se->strata_count = strata_count; |
198 | se->ibf_size = ibf_size; | 198 | se->ibf_size = ibf_size; |
199 | se->strata = GNUNET_new_array(strata_count, | 199 | se->strata = GNUNET_new_array (strata_count, |
200 | struct InvertibleBloomFilter *); | 200 | struct InvertibleBloomFilter *); |
201 | for (i = 0; i < strata_count; i++) | 201 | for (i = 0; i < strata_count; i++) |
202 | { | ||
203 | se->strata[i] = ibf_create (ibf_size, ibf_hashnum); | ||
204 | if (NULL == se->strata[i]) | ||
202 | { | 205 | { |
203 | se->strata[i] = ibf_create(ibf_size, ibf_hashnum); | 206 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
204 | if (NULL == se->strata[i]) | 207 | "Failed to allocate memory for strata estimator\n"); |
205 | { | 208 | for (j = 0; j < i; j++) |
206 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 209 | ibf_destroy (se->strata[i]); |
207 | "Failed to allocate memory for strata estimator\n"); | 210 | GNUNET_free (se); |
208 | for (j = 0; j < i; j++) | 211 | return NULL; |
209 | ibf_destroy(se->strata[i]); | ||
210 | GNUNET_free(se); | ||
211 | return NULL; | ||
212 | } | ||
213 | } | 212 | } |
213 | } | ||
214 | return se; | 214 | return se; |
215 | } | 215 | } |
216 | 216 | ||
@@ -225,40 +225,40 @@ strata_estimator_create(unsigned int strata_count, | |||
225 | * @return the estimated difference | 225 | * @return the estimated difference |
226 | */ | 226 | */ |
227 | unsigned int | 227 | unsigned int |
228 | strata_estimator_difference(const struct StrataEstimator *se1, | 228 | strata_estimator_difference (const struct StrataEstimator *se1, |
229 | const struct StrataEstimator *se2) | 229 | const struct StrataEstimator *se2) |
230 | { | 230 | { |
231 | unsigned int count; | 231 | unsigned int count; |
232 | 232 | ||
233 | GNUNET_assert(se1->strata_count == se2->strata_count); | 233 | GNUNET_assert (se1->strata_count == se2->strata_count); |
234 | count = 0; | 234 | count = 0; |
235 | for (int i = se1->strata_count - 1; i >= 0; i--) | 235 | for (int i = se1->strata_count - 1; i >= 0; i--) |
236 | { | ||
237 | struct InvertibleBloomFilter *diff; | ||
238 | /* number of keys decoded from the ibf */ | ||
239 | |||
240 | /* FIXME: implement this without always allocating new IBFs */ | ||
241 | diff = ibf_dup (se1->strata[i]); | ||
242 | ibf_subtract (diff, se2->strata[i]); | ||
243 | for (int ibf_count = 0; GNUNET_YES; ibf_count++) | ||
236 | { | 244 | { |
237 | struct InvertibleBloomFilter *diff; | 245 | int more; |
238 | /* number of keys decoded from the ibf */ | 246 | |
239 | 247 | more = ibf_decode (diff, NULL, NULL); | |
240 | /* FIXME: implement this without always allocating new IBFs */ | 248 | if (GNUNET_NO == more) |
241 | diff = ibf_dup(se1->strata[i]); | 249 | { |
242 | ibf_subtract(diff, se2->strata[i]); | 250 | count += ibf_count; |
243 | for (int ibf_count = 0; GNUNET_YES; ibf_count++) | 251 | break; |
244 | { | 252 | } |
245 | int more; | 253 | /* Estimate if decoding fails or would not terminate */ |
246 | 254 | if ((GNUNET_SYSERR == more) || (ibf_count > diff->size)) | |
247 | more = ibf_decode(diff, NULL, NULL); | 255 | { |
248 | if (GNUNET_NO == more) | 256 | ibf_destroy (diff); |
249 | { | 257 | return count * (1 << (i + 1)); |
250 | count += ibf_count; | 258 | } |
251 | break; | ||
252 | } | ||
253 | /* Estimate if decoding fails or would not terminate */ | ||
254 | if ((GNUNET_SYSERR == more) || (ibf_count > diff->size)) | ||
255 | { | ||
256 | ibf_destroy(diff); | ||
257 | return count * (1 << (i + 1)); | ||
258 | } | ||
259 | } | ||
260 | ibf_destroy(diff); | ||
261 | } | 259 | } |
260 | ibf_destroy (diff); | ||
261 | } | ||
262 | return count; | 262 | return count; |
263 | } | 263 | } |
264 | 264 | ||
@@ -270,18 +270,18 @@ strata_estimator_difference(const struct StrataEstimator *se1, | |||
270 | * @return the copy | 270 | * @return the copy |
271 | */ | 271 | */ |
272 | struct StrataEstimator * | 272 | struct StrataEstimator * |
273 | strata_estimator_dup(struct StrataEstimator *se) | 273 | strata_estimator_dup (struct StrataEstimator *se) |
274 | { | 274 | { |
275 | struct StrataEstimator *c; | 275 | struct StrataEstimator *c; |
276 | unsigned int i; | 276 | unsigned int i; |
277 | 277 | ||
278 | c = GNUNET_new(struct StrataEstimator); | 278 | c = GNUNET_new (struct StrataEstimator); |
279 | c->strata_count = se->strata_count; | 279 | c->strata_count = se->strata_count; |
280 | c->ibf_size = se->ibf_size; | 280 | c->ibf_size = se->ibf_size; |
281 | c->strata = GNUNET_new_array(se->strata_count, | 281 | c->strata = GNUNET_new_array (se->strata_count, |
282 | struct InvertibleBloomFilter *); | 282 | struct InvertibleBloomFilter *); |
283 | for (i = 0; i < se->strata_count; i++) | 283 | for (i = 0; i < se->strata_count; i++) |
284 | c->strata[i] = ibf_dup(se->strata[i]); | 284 | c->strata[i] = ibf_dup (se->strata[i]); |
285 | return c; | 285 | return c; |
286 | } | 286 | } |
287 | 287 | ||
@@ -292,12 +292,12 @@ strata_estimator_dup(struct StrataEstimator *se) | |||
292 | * @param se strata estimator to destroy. | 292 | * @param se strata estimator to destroy. |
293 | */ | 293 | */ |
294 | void | 294 | void |
295 | strata_estimator_destroy(struct StrataEstimator *se) | 295 | strata_estimator_destroy (struct StrataEstimator *se) |
296 | { | 296 | { |
297 | unsigned int i; | 297 | unsigned int i; |
298 | 298 | ||
299 | for (i = 0; i < se->strata_count; i++) | 299 | for (i = 0; i < se->strata_count; i++) |
300 | ibf_destroy(se->strata[i]); | 300 | ibf_destroy (se->strata[i]); |
301 | GNUNET_free(se->strata); | 301 | GNUNET_free (se->strata); |
302 | GNUNET_free(se); | 302 | GNUNET_free (se); |
303 | } | 303 | } |
diff --git a/src/set/gnunet-service-set_union_strata_estimator.h b/src/set/gnunet-service-set_union_strata_estimator.h index 2c09e1089..94267a2dc 100644 --- a/src/set/gnunet-service-set_union_strata_estimator.h +++ b/src/set/gnunet-service-set_union_strata_estimator.h | |||
@@ -43,7 +43,8 @@ extern "C" | |||
43 | /** | 43 | /** |
44 | * A handle to a strata estimator. | 44 | * A handle to a strata estimator. |
45 | */ | 45 | */ |
46 | struct StrataEstimator { | 46 | struct StrataEstimator |
47 | { | ||
47 | /** | 48 | /** |
48 | * The IBFs of this strata estimator. | 49 | * The IBFs of this strata estimator. |
49 | */ | 50 | */ |
@@ -69,8 +70,8 @@ struct StrataEstimator { | |||
69 | * @return number of bytes written to @a buf | 70 | * @return number of bytes written to @a buf |
70 | */ | 71 | */ |
71 | size_t | 72 | size_t |
72 | strata_estimator_write(const struct StrataEstimator *se, | 73 | strata_estimator_write (const struct StrataEstimator *se, |
73 | void *buf); | 74 | void *buf); |
74 | 75 | ||
75 | 76 | ||
76 | /** | 77 | /** |
@@ -84,10 +85,10 @@ strata_estimator_write(const struct StrataEstimator *se, | |||
84 | * @return #GNUNET_OK on success | 85 | * @return #GNUNET_OK on success |
85 | */ | 86 | */ |
86 | int | 87 | int |
87 | strata_estimator_read(const void *buf, | 88 | strata_estimator_read (const void *buf, |
88 | size_t buf_len, | 89 | size_t buf_len, |
89 | int is_compressed, | 90 | int is_compressed, |
90 | struct StrataEstimator *se); | 91 | struct StrataEstimator *se); |
91 | 92 | ||
92 | 93 | ||
93 | /** | 94 | /** |
@@ -99,9 +100,9 @@ strata_estimator_read(const void *buf, | |||
99 | * @return a freshly allocated, empty strata estimator, NULL on error | 100 | * @return a freshly allocated, empty strata estimator, NULL on error |
100 | */ | 101 | */ |
101 | struct StrataEstimator * | 102 | struct StrataEstimator * |
102 | strata_estimator_create(unsigned int strata_count, | 103 | strata_estimator_create (unsigned int strata_count, |
103 | uint32_t ibf_size, | 104 | uint32_t ibf_size, |
104 | uint8_t ibf_hashnum); | 105 | uint8_t ibf_hashnum); |
105 | 106 | ||
106 | 107 | ||
107 | /** | 108 | /** |
@@ -113,8 +114,8 @@ strata_estimator_create(unsigned int strata_count, | |||
113 | * @return abs(|se1| - |se2|) | 114 | * @return abs(|se1| - |se2|) |
114 | */ | 115 | */ |
115 | unsigned int | 116 | unsigned int |
116 | strata_estimator_difference(const struct StrataEstimator *se1, | 117 | strata_estimator_difference (const struct StrataEstimator *se1, |
117 | const struct StrataEstimator *se2); | 118 | const struct StrataEstimator *se2); |
118 | 119 | ||
119 | 120 | ||
120 | /** | 121 | /** |
@@ -124,8 +125,8 @@ strata_estimator_difference(const struct StrataEstimator *se1, | |||
124 | * @param key key to add | 125 | * @param key key to add |
125 | */ | 126 | */ |
126 | void | 127 | void |
127 | strata_estimator_insert(struct StrataEstimator *se, | 128 | strata_estimator_insert (struct StrataEstimator *se, |
128 | struct IBF_Key key); | 129 | struct IBF_Key key); |
129 | 130 | ||
130 | 131 | ||
131 | /** | 132 | /** |
@@ -135,8 +136,8 @@ strata_estimator_insert(struct StrataEstimator *se, | |||
135 | * @param key key to remove | 136 | * @param key key to remove |
136 | */ | 137 | */ |
137 | void | 138 | void |
138 | strata_estimator_remove(struct StrataEstimator *se, | 139 | strata_estimator_remove (struct StrataEstimator *se, |
139 | struct IBF_Key key); | 140 | struct IBF_Key key); |
140 | 141 | ||
141 | 142 | ||
142 | /** | 143 | /** |
@@ -145,7 +146,7 @@ strata_estimator_remove(struct StrataEstimator *se, | |||
145 | * @param se strata estimator to destroy. | 146 | * @param se strata estimator to destroy. |
146 | */ | 147 | */ |
147 | void | 148 | void |
148 | strata_estimator_destroy(struct StrataEstimator *se); | 149 | strata_estimator_destroy (struct StrataEstimator *se); |
149 | 150 | ||
150 | 151 | ||
151 | /** | 152 | /** |
@@ -155,7 +156,7 @@ strata_estimator_destroy(struct StrataEstimator *se); | |||
155 | * @return the copy | 156 | * @return the copy |
156 | */ | 157 | */ |
157 | struct StrataEstimator * | 158 | struct StrataEstimator * |
158 | strata_estimator_dup(struct StrataEstimator *se); | 159 | strata_estimator_dup (struct StrataEstimator *se); |
159 | 160 | ||
160 | 161 | ||
161 | #if 0 /* keep Emacsens' auto-indent happy */ | 162 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/set/gnunet-set-ibf-profiler.c b/src/set/gnunet-set-ibf-profiler.c index c54557fb0..944b63d30 100644 --- a/src/set/gnunet-set-ibf-profiler.c +++ b/src/set/gnunet-set-ibf-profiler.c | |||
@@ -50,62 +50,62 @@ static struct InvertibleBloomFilter *ibf_b; | |||
50 | 50 | ||
51 | 51 | ||
52 | static void | 52 | static void |
53 | register_hashcode(struct GNUNET_HashCode *hash) | 53 | register_hashcode (struct GNUNET_HashCode *hash) |
54 | { | 54 | { |
55 | struct GNUNET_HashCode replicated; | 55 | struct GNUNET_HashCode replicated; |
56 | struct IBF_Key key; | 56 | struct IBF_Key key; |
57 | 57 | ||
58 | key = ibf_key_from_hashcode(hash); | 58 | key = ibf_key_from_hashcode (hash); |
59 | ibf_hashcode_from_key(key, &replicated); | 59 | ibf_hashcode_from_key (key, &replicated); |
60 | (void)GNUNET_CONTAINER_multihashmap_put( | 60 | (void) GNUNET_CONTAINER_multihashmap_put ( |
61 | key_to_hashcode, | 61 | key_to_hashcode, |
62 | &replicated, | 62 | &replicated, |
63 | GNUNET_memdup(hash, sizeof *hash), | 63 | GNUNET_memdup (hash, sizeof *hash), |
64 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); | 64 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); |
65 | } | 65 | } |
66 | 66 | ||
67 | 67 | ||
68 | static void | 68 | static void |
69 | iter_hashcodes(struct IBF_Key key, | 69 | iter_hashcodes (struct IBF_Key key, |
70 | GNUNET_CONTAINER_MulitHashMapIteratorCallback iter, | 70 | GNUNET_CONTAINER_MulitHashMapIteratorCallback iter, |
71 | void *cls) | 71 | void *cls) |
72 | { | 72 | { |
73 | struct GNUNET_HashCode replicated; | 73 | struct GNUNET_HashCode replicated; |
74 | 74 | ||
75 | ibf_hashcode_from_key(key, &replicated); | 75 | ibf_hashcode_from_key (key, &replicated); |
76 | GNUNET_CONTAINER_multihashmap_get_multiple(key_to_hashcode, | 76 | GNUNET_CONTAINER_multihashmap_get_multiple (key_to_hashcode, |
77 | &replicated, | 77 | &replicated, |
78 | iter, | 78 | iter, |
79 | cls); | 79 | cls); |
80 | } | 80 | } |
81 | 81 | ||
82 | 82 | ||
83 | static int | 83 | static int |
84 | insert_iterator(void *cls, const struct GNUNET_HashCode *key, void *value) | 84 | insert_iterator (void *cls, const struct GNUNET_HashCode *key, void *value) |
85 | { | 85 | { |
86 | struct InvertibleBloomFilter *ibf = cls; | 86 | struct InvertibleBloomFilter *ibf = cls; |
87 | 87 | ||
88 | ibf_insert(ibf, ibf_key_from_hashcode(key)); | 88 | ibf_insert (ibf, ibf_key_from_hashcode (key)); |
89 | return GNUNET_YES; | 89 | return GNUNET_YES; |
90 | } | 90 | } |
91 | 91 | ||
92 | 92 | ||
93 | static int | 93 | static int |
94 | remove_iterator(void *cls, const struct GNUNET_HashCode *key, void *value) | 94 | remove_iterator (void *cls, const struct GNUNET_HashCode *key, void *value) |
95 | { | 95 | { |
96 | struct GNUNET_CONTAINER_MultiHashMap *hashmap = cls; | 96 | struct GNUNET_CONTAINER_MultiHashMap *hashmap = cls; |
97 | 97 | ||
98 | /* if remove fails, there just was a collision with another key */ | 98 | /* if remove fails, there just was a collision with another key */ |
99 | (void)GNUNET_CONTAINER_multihashmap_remove(hashmap, value, NULL); | 99 | (void) GNUNET_CONTAINER_multihashmap_remove (hashmap, value, NULL); |
100 | return GNUNET_YES; | 100 | return GNUNET_YES; |
101 | } | 101 | } |
102 | 102 | ||
103 | 103 | ||
104 | static void | 104 | static void |
105 | run(void *cls, | 105 | run (void *cls, |
106 | char *const *args, | 106 | char *const *args, |
107 | const char *cfgfile, | 107 | const char *cfgfile, |
108 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 108 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
109 | { | 109 | { |
110 | struct GNUNET_HashCode id; | 110 | struct GNUNET_HashCode id; |
111 | struct IBF_Key ibf_key; | 111 | struct IBF_Key ibf_key; |
@@ -116,193 +116,193 @@ run(void *cls, | |||
116 | struct GNUNET_TIME_Relative delta_time; | 116 | struct GNUNET_TIME_Relative delta_time; |
117 | 117 | ||
118 | set_a = | 118 | set_a = |
119 | GNUNET_CONTAINER_multihashmap_create(((asize == 0) ? 1 : (asize + csize)), | 119 | GNUNET_CONTAINER_multihashmap_create (((asize == 0) ? 1 : (asize + csize)), |
120 | GNUNET_NO); | 120 | GNUNET_NO); |
121 | set_b = | 121 | set_b = |
122 | GNUNET_CONTAINER_multihashmap_create(((bsize == 0) ? 1 : (bsize + csize)), | 122 | GNUNET_CONTAINER_multihashmap_create (((bsize == 0) ? 1 : (bsize + csize)), |
123 | GNUNET_NO); | 123 | GNUNET_NO); |
124 | set_c = GNUNET_CONTAINER_multihashmap_create(((csize == 0) ? 1 : csize), | 124 | set_c = GNUNET_CONTAINER_multihashmap_create (((csize == 0) ? 1 : csize), |
125 | GNUNET_NO); | 125 | GNUNET_NO); |
126 | 126 | ||
127 | key_to_hashcode = | 127 | key_to_hashcode = |
128 | GNUNET_CONTAINER_multihashmap_create(((asize + bsize + csize == 0) | 128 | GNUNET_CONTAINER_multihashmap_create (((asize + bsize + csize == 0) |
129 | ? 1 | 129 | ? 1 |
130 | : (asize + bsize + csize)), | 130 | : (asize + bsize + csize)), |
131 | GNUNET_NO); | 131 | GNUNET_NO); |
132 | 132 | ||
133 | printf("hash-num=%u, size=%u, #(A-B)=%u, #(B-A)=%u, #(A&B)=%u\n", | 133 | printf ("hash-num=%u, size=%u, #(A-B)=%u, #(B-A)=%u, #(A&B)=%u\n", |
134 | hash_num, | 134 | hash_num, |
135 | ibf_size, | 135 | ibf_size, |
136 | asize, | 136 | asize, |
137 | bsize, | 137 | bsize, |
138 | csize); | 138 | csize); |
139 | 139 | ||
140 | i = 0; | 140 | i = 0; |
141 | while (i < asize) | 141 | while (i < asize) |
142 | { | 142 | { |
143 | GNUNET_CRYPTO_hash_create_random(random_quality, &id); | 143 | GNUNET_CRYPTO_hash_create_random (random_quality, &id); |
144 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_a, &id)) | 144 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id)) |
145 | continue; | 145 | continue; |
146 | GNUNET_break(GNUNET_OK == | 146 | GNUNET_break (GNUNET_OK == |
147 | GNUNET_CONTAINER_multihashmap_put( | 147 | GNUNET_CONTAINER_multihashmap_put ( |
148 | set_a, | 148 | set_a, |
149 | &id, | 149 | &id, |
150 | NULL, | 150 | NULL, |
151 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 151 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
152 | register_hashcode(&id); | 152 | register_hashcode (&id); |
153 | i++; | 153 | i++; |
154 | } | 154 | } |
155 | i = 0; | 155 | i = 0; |
156 | while (i < bsize) | 156 | while (i < bsize) |
157 | { | 157 | { |
158 | GNUNET_CRYPTO_hash_create_random(random_quality, &id); | 158 | GNUNET_CRYPTO_hash_create_random (random_quality, &id); |
159 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_a, &id)) | 159 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id)) |
160 | continue; | 160 | continue; |
161 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_b, &id)) | 161 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id)) |
162 | continue; | 162 | continue; |
163 | GNUNET_break(GNUNET_OK == | 163 | GNUNET_break (GNUNET_OK == |
164 | GNUNET_CONTAINER_multihashmap_put( | 164 | GNUNET_CONTAINER_multihashmap_put ( |
165 | set_b, | 165 | set_b, |
166 | &id, | 166 | &id, |
167 | NULL, | 167 | NULL, |
168 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 168 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
169 | register_hashcode(&id); | 169 | register_hashcode (&id); |
170 | i++; | 170 | i++; |
171 | } | 171 | } |
172 | i = 0; | 172 | i = 0; |
173 | while (i < csize) | 173 | while (i < csize) |
174 | { | 174 | { |
175 | GNUNET_CRYPTO_hash_create_random(random_quality, &id); | 175 | GNUNET_CRYPTO_hash_create_random (random_quality, &id); |
176 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_a, &id)) | 176 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id)) |
177 | continue; | 177 | continue; |
178 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_b, &id)) | 178 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id)) |
179 | continue; | 179 | continue; |
180 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(set_c, &id)) | 180 | if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_c, &id)) |
181 | continue; | 181 | continue; |
182 | GNUNET_break(GNUNET_OK == | 182 | GNUNET_break (GNUNET_OK == |
183 | GNUNET_CONTAINER_multihashmap_put( | 183 | GNUNET_CONTAINER_multihashmap_put ( |
184 | set_c, | 184 | set_c, |
185 | &id, | 185 | &id, |
186 | NULL, | 186 | NULL, |
187 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 187 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); |
188 | register_hashcode(&id); | 188 | register_hashcode (&id); |
189 | i++; | 189 | i++; |
190 | } | 190 | } |
191 | 191 | ||
192 | ibf_a = ibf_create(ibf_size, hash_num); | 192 | ibf_a = ibf_create (ibf_size, hash_num); |
193 | ibf_b = ibf_create(ibf_size, hash_num); | 193 | ibf_b = ibf_create (ibf_size, hash_num); |
194 | if ((NULL == ibf_a) || (NULL == ibf_b)) | 194 | if ((NULL == ibf_a) || (NULL == ibf_b)) |
195 | { | 195 | { |
196 | /* insufficient memory */ | 196 | /* insufficient memory */ |
197 | GNUNET_break(0); | 197 | GNUNET_break (0); |
198 | GNUNET_SCHEDULER_shutdown(); | 198 | GNUNET_SCHEDULER_shutdown (); |
199 | return; | 199 | return; |
200 | } | 200 | } |
201 | 201 | ||
202 | 202 | ||
203 | printf("generated sets\n"); | 203 | printf ("generated sets\n"); |
204 | 204 | ||
205 | start_time = GNUNET_TIME_absolute_get(); | 205 | start_time = GNUNET_TIME_absolute_get (); |
206 | 206 | ||
207 | GNUNET_CONTAINER_multihashmap_iterate(set_a, &insert_iterator, ibf_a); | 207 | GNUNET_CONTAINER_multihashmap_iterate (set_a, &insert_iterator, ibf_a); |
208 | GNUNET_CONTAINER_multihashmap_iterate(set_b, &insert_iterator, ibf_b); | 208 | GNUNET_CONTAINER_multihashmap_iterate (set_b, &insert_iterator, ibf_b); |
209 | GNUNET_CONTAINER_multihashmap_iterate(set_c, &insert_iterator, ibf_a); | 209 | GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_a); |
210 | GNUNET_CONTAINER_multihashmap_iterate(set_c, &insert_iterator, ibf_b); | 210 | GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_b); |
211 | 211 | ||
212 | delta_time = GNUNET_TIME_absolute_get_duration(start_time); | 212 | delta_time = GNUNET_TIME_absolute_get_duration (start_time); |
213 | 213 | ||
214 | printf("encoded in: %s\n", | 214 | printf ("encoded in: %s\n", |
215 | GNUNET_STRINGS_relative_time_to_string(delta_time, GNUNET_NO)); | 215 | GNUNET_STRINGS_relative_time_to_string (delta_time, GNUNET_NO)); |
216 | 216 | ||
217 | ibf_subtract(ibf_a, ibf_b); | 217 | ibf_subtract (ibf_a, ibf_b); |
218 | 218 | ||
219 | 219 | ||
220 | start_time = GNUNET_TIME_absolute_get(); | 220 | start_time = GNUNET_TIME_absolute_get (); |
221 | 221 | ||
222 | for (i = 0; i <= asize + bsize; i++) | 222 | for (i = 0; i <= asize + bsize; i++) |
223 | { | ||
224 | res = ibf_decode (ibf_a, &side, &ibf_key); | ||
225 | if (GNUNET_SYSERR == res) | ||
223 | { | 226 | { |
224 | res = ibf_decode(ibf_a, &side, &ibf_key); | 227 | printf ("decode failed, %u/%u elements left\n", |
225 | if (GNUNET_SYSERR == res) | 228 | GNUNET_CONTAINER_multihashmap_size (set_a) |
226 | { | 229 | + GNUNET_CONTAINER_multihashmap_size (set_b), |
227 | printf("decode failed, %u/%u elements left\n", | 230 | asize + bsize); |
228 | GNUNET_CONTAINER_multihashmap_size(set_a) + | 231 | return; |
229 | GNUNET_CONTAINER_multihashmap_size(set_b), | ||
230 | asize + bsize); | ||
231 | return; | ||
232 | } | ||
233 | if (GNUNET_NO == res) | ||
234 | { | ||
235 | if ((0 == GNUNET_CONTAINER_multihashmap_size(set_b)) && | ||
236 | (0 == GNUNET_CONTAINER_multihashmap_size(set_a))) | ||
237 | { | ||
238 | delta_time = GNUNET_TIME_absolute_get_duration(start_time); | ||
239 | printf("decoded successfully in: %s\n", | ||
240 | GNUNET_STRINGS_relative_time_to_string(delta_time, GNUNET_NO)); | ||
241 | } | ||
242 | else | ||
243 | { | ||
244 | printf("decode missed elements (should never happen)\n"); | ||
245 | } | ||
246 | return; | ||
247 | } | ||
248 | |||
249 | if (side == 1) | ||
250 | iter_hashcodes(ibf_key, remove_iterator, set_a); | ||
251 | if (side == -1) | ||
252 | iter_hashcodes(ibf_key, remove_iterator, set_b); | ||
253 | } | 232 | } |
254 | printf("cyclic IBF, %u/%u elements left\n", | 233 | if (GNUNET_NO == res) |
255 | GNUNET_CONTAINER_multihashmap_size(set_a) + | 234 | { |
256 | GNUNET_CONTAINER_multihashmap_size(set_b), | 235 | if ((0 == GNUNET_CONTAINER_multihashmap_size (set_b)) && |
257 | asize + bsize); | 236 | (0 == GNUNET_CONTAINER_multihashmap_size (set_a))) |
237 | { | ||
238 | delta_time = GNUNET_TIME_absolute_get_duration (start_time); | ||
239 | printf ("decoded successfully in: %s\n", | ||
240 | GNUNET_STRINGS_relative_time_to_string (delta_time, GNUNET_NO)); | ||
241 | } | ||
242 | else | ||
243 | { | ||
244 | printf ("decode missed elements (should never happen)\n"); | ||
245 | } | ||
246 | return; | ||
247 | } | ||
248 | |||
249 | if (side == 1) | ||
250 | iter_hashcodes (ibf_key, remove_iterator, set_a); | ||
251 | if (side == -1) | ||
252 | iter_hashcodes (ibf_key, remove_iterator, set_b); | ||
253 | } | ||
254 | printf ("cyclic IBF, %u/%u elements left\n", | ||
255 | GNUNET_CONTAINER_multihashmap_size (set_a) | ||
256 | + GNUNET_CONTAINER_multihashmap_size (set_b), | ||
257 | asize + bsize); | ||
258 | } | 258 | } |
259 | 259 | ||
260 | 260 | ||
261 | int | 261 | int |
262 | main(int argc, char **argv) | 262 | main (int argc, char **argv) |
263 | { | 263 | { |
264 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 264 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
265 | GNUNET_GETOPT_option_uint('A', | 265 | GNUNET_GETOPT_option_uint ('A', |
266 | "asize", | 266 | "asize", |
267 | NULL, | 267 | NULL, |
268 | gettext_noop("number of element in set A-B"), | 268 | gettext_noop ("number of element in set A-B"), |
269 | &asize), | 269 | &asize), |
270 | 270 | ||
271 | GNUNET_GETOPT_option_uint('B', | 271 | GNUNET_GETOPT_option_uint ('B', |
272 | "bsize", | 272 | "bsize", |
273 | NULL, | 273 | NULL, |
274 | gettext_noop("number of element in set B-A"), | 274 | gettext_noop ("number of element in set B-A"), |
275 | &bsize), | 275 | &bsize), |
276 | 276 | ||
277 | GNUNET_GETOPT_option_uint('C', | 277 | GNUNET_GETOPT_option_uint ('C', |
278 | "csize", | 278 | "csize", |
279 | NULL, | 279 | NULL, |
280 | gettext_noop( | 280 | gettext_noop ( |
281 | "number of common elements in A and B"), | 281 | "number of common elements in A and B"), |
282 | &csize), | 282 | &csize), |
283 | 283 | ||
284 | GNUNET_GETOPT_option_uint('k', | 284 | GNUNET_GETOPT_option_uint ('k', |
285 | "hash-num", | 285 | "hash-num", |
286 | NULL, | 286 | NULL, |
287 | gettext_noop("hash num"), | 287 | gettext_noop ("hash num"), |
288 | &hash_num), | 288 | &hash_num), |
289 | 289 | ||
290 | GNUNET_GETOPT_option_uint('s', | 290 | GNUNET_GETOPT_option_uint ('s', |
291 | "ibf-size", | 291 | "ibf-size", |
292 | NULL, | 292 | NULL, |
293 | gettext_noop("ibf size"), | 293 | gettext_noop ("ibf size"), |
294 | &ibf_size), | 294 | &ibf_size), |
295 | 295 | ||
296 | GNUNET_GETOPT_OPTION_END | 296 | GNUNET_GETOPT_OPTION_END |
297 | }; | 297 | }; |
298 | 298 | ||
299 | GNUNET_PROGRAM_run2(argc, | 299 | GNUNET_PROGRAM_run2 (argc, |
300 | argv, | 300 | argv, |
301 | "gnunet-consensus-ibf", | 301 | "gnunet-consensus-ibf", |
302 | "help", | 302 | "help", |
303 | options, | 303 | options, |
304 | &run, | 304 | &run, |
305 | NULL, | 305 | NULL, |
306 | GNUNET_YES); | 306 | GNUNET_YES); |
307 | return 0; | 307 | return 0; |
308 | } | 308 | } |
diff --git a/src/set/gnunet-set-profiler.c b/src/set/gnunet-set-profiler.c index 4fabc8388..81263966a 100644 --- a/src/set/gnunet-set-profiler.c +++ b/src/set/gnunet-set-profiler.c | |||
@@ -40,7 +40,8 @@ static char *op_str = "union"; | |||
40 | 40 | ||
41 | const static struct GNUNET_CONFIGURATION_Handle *config; | 41 | const static struct GNUNET_CONFIGURATION_Handle *config; |
42 | 42 | ||
43 | struct SetInfo { | 43 | struct SetInfo |
44 | { | ||
44 | char *id; | 45 | char *id; |
45 | struct GNUNET_SET_Handle *set; | 46 | struct GNUNET_SET_Handle *set; |
46 | struct GNUNET_SET_OperationHandle *oh; | 47 | struct GNUNET_SET_OperationHandle *oh; |
@@ -81,18 +82,18 @@ static FILE *statistics_file; | |||
81 | 82 | ||
82 | 83 | ||
83 | static int | 84 | static int |
84 | map_remove_iterator(void *cls, | 85 | map_remove_iterator (void *cls, |
85 | const struct GNUNET_HashCode *key, | 86 | const struct GNUNET_HashCode *key, |
86 | void *value) | 87 | void *value) |
87 | { | 88 | { |
88 | struct GNUNET_CONTAINER_MultiHashMap *m = cls; | 89 | struct GNUNET_CONTAINER_MultiHashMap *m = cls; |
89 | int ret; | 90 | int ret; |
90 | 91 | ||
91 | GNUNET_assert(NULL != key); | 92 | GNUNET_assert (NULL != key); |
92 | 93 | ||
93 | ret = GNUNET_CONTAINER_multihashmap_remove_all(m, key); | 94 | ret = GNUNET_CONTAINER_multihashmap_remove_all (m, key); |
94 | if (GNUNET_OK != ret) | 95 | if (GNUNET_OK != ret) |
95 | printf("spurious element\n"); | 96 | printf ("spurious element\n"); |
96 | return GNUNET_YES; | 97 | return GNUNET_YES; |
97 | } | 98 | } |
98 | 99 | ||
@@ -108,162 +109,170 @@ map_remove_iterator(void *cls, | |||
108 | * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration | 109 | * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration |
109 | */ | 110 | */ |
110 | static int | 111 | static int |
111 | statistics_result(void *cls, | 112 | statistics_result (void *cls, |
112 | const char *subsystem, | 113 | const char *subsystem, |
113 | const char *name, | 114 | const char *name, |
114 | uint64_t value, | 115 | uint64_t value, |
115 | int is_persistent) | 116 | int is_persistent) |
116 | { | 117 | { |
117 | if (NULL != statistics_file) | 118 | if (NULL != statistics_file) |
118 | { | 119 | { |
119 | fprintf(statistics_file, "%s\t%s\t%lu\n", subsystem, name, (unsigned long)value); | 120 | fprintf (statistics_file, "%s\t%s\t%lu\n", subsystem, name, (unsigned |
120 | } | 121 | long) value); |
122 | } | ||
121 | return GNUNET_OK; | 123 | return GNUNET_OK; |
122 | } | 124 | } |
123 | 125 | ||
124 | 126 | ||
125 | static void | 127 | static void |
126 | statistics_done(void *cls, | 128 | statistics_done (void *cls, |
127 | int success) | 129 | int success) |
128 | { | 130 | { |
129 | GNUNET_assert(GNUNET_YES == success); | 131 | GNUNET_assert (GNUNET_YES == success); |
130 | if (NULL != statistics_file) | 132 | if (NULL != statistics_file) |
131 | fclose(statistics_file); | 133 | fclose (statistics_file); |
132 | GNUNET_SCHEDULER_shutdown(); | 134 | GNUNET_SCHEDULER_shutdown (); |
133 | } | 135 | } |
134 | 136 | ||
135 | 137 | ||
136 | static void | 138 | static void |
137 | check_all_done(void) | 139 | check_all_done (void) |
138 | { | 140 | { |
139 | if (info1.done == GNUNET_NO || info2.done == GNUNET_NO) | 141 | if ((info1.done == GNUNET_NO)||(info2.done == GNUNET_NO)) |
140 | return; | 142 | return; |
141 | 143 | ||
142 | GNUNET_CONTAINER_multihashmap_iterate(info1.received, map_remove_iterator, info2.sent); | 144 | GNUNET_CONTAINER_multihashmap_iterate (info1.received, map_remove_iterator, |
143 | GNUNET_CONTAINER_multihashmap_iterate(info2.received, map_remove_iterator, info1.sent); | 145 | info2.sent); |
146 | GNUNET_CONTAINER_multihashmap_iterate (info2.received, map_remove_iterator, | ||
147 | info1.sent); | ||
144 | 148 | ||
145 | printf("set a: %d missing elements\n", GNUNET_CONTAINER_multihashmap_size(info1.sent)); | 149 | printf ("set a: %d missing elements\n", GNUNET_CONTAINER_multihashmap_size ( |
146 | printf("set b: %d missing elements\n", GNUNET_CONTAINER_multihashmap_size(info2.sent)); | 150 | info1.sent)); |
151 | printf ("set b: %d missing elements\n", GNUNET_CONTAINER_multihashmap_size ( | ||
152 | info2.sent)); | ||
147 | 153 | ||
148 | if (NULL == statistics_filename) | 154 | if (NULL == statistics_filename) |
149 | { | 155 | { |
150 | GNUNET_SCHEDULER_shutdown(); | 156 | GNUNET_SCHEDULER_shutdown (); |
151 | return; | 157 | return; |
152 | } | 158 | } |
153 | 159 | ||
154 | statistics_file = fopen(statistics_filename, "w"); | 160 | statistics_file = fopen (statistics_filename, "w"); |
155 | GNUNET_STATISTICS_get(statistics, NULL, NULL, | 161 | GNUNET_STATISTICS_get (statistics, NULL, NULL, |
156 | &statistics_done, | 162 | &statistics_done, |
157 | &statistics_result, NULL); | 163 | &statistics_result, NULL); |
158 | } | 164 | } |
159 | 165 | ||
160 | 166 | ||
161 | static void | 167 | static void |
162 | set_result_cb(void *cls, | 168 | set_result_cb (void *cls, |
163 | const struct GNUNET_SET_Element *element, | 169 | const struct GNUNET_SET_Element *element, |
164 | uint64_t current_size, | 170 | uint64_t current_size, |
165 | enum GNUNET_SET_Status status) | 171 | enum GNUNET_SET_Status status) |
166 | { | 172 | { |
167 | struct SetInfo *info = cls; | 173 | struct SetInfo *info = cls; |
168 | struct GNUNET_HashCode hash; | 174 | struct GNUNET_HashCode hash; |
169 | 175 | ||
170 | GNUNET_assert(GNUNET_NO == info->done); | 176 | GNUNET_assert (GNUNET_NO == info->done); |
171 | switch (status) | 177 | switch (status) |
172 | { | 178 | { |
173 | case GNUNET_SET_STATUS_DONE: | 179 | case GNUNET_SET_STATUS_DONE: |
174 | case GNUNET_SET_STATUS_HALF_DONE: | 180 | case GNUNET_SET_STATUS_HALF_DONE: |
175 | info->done = GNUNET_YES; | 181 | info->done = GNUNET_YES; |
176 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "set %s done\n", info->id); | 182 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "set %s done\n", info->id); |
177 | check_all_done(); | 183 | check_all_done (); |
178 | info->oh = NULL; | 184 | info->oh = NULL; |
179 | return; | 185 | return; |
180 | 186 | ||
181 | case GNUNET_SET_STATUS_FAILURE: | 187 | case GNUNET_SET_STATUS_FAILURE: |
182 | info->oh = NULL; | 188 | info->oh = NULL; |
183 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "failure\n"); | 189 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "failure\n"); |
184 | GNUNET_SCHEDULER_shutdown(); | 190 | GNUNET_SCHEDULER_shutdown (); |
185 | return; | 191 | return; |
186 | 192 | ||
187 | case GNUNET_SET_STATUS_ADD_LOCAL: | 193 | case GNUNET_SET_STATUS_ADD_LOCAL: |
188 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "set %s: local element\n", info->id); | 194 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "set %s: local element\n", info->id); |
189 | break; | 195 | break; |
190 | 196 | ||
191 | case GNUNET_SET_STATUS_ADD_REMOTE: | 197 | case GNUNET_SET_STATUS_ADD_REMOTE: |
192 | GNUNET_CRYPTO_hash(element->data, element->size, &hash); | 198 | GNUNET_CRYPTO_hash (element->data, element->size, &hash); |
193 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "set %s: remote element %s\n", info->id, | 199 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "set %s: remote element %s\n", info->id, |
194 | GNUNET_h2s(&hash)); | 200 | GNUNET_h2s (&hash)); |
195 | // XXX: record and check | 201 | // XXX: record and check |
196 | return; | 202 | return; |
197 | 203 | ||
198 | default: | 204 | default: |
199 | GNUNET_assert(0); | 205 | GNUNET_assert (0); |
200 | } | 206 | } |
201 | 207 | ||
202 | if (element->size != element_size) | 208 | if (element->size != element_size) |
203 | { | 209 | { |
204 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 210 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
205 | "wrong element size: %u, expected %u\n", | 211 | "wrong element size: %u, expected %u\n", |
206 | element->size, | 212 | element->size, |
207 | (unsigned int)sizeof(struct GNUNET_HashCode)); | 213 | (unsigned int) sizeof(struct GNUNET_HashCode)); |
208 | GNUNET_assert(0); | 214 | GNUNET_assert (0); |
209 | } | 215 | } |
210 | 216 | ||
211 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "set %s: got element (%s)\n", | 217 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "set %s: got element (%s)\n", |
212 | info->id, GNUNET_h2s(element->data)); | 218 | info->id, GNUNET_h2s (element->data)); |
213 | GNUNET_assert(NULL != element->data); | 219 | GNUNET_assert (NULL != element->data); |
214 | struct GNUNET_HashCode data_hash; | 220 | struct GNUNET_HashCode data_hash; |
215 | GNUNET_CRYPTO_hash(element->data, element_size, &data_hash); | 221 | GNUNET_CRYPTO_hash (element->data, element_size, &data_hash); |
216 | GNUNET_CONTAINER_multihashmap_put(info->received, | 222 | GNUNET_CONTAINER_multihashmap_put (info->received, |
217 | &data_hash, NULL, | 223 | &data_hash, NULL, |
218 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); | 224 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); |
219 | } | 225 | } |
220 | 226 | ||
221 | 227 | ||
222 | static void | 228 | static void |
223 | set_listen_cb(void *cls, | 229 | set_listen_cb (void *cls, |
224 | const struct GNUNET_PeerIdentity *other_peer, | 230 | const struct GNUNET_PeerIdentity *other_peer, |
225 | const struct GNUNET_MessageHeader *context_msg, | 231 | const struct GNUNET_MessageHeader *context_msg, |
226 | struct GNUNET_SET_Request *request) | 232 | struct GNUNET_SET_Request *request) |
227 | { | 233 | { |
228 | /* max. 2 options plus terminator */ | 234 | /* max. 2 options plus terminator */ |
229 | struct GNUNET_SET_Option opts[3] = { { 0 } }; | 235 | struct GNUNET_SET_Option opts[3] = { { 0 } }; |
230 | unsigned int n_opts = 0; | 236 | unsigned int n_opts = 0; |
231 | 237 | ||
232 | if (NULL == request) | 238 | if (NULL == request) |
233 | { | 239 | { |
234 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 240 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
235 | "listener failed\n"); | 241 | "listener failed\n"); |
236 | return; | 242 | return; |
237 | } | 243 | } |
238 | GNUNET_assert(NULL == info2.oh); | 244 | GNUNET_assert (NULL == info2.oh); |
239 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 245 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
240 | "set listen cb called\n"); | 246 | "set listen cb called\n"); |
241 | if (byzantine) | 247 | if (byzantine) |
242 | { | 248 | { |
243 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = GNUNET_SET_OPTION_BYZANTINE }; | 249 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = |
244 | } | 250 | GNUNET_SET_OPTION_BYZANTINE }; |
245 | GNUNET_assert(!(force_full && force_delta)); | 251 | } |
252 | GNUNET_assert (! (force_full && force_delta)); | ||
246 | if (force_full) | 253 | if (force_full) |
247 | { | 254 | { |
248 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = GNUNET_SET_OPTION_FORCE_FULL }; | 255 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = |
249 | } | 256 | GNUNET_SET_OPTION_FORCE_FULL }; |
257 | } | ||
250 | if (force_delta) | 258 | if (force_delta) |
251 | { | 259 | { |
252 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = GNUNET_SET_OPTION_FORCE_DELTA }; | 260 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = |
253 | } | 261 | GNUNET_SET_OPTION_FORCE_DELTA }; |
262 | } | ||
254 | 263 | ||
255 | opts[n_opts].type = 0; | 264 | opts[n_opts].type = 0; |
256 | info2.oh = GNUNET_SET_accept(request, GNUNET_SET_RESULT_SYMMETRIC, | 265 | info2.oh = GNUNET_SET_accept (request, GNUNET_SET_RESULT_SYMMETRIC, |
257 | opts, | 266 | opts, |
258 | set_result_cb, &info2); | 267 | set_result_cb, &info2); |
259 | GNUNET_SET_commit(info2.oh, info2.set); | 268 | GNUNET_SET_commit (info2.oh, info2.set); |
260 | } | 269 | } |
261 | 270 | ||
262 | 271 | ||
263 | static int | 272 | static int |
264 | set_insert_iterator(void *cls, | 273 | set_insert_iterator (void *cls, |
265 | const struct GNUNET_HashCode *key, | 274 | const struct GNUNET_HashCode *key, |
266 | void *value) | 275 | void *value) |
267 | { | 276 | { |
268 | struct GNUNET_SET_Handle *set = cls; | 277 | struct GNUNET_SET_Handle *set = cls; |
269 | struct GNUNET_SET_Element el; | 278 | struct GNUNET_SET_Element el; |
@@ -271,49 +280,49 @@ set_insert_iterator(void *cls, | |||
271 | el.element_type = 0; | 280 | el.element_type = 0; |
272 | el.data = value; | 281 | el.data = value; |
273 | el.size = element_size; | 282 | el.size = element_size; |
274 | GNUNET_SET_add_element(set, &el, NULL, NULL); | 283 | GNUNET_SET_add_element (set, &el, NULL, NULL); |
275 | return GNUNET_YES; | 284 | return GNUNET_YES; |
276 | } | 285 | } |
277 | 286 | ||
278 | 287 | ||
279 | static void | 288 | static void |
280 | handle_shutdown(void *cls) | 289 | handle_shutdown (void *cls) |
281 | { | 290 | { |
282 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 291 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
283 | "Shutting down set profiler\n"); | 292 | "Shutting down set profiler\n"); |
284 | if (NULL != set_listener) | 293 | if (NULL != set_listener) |
285 | { | 294 | { |
286 | GNUNET_SET_listen_cancel(set_listener); | 295 | GNUNET_SET_listen_cancel (set_listener); |
287 | set_listener = NULL; | 296 | set_listener = NULL; |
288 | } | 297 | } |
289 | if (NULL != info1.oh) | 298 | if (NULL != info1.oh) |
290 | { | 299 | { |
291 | GNUNET_SET_operation_cancel(info1.oh); | 300 | GNUNET_SET_operation_cancel (info1.oh); |
292 | info1.oh = NULL; | 301 | info1.oh = NULL; |
293 | } | 302 | } |
294 | if (NULL != info2.oh) | 303 | if (NULL != info2.oh) |
295 | { | 304 | { |
296 | GNUNET_SET_operation_cancel(info2.oh); | 305 | GNUNET_SET_operation_cancel (info2.oh); |
297 | info2.oh = NULL; | 306 | info2.oh = NULL; |
298 | } | 307 | } |
299 | if (NULL != info1.set) | 308 | if (NULL != info1.set) |
300 | { | 309 | { |
301 | GNUNET_SET_destroy(info1.set); | 310 | GNUNET_SET_destroy (info1.set); |
302 | info1.set = NULL; | 311 | info1.set = NULL; |
303 | } | 312 | } |
304 | if (NULL != info2.set) | 313 | if (NULL != info2.set) |
305 | { | 314 | { |
306 | GNUNET_SET_destroy(info2.set); | 315 | GNUNET_SET_destroy (info2.set); |
307 | info2.set = NULL; | 316 | info2.set = NULL; |
308 | } | 317 | } |
309 | GNUNET_STATISTICS_destroy(statistics, GNUNET_NO); | 318 | GNUNET_STATISTICS_destroy (statistics, GNUNET_NO); |
310 | } | 319 | } |
311 | 320 | ||
312 | 321 | ||
313 | static void | 322 | static void |
314 | run(void *cls, | 323 | run (void *cls, |
315 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 324 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
316 | struct GNUNET_TESTING_Peer *peer) | 325 | struct GNUNET_TESTING_Peer *peer) |
317 | { | 326 | { |
318 | unsigned int i; | 327 | unsigned int i; |
319 | struct GNUNET_HashCode hash; | 328 | struct GNUNET_HashCode hash; |
@@ -323,170 +332,177 @@ run(void *cls, | |||
323 | 332 | ||
324 | config = cfg; | 333 | config = cfg; |
325 | 334 | ||
326 | GNUNET_assert(element_size > 0); | 335 | GNUNET_assert (element_size > 0); |
327 | 336 | ||
328 | if (GNUNET_OK != GNUNET_CRYPTO_get_peer_identity(cfg, &local_peer)) | 337 | if (GNUNET_OK != GNUNET_CRYPTO_get_peer_identity (cfg, &local_peer)) |
329 | { | 338 | { |
330 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "could not retrieve host identity\n"); | 339 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "could not retrieve host identity\n"); |
331 | ret = 0; | 340 | ret = 0; |
332 | return; | 341 | return; |
333 | } | 342 | } |
334 | 343 | ||
335 | statistics = GNUNET_STATISTICS_create("set-profiler", cfg); | 344 | statistics = GNUNET_STATISTICS_create ("set-profiler", cfg); |
336 | 345 | ||
337 | GNUNET_SCHEDULER_add_shutdown(&handle_shutdown, NULL); | 346 | GNUNET_SCHEDULER_add_shutdown (&handle_shutdown, NULL); |
338 | 347 | ||
339 | info1.id = "a"; | 348 | info1.id = "a"; |
340 | info2.id = "b"; | 349 | info2.id = "b"; |
341 | 350 | ||
342 | info1.sent = GNUNET_CONTAINER_multihashmap_create(num_a + 1, GNUNET_NO); | 351 | info1.sent = GNUNET_CONTAINER_multihashmap_create (num_a + 1, GNUNET_NO); |
343 | info2.sent = GNUNET_CONTAINER_multihashmap_create(num_b + 1, GNUNET_NO); | 352 | info2.sent = GNUNET_CONTAINER_multihashmap_create (num_b + 1, GNUNET_NO); |
344 | common_sent = GNUNET_CONTAINER_multihashmap_create(num_c + 1, GNUNET_NO); | 353 | common_sent = GNUNET_CONTAINER_multihashmap_create (num_c + 1, GNUNET_NO); |
345 | 354 | ||
346 | info1.received = GNUNET_CONTAINER_multihashmap_create(num_a + 1, GNUNET_NO); | 355 | info1.received = GNUNET_CONTAINER_multihashmap_create (num_a + 1, GNUNET_NO); |
347 | info2.received = GNUNET_CONTAINER_multihashmap_create(num_b + 1, GNUNET_NO); | 356 | info2.received = GNUNET_CONTAINER_multihashmap_create (num_b + 1, GNUNET_NO); |
348 | 357 | ||
349 | for (i = 0; i < num_a; i++) | 358 | for (i = 0; i < num_a; i++) |
350 | { | 359 | { |
351 | char *data = GNUNET_malloc(element_size); | 360 | char *data = GNUNET_malloc (element_size); |
352 | GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, data, element_size); | 361 | GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, data, element_size); |
353 | GNUNET_CRYPTO_hash(data, element_size, &hash); | 362 | GNUNET_CRYPTO_hash (data, element_size, &hash); |
354 | GNUNET_CONTAINER_multihashmap_put(info1.sent, &hash, data, | 363 | GNUNET_CONTAINER_multihashmap_put (info1.sent, &hash, data, |
355 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); | 364 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); |
356 | } | 365 | } |
357 | 366 | ||
358 | for (i = 0; i < num_b; i++) | 367 | for (i = 0; i < num_b; i++) |
359 | { | 368 | { |
360 | char *data = GNUNET_malloc(element_size); | 369 | char *data = GNUNET_malloc (element_size); |
361 | GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, data, element_size); | 370 | GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, data, element_size); |
362 | GNUNET_CRYPTO_hash(data, element_size, &hash); | 371 | GNUNET_CRYPTO_hash (data, element_size, &hash); |
363 | GNUNET_CONTAINER_multihashmap_put(info2.sent, &hash, data, | 372 | GNUNET_CONTAINER_multihashmap_put (info2.sent, &hash, data, |
364 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); | 373 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); |
365 | } | 374 | } |
366 | 375 | ||
367 | for (i = 0; i < num_c; i++) | 376 | for (i = 0; i < num_c; i++) |
368 | { | 377 | { |
369 | char *data = GNUNET_malloc(element_size); | 378 | char *data = GNUNET_malloc (element_size); |
370 | GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_WEAK, data, element_size); | 379 | GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, data, element_size); |
371 | GNUNET_CRYPTO_hash(data, element_size, &hash); | 380 | GNUNET_CRYPTO_hash (data, element_size, &hash); |
372 | GNUNET_CONTAINER_multihashmap_put(common_sent, &hash, data, | 381 | GNUNET_CONTAINER_multihashmap_put (common_sent, &hash, data, |
373 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); | 382 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); |
374 | } | 383 | } |
375 | 384 | ||
376 | GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_STRONG, &app_id); | 385 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_STRONG, &app_id); |
377 | 386 | ||
378 | /* FIXME: also implement intersection etc. */ | 387 | /* FIXME: also implement intersection etc. */ |
379 | info1.set = GNUNET_SET_create(config, GNUNET_SET_OPERATION_UNION); | 388 | info1.set = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION); |
380 | info2.set = GNUNET_SET_create(config, GNUNET_SET_OPERATION_UNION); | 389 | info2.set = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION); |
381 | 390 | ||
382 | GNUNET_CONTAINER_multihashmap_iterate(info1.sent, set_insert_iterator, info1.set); | 391 | GNUNET_CONTAINER_multihashmap_iterate (info1.sent, set_insert_iterator, |
383 | GNUNET_CONTAINER_multihashmap_iterate(info2.sent, set_insert_iterator, info2.set); | 392 | info1.set); |
384 | GNUNET_CONTAINER_multihashmap_iterate(common_sent, set_insert_iterator, info1.set); | 393 | GNUNET_CONTAINER_multihashmap_iterate (info2.sent, set_insert_iterator, |
385 | GNUNET_CONTAINER_multihashmap_iterate(common_sent, set_insert_iterator, info2.set); | 394 | info2.set); |
395 | GNUNET_CONTAINER_multihashmap_iterate (common_sent, set_insert_iterator, | ||
396 | info1.set); | ||
397 | GNUNET_CONTAINER_multihashmap_iterate (common_sent, set_insert_iterator, | ||
398 | info2.set); | ||
386 | 399 | ||
387 | set_listener = GNUNET_SET_listen(config, GNUNET_SET_OPERATION_UNION, | 400 | set_listener = GNUNET_SET_listen (config, GNUNET_SET_OPERATION_UNION, |
388 | &app_id, set_listen_cb, NULL); | 401 | &app_id, set_listen_cb, NULL); |
389 | 402 | ||
390 | 403 | ||
391 | if (byzantine) | 404 | if (byzantine) |
392 | { | 405 | { |
393 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = GNUNET_SET_OPTION_BYZANTINE }; | 406 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = |
394 | } | 407 | GNUNET_SET_OPTION_BYZANTINE }; |
395 | GNUNET_assert(!(force_full && force_delta)); | 408 | } |
409 | GNUNET_assert (! (force_full && force_delta)); | ||
396 | if (force_full) | 410 | if (force_full) |
397 | { | 411 | { |
398 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = GNUNET_SET_OPTION_FORCE_FULL }; | 412 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = |
399 | } | 413 | GNUNET_SET_OPTION_FORCE_FULL }; |
414 | } | ||
400 | if (force_delta) | 415 | if (force_delta) |
401 | { | 416 | { |
402 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = GNUNET_SET_OPTION_FORCE_DELTA }; | 417 | opts[n_opts++] = (struct GNUNET_SET_Option) { .type = |
403 | } | 418 | GNUNET_SET_OPTION_FORCE_DELTA }; |
419 | } | ||
404 | 420 | ||
405 | opts[n_opts].type = 0; | 421 | opts[n_opts].type = 0; |
406 | 422 | ||
407 | info1.oh = GNUNET_SET_prepare(&local_peer, &app_id, NULL, | 423 | info1.oh = GNUNET_SET_prepare (&local_peer, &app_id, NULL, |
408 | GNUNET_SET_RESULT_SYMMETRIC, | 424 | GNUNET_SET_RESULT_SYMMETRIC, |
409 | opts, | 425 | opts, |
410 | set_result_cb, &info1); | 426 | set_result_cb, &info1); |
411 | GNUNET_SET_commit(info1.oh, info1.set); | 427 | GNUNET_SET_commit (info1.oh, info1.set); |
412 | GNUNET_SET_destroy(info1.set); | 428 | GNUNET_SET_destroy (info1.set); |
413 | info1.set = NULL; | 429 | info1.set = NULL; |
414 | } | 430 | } |
415 | 431 | ||
416 | 432 | ||
417 | static void | 433 | static void |
418 | pre_run(void *cls, char *const *args, const char *cfgfile, | 434 | pre_run (void *cls, char *const *args, const char *cfgfile, |
419 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 435 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
420 | { | 436 | { |
421 | if (0 != GNUNET_TESTING_peer_run("set-profiler", | 437 | if (0 != GNUNET_TESTING_peer_run ("set-profiler", |
422 | cfgfile, | 438 | cfgfile, |
423 | &run, NULL)) | 439 | &run, NULL)) |
424 | ret = 2; | 440 | ret = 2; |
425 | } | 441 | } |
426 | 442 | ||
427 | 443 | ||
428 | int | 444 | int |
429 | main(int argc, char **argv) | 445 | main (int argc, char **argv) |
430 | { | 446 | { |
431 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 447 | struct GNUNET_GETOPT_CommandLineOption options[] = { |
432 | GNUNET_GETOPT_option_uint('A', | 448 | GNUNET_GETOPT_option_uint ('A', |
433 | "num-first", | 449 | "num-first", |
434 | NULL, | 450 | NULL, |
435 | gettext_noop("number of values"), | 451 | gettext_noop ("number of values"), |
436 | &num_a), | 452 | &num_a), |
437 | 453 | ||
438 | GNUNET_GETOPT_option_uint('B', | 454 | GNUNET_GETOPT_option_uint ('B', |
439 | "num-second", | 455 | "num-second", |
440 | NULL, | 456 | NULL, |
441 | gettext_noop("number of values"), | 457 | gettext_noop ("number of values"), |
442 | &num_b), | 458 | &num_b), |
443 | 459 | ||
444 | GNUNET_GETOPT_option_flag('b', | 460 | GNUNET_GETOPT_option_flag ('b', |
445 | "byzantine", | 461 | "byzantine", |
446 | gettext_noop("use byzantine mode"), | 462 | gettext_noop ("use byzantine mode"), |
447 | &byzantine), | 463 | &byzantine), |
448 | 464 | ||
449 | GNUNET_GETOPT_option_uint('f', | 465 | GNUNET_GETOPT_option_uint ('f', |
450 | "force-full", | 466 | "force-full", |
451 | NULL, | 467 | NULL, |
452 | gettext_noop("force sending full set"), | 468 | gettext_noop ("force sending full set"), |
453 | &force_full), | 469 | &force_full), |
454 | 470 | ||
455 | GNUNET_GETOPT_option_uint('d', | 471 | GNUNET_GETOPT_option_uint ('d', |
456 | "force-delta", | 472 | "force-delta", |
457 | NULL, | 473 | NULL, |
458 | gettext_noop("number delta operation"), | 474 | gettext_noop ("number delta operation"), |
459 | &force_delta), | 475 | &force_delta), |
460 | 476 | ||
461 | GNUNET_GETOPT_option_uint('C', | 477 | GNUNET_GETOPT_option_uint ('C', |
462 | "num-common", | 478 | "num-common", |
463 | NULL, | 479 | NULL, |
464 | gettext_noop("number of values"), | 480 | gettext_noop ("number of values"), |
465 | &num_c), | 481 | &num_c), |
466 | 482 | ||
467 | GNUNET_GETOPT_option_string('x', | 483 | GNUNET_GETOPT_option_string ('x', |
468 | "operation", | 484 | "operation", |
469 | NULL, | 485 | NULL, |
470 | gettext_noop("operation to execute"), | 486 | gettext_noop ("operation to execute"), |
471 | &op_str), | 487 | &op_str), |
472 | 488 | ||
473 | GNUNET_GETOPT_option_uint('w', | 489 | GNUNET_GETOPT_option_uint ('w', |
474 | "element-size", | 490 | "element-size", |
475 | NULL, | 491 | NULL, |
476 | gettext_noop("element size"), | 492 | gettext_noop ("element size"), |
477 | &element_size), | 493 | &element_size), |
478 | 494 | ||
479 | GNUNET_GETOPT_option_filename('s', | 495 | GNUNET_GETOPT_option_filename ('s', |
480 | "statistics", | 496 | "statistics", |
481 | "FILENAME", | 497 | "FILENAME", |
482 | gettext_noop("write statistics to file"), | 498 | gettext_noop ("write statistics to file"), |
483 | &statistics_filename), | 499 | &statistics_filename), |
484 | 500 | ||
485 | GNUNET_GETOPT_OPTION_END | 501 | GNUNET_GETOPT_OPTION_END |
486 | }; | 502 | }; |
487 | 503 | ||
488 | GNUNET_PROGRAM_run2(argc, argv, "gnunet-set-profiler", | 504 | GNUNET_PROGRAM_run2 (argc, argv, "gnunet-set-profiler", |
489 | "help", | 505 | "help", |
490 | options, &pre_run, NULL, GNUNET_YES); | 506 | options, &pre_run, NULL, GNUNET_YES); |
491 | return ret; | 507 | return ret; |
492 | } | 508 | } |
diff --git a/src/set/ibf.c b/src/set/ibf.c index a573ef6b4..7c7adaa3c 100644 --- a/src/set/ibf.c +++ b/src/set/ibf.c | |||
@@ -30,7 +30,8 @@ | |||
30 | * Compute the key's hash from the key. | 30 | * Compute the key's hash from the key. |
31 | * Redefine to use a different hash function. | 31 | * Redefine to use a different hash function. |
32 | */ | 32 | */ |
33 | #define IBF_KEY_HASH_VAL(k) (GNUNET_CRYPTO_crc32_n(&(k), sizeof(struct IBF_KeyHash))) | 33 | #define IBF_KEY_HASH_VAL(k) (GNUNET_CRYPTO_crc32_n (&(k), sizeof(struct \ |
34 | IBF_KeyHash))) | ||
34 | 35 | ||
35 | /** | 36 | /** |
36 | * Create a key from a hashcode. | 37 | * Create a key from a hashcode. |
@@ -39,9 +40,9 @@ | |||
39 | * @return a key | 40 | * @return a key |
40 | */ | 41 | */ |
41 | struct IBF_Key | 42 | struct IBF_Key |
42 | ibf_key_from_hashcode(const struct GNUNET_HashCode *hash) | 43 | ibf_key_from_hashcode (const struct GNUNET_HashCode *hash) |
43 | { | 44 | { |
44 | return *(struct IBF_Key *)hash; | 45 | return *(struct IBF_Key *) hash; |
45 | } | 46 | } |
46 | 47 | ||
47 | /** | 48 | /** |
@@ -52,14 +53,15 @@ ibf_key_from_hashcode(const struct GNUNET_HashCode *hash) | |||
52 | * @param dst hashcode to store the result in | 53 | * @param dst hashcode to store the result in |
53 | */ | 54 | */ |
54 | void | 55 | void |
55 | ibf_hashcode_from_key(struct IBF_Key key, | 56 | ibf_hashcode_from_key (struct IBF_Key key, |
56 | struct GNUNET_HashCode *dst) | 57 | struct GNUNET_HashCode *dst) |
57 | { | 58 | { |
58 | struct IBF_Key *p; | 59 | struct IBF_Key *p; |
59 | unsigned int i; | 60 | unsigned int i; |
60 | const unsigned int keys_per_hashcode = sizeof(struct GNUNET_HashCode) / sizeof(struct IBF_Key); | 61 | const unsigned int keys_per_hashcode = sizeof(struct GNUNET_HashCode) |
62 | / sizeof(struct IBF_Key); | ||
61 | 63 | ||
62 | p = (struct IBF_Key *)dst; | 64 | p = (struct IBF_Key *) dst; |
63 | for (i = 0; i < keys_per_hashcode; i++) | 65 | for (i = 0; i < keys_per_hashcode; i++) |
64 | *p++ = key; | 66 | *p++ = key; |
65 | } | 67 | } |
@@ -73,34 +75,34 @@ ibf_hashcode_from_key(struct IBF_Key key, | |||
73 | * @return the newly created invertible bloom filter, NULL on error | 75 | * @return the newly created invertible bloom filter, NULL on error |
74 | */ | 76 | */ |
75 | struct InvertibleBloomFilter * | 77 | struct InvertibleBloomFilter * |
76 | ibf_create(uint32_t size, uint8_t hash_num) | 78 | ibf_create (uint32_t size, uint8_t hash_num) |
77 | { | 79 | { |
78 | struct InvertibleBloomFilter *ibf; | 80 | struct InvertibleBloomFilter *ibf; |
79 | 81 | ||
80 | GNUNET_assert(0 != size); | 82 | GNUNET_assert (0 != size); |
81 | 83 | ||
82 | ibf = GNUNET_new(struct InvertibleBloomFilter); | 84 | ibf = GNUNET_new (struct InvertibleBloomFilter); |
83 | ibf->count = GNUNET_malloc_large(size * sizeof(uint8_t)); | 85 | ibf->count = GNUNET_malloc_large (size * sizeof(uint8_t)); |
84 | if (NULL == ibf->count) | 86 | if (NULL == ibf->count) |
85 | { | 87 | { |
86 | GNUNET_free(ibf); | 88 | GNUNET_free (ibf); |
87 | return NULL; | 89 | return NULL; |
88 | } | 90 | } |
89 | ibf->key_sum = GNUNET_malloc_large(size * sizeof(struct IBF_Key)); | 91 | ibf->key_sum = GNUNET_malloc_large (size * sizeof(struct IBF_Key)); |
90 | if (NULL == ibf->key_sum) | 92 | if (NULL == ibf->key_sum) |
91 | { | 93 | { |
92 | GNUNET_free(ibf->count); | 94 | GNUNET_free (ibf->count); |
93 | GNUNET_free(ibf); | 95 | GNUNET_free (ibf); |
94 | return NULL; | 96 | return NULL; |
95 | } | 97 | } |
96 | ibf->key_hash_sum = GNUNET_malloc_large(size * sizeof(struct IBF_KeyHash)); | 98 | ibf->key_hash_sum = GNUNET_malloc_large (size * sizeof(struct IBF_KeyHash)); |
97 | if (NULL == ibf->key_hash_sum) | 99 | if (NULL == ibf->key_hash_sum) |
98 | { | 100 | { |
99 | GNUNET_free(ibf->key_sum); | 101 | GNUNET_free (ibf->key_sum); |
100 | GNUNET_free(ibf->count); | 102 | GNUNET_free (ibf->count); |
101 | GNUNET_free(ibf); | 103 | GNUNET_free (ibf); |
102 | return NULL; | 104 | return NULL; |
103 | } | 105 | } |
104 | ibf->size = size; | 106 | ibf->size = size; |
105 | ibf->hash_num = hash_num; | 107 | ibf->hash_num = hash_num; |
106 | 108 | ||
@@ -112,45 +114,45 @@ ibf_create(uint32_t size, uint8_t hash_num) | |||
112 | * Store unique bucket indices for the specified key in dst. | 114 | * Store unique bucket indices for the specified key in dst. |
113 | */ | 115 | */ |
114 | static void | 116 | static void |
115 | ibf_get_indices(const struct InvertibleBloomFilter *ibf, | 117 | ibf_get_indices (const struct InvertibleBloomFilter *ibf, |
116 | struct IBF_Key key, | 118 | struct IBF_Key key, |
117 | int *dst) | 119 | int *dst) |
118 | { | 120 | { |
119 | uint32_t filled; | 121 | uint32_t filled; |
120 | uint32_t i; | 122 | uint32_t i; |
121 | uint32_t bucket; | 123 | uint32_t bucket; |
122 | 124 | ||
123 | bucket = GNUNET_CRYPTO_crc32_n(&key, sizeof key); | 125 | bucket = GNUNET_CRYPTO_crc32_n (&key, sizeof key); |
124 | for (i = 0, filled = 0; filled < ibf->hash_num; i++) | 126 | for (i = 0, filled = 0; filled < ibf->hash_num; i++) |
125 | { | 127 | { |
126 | unsigned int j; | 128 | unsigned int j; |
127 | uint64_t x; | 129 | uint64_t x; |
128 | for (j = 0; j < filled; j++) | 130 | for (j = 0; j < filled; j++) |
129 | if (dst[j] == bucket) | 131 | if (dst[j] == bucket) |
130 | goto try_next; | 132 | goto try_next; |
131 | dst[filled++] = bucket % ibf->size; | 133 | dst[filled++] = bucket % ibf->size; |
132 | try_next:; | 134 | try_next:; |
133 | x = ((uint64_t)bucket << 32) | i; | 135 | x = ((uint64_t) bucket << 32) | i; |
134 | bucket = GNUNET_CRYPTO_crc32_n(&x, sizeof x); | 136 | bucket = GNUNET_CRYPTO_crc32_n (&x, sizeof x); |
135 | } | 137 | } |
136 | } | 138 | } |
137 | 139 | ||
138 | 140 | ||
139 | static void | 141 | static void |
140 | ibf_insert_into(struct InvertibleBloomFilter *ibf, | 142 | ibf_insert_into (struct InvertibleBloomFilter *ibf, |
141 | struct IBF_Key key, | 143 | struct IBF_Key key, |
142 | const int *buckets, int side) | 144 | const int *buckets, int side) |
143 | { | 145 | { |
144 | int i; | 146 | int i; |
145 | 147 | ||
146 | for (i = 0; i < ibf->hash_num; i++) | 148 | for (i = 0; i < ibf->hash_num; i++) |
147 | { | 149 | { |
148 | const int bucket = buckets[i]; | 150 | const int bucket = buckets[i]; |
149 | ibf->count[bucket].count_val += side; | 151 | ibf->count[bucket].count_val += side; |
150 | ibf->key_sum[bucket].key_val ^= key.key_val; | 152 | ibf->key_sum[bucket].key_val ^= key.key_val; |
151 | ibf->key_hash_sum[bucket].key_hash_val | 153 | ibf->key_hash_sum[bucket].key_hash_val |
152 | ^= IBF_KEY_HASH_VAL(key); | 154 | ^= IBF_KEY_HASH_VAL (key); |
153 | } | 155 | } |
154 | } | 156 | } |
155 | 157 | ||
156 | 158 | ||
@@ -161,13 +163,13 @@ ibf_insert_into(struct InvertibleBloomFilter *ibf, | |||
161 | * @param key the element's hash code | 163 | * @param key the element's hash code |
162 | */ | 164 | */ |
163 | void | 165 | void |
164 | ibf_insert(struct InvertibleBloomFilter *ibf, struct IBF_Key key) | 166 | ibf_insert (struct InvertibleBloomFilter *ibf, struct IBF_Key key) |
165 | { | 167 | { |
166 | int buckets[ibf->hash_num]; | 168 | int buckets[ibf->hash_num]; |
167 | 169 | ||
168 | GNUNET_assert(ibf->hash_num <= ibf->size); | 170 | GNUNET_assert (ibf->hash_num <= ibf->size); |
169 | ibf_get_indices(ibf, key, buckets); | 171 | ibf_get_indices (ibf, key, buckets); |
170 | ibf_insert_into(ibf, key, buckets, 1); | 172 | ibf_insert_into (ibf, key, buckets, 1); |
171 | } | 173 | } |
172 | 174 | ||
173 | 175 | ||
@@ -178,13 +180,13 @@ ibf_insert(struct InvertibleBloomFilter *ibf, struct IBF_Key key) | |||
178 | * @param key the element's hash code | 180 | * @param key the element's hash code |
179 | */ | 181 | */ |
180 | void | 182 | void |
181 | ibf_remove(struct InvertibleBloomFilter *ibf, struct IBF_Key key) | 183 | ibf_remove (struct InvertibleBloomFilter *ibf, struct IBF_Key key) |
182 | { | 184 | { |
183 | int buckets[ibf->hash_num]; | 185 | int buckets[ibf->hash_num]; |
184 | 186 | ||
185 | GNUNET_assert(ibf->hash_num <= ibf->size); | 187 | GNUNET_assert (ibf->hash_num <= ibf->size); |
186 | ibf_get_indices(ibf, key, buckets); | 188 | ibf_get_indices (ibf, key, buckets); |
187 | ibf_insert_into(ibf, key, buckets, -1); | 189 | ibf_insert_into (ibf, key, buckets, -1); |
188 | } | 190 | } |
189 | 191 | ||
190 | 192 | ||
@@ -192,19 +194,19 @@ ibf_remove(struct InvertibleBloomFilter *ibf, struct IBF_Key key) | |||
192 | * Test is the IBF is empty, i.e. all counts, keys and key hashes are zero. | 194 | * Test is the IBF is empty, i.e. all counts, keys and key hashes are zero. |
193 | */ | 195 | */ |
194 | static int | 196 | static int |
195 | ibf_is_empty(struct InvertibleBloomFilter *ibf) | 197 | ibf_is_empty (struct InvertibleBloomFilter *ibf) |
196 | { | 198 | { |
197 | int i; | 199 | int i; |
198 | 200 | ||
199 | for (i = 0; i < ibf->size; i++) | 201 | for (i = 0; i < ibf->size; i++) |
200 | { | 202 | { |
201 | if (0 != ibf->count[i].count_val) | 203 | if (0 != ibf->count[i].count_val) |
202 | return GNUNET_NO; | 204 | return GNUNET_NO; |
203 | if (0 != ibf->key_hash_sum[i].key_hash_val) | 205 | if (0 != ibf->key_hash_sum[i].key_hash_val) |
204 | return GNUNET_NO; | 206 | return GNUNET_NO; |
205 | if (0 != ibf->key_sum[i].key_val) | 207 | if (0 != ibf->key_sum[i].key_val) |
206 | return GNUNET_NO; | 208 | return GNUNET_NO; |
207 | } | 209 | } |
208 | return GNUNET_YES; | 210 | return GNUNET_YES; |
209 | } | 211 | } |
210 | 212 | ||
@@ -222,53 +224,53 @@ ibf_is_empty(struct InvertibleBloomFilter *ibf) | |||
222 | * GNUNET_SYSERR if the decoding has failed | 224 | * GNUNET_SYSERR if the decoding has failed |
223 | */ | 225 | */ |
224 | int | 226 | int |
225 | ibf_decode(struct InvertibleBloomFilter *ibf, | 227 | ibf_decode (struct InvertibleBloomFilter *ibf, |
226 | int *ret_side, struct IBF_Key *ret_id) | 228 | int *ret_side, struct IBF_Key *ret_id) |
227 | { | 229 | { |
228 | struct IBF_KeyHash hash; | 230 | struct IBF_KeyHash hash; |
229 | int i; | 231 | int i; |
230 | int buckets[ibf->hash_num]; | 232 | int buckets[ibf->hash_num]; |
231 | 233 | ||
232 | GNUNET_assert(NULL != ibf); | 234 | GNUNET_assert (NULL != ibf); |
233 | 235 | ||
234 | for (i = 0; i < ibf->size; i++) | 236 | for (i = 0; i < ibf->size; i++) |
235 | { | 237 | { |
236 | int j; | 238 | int j; |
237 | int hit; | 239 | int hit; |
238 | 240 | ||
239 | /* we can only decode from pure buckets */ | 241 | /* we can only decode from pure buckets */ |
240 | if ((1 != ibf->count[i].count_val) && (-1 != ibf->count[i].count_val)) | 242 | if ((1 != ibf->count[i].count_val) && (-1 != ibf->count[i].count_val)) |
241 | continue; | 243 | continue; |
242 | 244 | ||
243 | hash.key_hash_val = IBF_KEY_HASH_VAL(ibf->key_sum[i]); | 245 | hash.key_hash_val = IBF_KEY_HASH_VAL (ibf->key_sum[i]); |
244 | 246 | ||
245 | /* test if the hash matches the key */ | 247 | /* test if the hash matches the key */ |
246 | if (hash.key_hash_val != ibf->key_hash_sum[i].key_hash_val) | 248 | if (hash.key_hash_val != ibf->key_hash_sum[i].key_hash_val) |
247 | continue; | 249 | continue; |
248 | 250 | ||
249 | /* test if key in bucket hits its own location, | 251 | /* test if key in bucket hits its own location, |
250 | * if not, the key hash was subject to collision */ | 252 | * if not, the key hash was subject to collision */ |
251 | hit = GNUNET_NO; | 253 | hit = GNUNET_NO; |
252 | ibf_get_indices(ibf, ibf->key_sum[i], buckets); | 254 | ibf_get_indices (ibf, ibf->key_sum[i], buckets); |
253 | for (j = 0; j < ibf->hash_num; j++) | 255 | for (j = 0; j < ibf->hash_num; j++) |
254 | if (buckets[j] == i) | 256 | if (buckets[j] == i) |
255 | hit = GNUNET_YES; | 257 | hit = GNUNET_YES; |
256 | 258 | ||
257 | if (GNUNET_NO == hit) | 259 | if (GNUNET_NO == hit) |
258 | continue; | 260 | continue; |
259 | 261 | ||
260 | if (NULL != ret_side) | 262 | if (NULL != ret_side) |
261 | *ret_side = ibf->count[i].count_val; | 263 | *ret_side = ibf->count[i].count_val; |
262 | if (NULL != ret_id) | 264 | if (NULL != ret_id) |
263 | *ret_id = ibf->key_sum[i]; | 265 | *ret_id = ibf->key_sum[i]; |
264 | 266 | ||
265 | /* insert on the opposite side, effectively removing the element */ | 267 | /* insert on the opposite side, effectively removing the element */ |
266 | ibf_insert_into(ibf, ibf->key_sum[i], buckets, -ibf->count[i].count_val); | 268 | ibf_insert_into (ibf, ibf->key_sum[i], buckets, -ibf->count[i].count_val); |
267 | 269 | ||
268 | return GNUNET_YES; | 270 | return GNUNET_YES; |
269 | } | 271 | } |
270 | 272 | ||
271 | if (GNUNET_YES == ibf_is_empty(ibf)) | 273 | if (GNUNET_YES == ibf_is_empty (ibf)) |
272 | return GNUNET_NO; | 274 | return GNUNET_NO; |
273 | return GNUNET_SYSERR; | 275 | return GNUNET_SYSERR; |
274 | } | 276 | } |
@@ -284,25 +286,27 @@ ibf_decode(struct InvertibleBloomFilter *ibf, | |||
284 | * @param buf buffer to write the data to | 286 | * @param buf buffer to write the data to |
285 | */ | 287 | */ |
286 | void | 288 | void |
287 | ibf_write_slice(const struct InvertibleBloomFilter *ibf, uint32_t start, uint32_t count, void *buf) | 289 | ibf_write_slice (const struct InvertibleBloomFilter *ibf, uint32_t start, |
290 | uint32_t count, void *buf) | ||
288 | { | 291 | { |
289 | struct IBF_Key *key_dst; | 292 | struct IBF_Key *key_dst; |
290 | struct IBF_KeyHash *key_hash_dst; | 293 | struct IBF_KeyHash *key_hash_dst; |
291 | struct IBF_Count *count_dst; | 294 | struct IBF_Count *count_dst; |
292 | 295 | ||
293 | GNUNET_assert(start + count <= ibf->size); | 296 | GNUNET_assert (start + count <= ibf->size); |
294 | 297 | ||
295 | /* copy keys */ | 298 | /* copy keys */ |
296 | key_dst = (struct IBF_Key *)buf; | 299 | key_dst = (struct IBF_Key *) buf; |
297 | GNUNET_memcpy(key_dst, ibf->key_sum + start, count * sizeof *key_dst); | 300 | GNUNET_memcpy (key_dst, ibf->key_sum + start, count * sizeof *key_dst); |
298 | key_dst += count; | 301 | key_dst += count; |
299 | /* copy key hashes */ | 302 | /* copy key hashes */ |
300 | key_hash_dst = (struct IBF_KeyHash *)key_dst; | 303 | key_hash_dst = (struct IBF_KeyHash *) key_dst; |
301 | GNUNET_memcpy(key_hash_dst, ibf->key_hash_sum + start, count * sizeof *key_hash_dst); | 304 | GNUNET_memcpy (key_hash_dst, ibf->key_hash_sum + start, count |
305 | * sizeof *key_hash_dst); | ||
302 | key_hash_dst += count; | 306 | key_hash_dst += count; |
303 | /* copy counts */ | 307 | /* copy counts */ |
304 | count_dst = (struct IBF_Count *)key_hash_dst; | 308 | count_dst = (struct IBF_Count *) key_hash_dst; |
305 | GNUNET_memcpy(count_dst, ibf->count + start, count * sizeof *count_dst); | 309 | GNUNET_memcpy (count_dst, ibf->count + start, count * sizeof *count_dst); |
306 | } | 310 | } |
307 | 311 | ||
308 | 312 | ||
@@ -315,26 +319,28 @@ ibf_write_slice(const struct InvertibleBloomFilter *ibf, uint32_t start, uint32_ | |||
315 | * @param ibf the ibf to read from | 319 | * @param ibf the ibf to read from |
316 | */ | 320 | */ |
317 | void | 321 | void |
318 | ibf_read_slice(const void *buf, uint32_t start, uint32_t count, struct InvertibleBloomFilter *ibf) | 322 | ibf_read_slice (const void *buf, uint32_t start, uint32_t count, struct |
323 | InvertibleBloomFilter *ibf) | ||
319 | { | 324 | { |
320 | struct IBF_Key *key_src; | 325 | struct IBF_Key *key_src; |
321 | struct IBF_KeyHash *key_hash_src; | 326 | struct IBF_KeyHash *key_hash_src; |
322 | struct IBF_Count *count_src; | 327 | struct IBF_Count *count_src; |
323 | 328 | ||
324 | GNUNET_assert(count > 0); | 329 | GNUNET_assert (count > 0); |
325 | GNUNET_assert(start + count <= ibf->size); | 330 | GNUNET_assert (start + count <= ibf->size); |
326 | 331 | ||
327 | /* copy keys */ | 332 | /* copy keys */ |
328 | key_src = (struct IBF_Key *)buf; | 333 | key_src = (struct IBF_Key *) buf; |
329 | GNUNET_memcpy(ibf->key_sum + start, key_src, count * sizeof *key_src); | 334 | GNUNET_memcpy (ibf->key_sum + start, key_src, count * sizeof *key_src); |
330 | key_src += count; | 335 | key_src += count; |
331 | /* copy key hashes */ | 336 | /* copy key hashes */ |
332 | key_hash_src = (struct IBF_KeyHash *)key_src; | 337 | key_hash_src = (struct IBF_KeyHash *) key_src; |
333 | GNUNET_memcpy(ibf->key_hash_sum + start, key_hash_src, count * sizeof *key_hash_src); | 338 | GNUNET_memcpy (ibf->key_hash_sum + start, key_hash_src, count |
339 | * sizeof *key_hash_src); | ||
334 | key_hash_src += count; | 340 | key_hash_src += count; |
335 | /* copy counts */ | 341 | /* copy counts */ |
336 | count_src = (struct IBF_Count *)key_hash_src; | 342 | count_src = (struct IBF_Count *) key_hash_src; |
337 | GNUNET_memcpy(ibf->count + start, count_src, count * sizeof *count_src); | 343 | GNUNET_memcpy (ibf->count + start, count_src, count * sizeof *count_src); |
338 | } | 344 | } |
339 | 345 | ||
340 | 346 | ||
@@ -346,19 +352,20 @@ ibf_read_slice(const void *buf, uint32_t start, uint32_t count, struct Invertibl | |||
346 | * @param ibf2 IBF that will be subtracted from ibf1 | 352 | * @param ibf2 IBF that will be subtracted from ibf1 |
347 | */ | 353 | */ |
348 | void | 354 | void |
349 | ibf_subtract(struct InvertibleBloomFilter *ibf1, const struct InvertibleBloomFilter *ibf2) | 355 | ibf_subtract (struct InvertibleBloomFilter *ibf1, const struct |
356 | InvertibleBloomFilter *ibf2) | ||
350 | { | 357 | { |
351 | int i; | 358 | int i; |
352 | 359 | ||
353 | GNUNET_assert(ibf1->size == ibf2->size); | 360 | GNUNET_assert (ibf1->size == ibf2->size); |
354 | GNUNET_assert(ibf1->hash_num == ibf2->hash_num); | 361 | GNUNET_assert (ibf1->hash_num == ibf2->hash_num); |
355 | 362 | ||
356 | for (i = 0; i < ibf1->size; i++) | 363 | for (i = 0; i < ibf1->size; i++) |
357 | { | 364 | { |
358 | ibf1->count[i].count_val -= ibf2->count[i].count_val; | 365 | ibf1->count[i].count_val -= ibf2->count[i].count_val; |
359 | ibf1->key_hash_sum[i].key_hash_val ^= ibf2->key_hash_sum[i].key_hash_val; | 366 | ibf1->key_hash_sum[i].key_hash_val ^= ibf2->key_hash_sum[i].key_hash_val; |
360 | ibf1->key_sum[i].key_val ^= ibf2->key_sum[i].key_val; | 367 | ibf1->key_sum[i].key_val ^= ibf2->key_sum[i].key_val; |
361 | } | 368 | } |
362 | } | 369 | } |
363 | 370 | ||
364 | 371 | ||
@@ -368,16 +375,19 @@ ibf_subtract(struct InvertibleBloomFilter *ibf1, const struct InvertibleBloomFil | |||
368 | * @param ibf the IBF to copy | 375 | * @param ibf the IBF to copy |
369 | */ | 376 | */ |
370 | struct InvertibleBloomFilter * | 377 | struct InvertibleBloomFilter * |
371 | ibf_dup(const struct InvertibleBloomFilter *ibf) | 378 | ibf_dup (const struct InvertibleBloomFilter *ibf) |
372 | { | 379 | { |
373 | struct InvertibleBloomFilter *copy; | 380 | struct InvertibleBloomFilter *copy; |
374 | 381 | ||
375 | copy = GNUNET_malloc(sizeof *copy); | 382 | copy = GNUNET_malloc (sizeof *copy); |
376 | copy->hash_num = ibf->hash_num; | 383 | copy->hash_num = ibf->hash_num; |
377 | copy->size = ibf->size; | 384 | copy->size = ibf->size; |
378 | copy->key_hash_sum = GNUNET_memdup(ibf->key_hash_sum, ibf->size * sizeof(struct IBF_KeyHash)); | 385 | copy->key_hash_sum = GNUNET_memdup (ibf->key_hash_sum, ibf->size |
379 | copy->key_sum = GNUNET_memdup(ibf->key_sum, ibf->size * sizeof(struct IBF_Key)); | 386 | * sizeof(struct IBF_KeyHash)); |
380 | copy->count = GNUNET_memdup(ibf->count, ibf->size * sizeof(struct IBF_Count)); | 387 | copy->key_sum = GNUNET_memdup (ibf->key_sum, ibf->size * sizeof(struct |
388 | IBF_Key)); | ||
389 | copy->count = GNUNET_memdup (ibf->count, ibf->size * sizeof(struct | ||
390 | IBF_Count)); | ||
381 | return copy; | 391 | return copy; |
382 | } | 392 | } |
383 | 393 | ||
@@ -389,10 +399,10 @@ ibf_dup(const struct InvertibleBloomFilter *ibf) | |||
389 | * @param ibf the intertible bloom filter to destroy | 399 | * @param ibf the intertible bloom filter to destroy |
390 | */ | 400 | */ |
391 | void | 401 | void |
392 | ibf_destroy(struct InvertibleBloomFilter *ibf) | 402 | ibf_destroy (struct InvertibleBloomFilter *ibf) |
393 | { | 403 | { |
394 | GNUNET_free(ibf->key_sum); | 404 | GNUNET_free (ibf->key_sum); |
395 | GNUNET_free(ibf->key_hash_sum); | 405 | GNUNET_free (ibf->key_hash_sum); |
396 | GNUNET_free(ibf->count); | 406 | GNUNET_free (ibf->count); |
397 | GNUNET_free(ibf); | 407 | GNUNET_free (ibf); |
398 | } | 408 | } |
diff --git a/src/set/ibf.h b/src/set/ibf.h index 94079a39f..7c2ab33b1 100644 --- a/src/set/ibf.h +++ b/src/set/ibf.h | |||
@@ -42,7 +42,8 @@ extern "C" | |||
42 | /** | 42 | /** |
43 | * Keys that can be inserted into and removed from an IBF. | 43 | * Keys that can be inserted into and removed from an IBF. |
44 | */ | 44 | */ |
45 | struct IBF_Key { | 45 | struct IBF_Key |
46 | { | ||
46 | uint64_t key_val; | 47 | uint64_t key_val; |
47 | }; | 48 | }; |
48 | 49 | ||
@@ -50,7 +51,8 @@ struct IBF_Key { | |||
50 | /** | 51 | /** |
51 | * Hash of an IBF key. | 52 | * Hash of an IBF key. |
52 | */ | 53 | */ |
53 | struct IBF_KeyHash { | 54 | struct IBF_KeyHash |
55 | { | ||
54 | uint32_t key_hash_val; | 56 | uint32_t key_hash_val; |
55 | }; | 57 | }; |
56 | 58 | ||
@@ -58,7 +60,8 @@ struct IBF_KeyHash { | |||
58 | /** | 60 | /** |
59 | * Type of the count field of IBF buckets. | 61 | * Type of the count field of IBF buckets. |
60 | */ | 62 | */ |
61 | struct IBF_Count { | 63 | struct IBF_Count |
64 | { | ||
62 | int8_t count_val; | 65 | int8_t count_val; |
63 | }; | 66 | }; |
64 | 67 | ||
@@ -66,8 +69,8 @@ struct IBF_Count { | |||
66 | /** | 69 | /** |
67 | * Size of one ibf bucket in bytes | 70 | * Size of one ibf bucket in bytes |
68 | */ | 71 | */ |
69 | #define IBF_BUCKET_SIZE (sizeof(struct IBF_Count) + sizeof(struct IBF_Key) + \ | 72 | #define IBF_BUCKET_SIZE (sizeof(struct IBF_Count) + sizeof(struct IBF_Key) \ |
70 | sizeof(struct IBF_KeyHash)) | 73 | + sizeof(struct IBF_KeyHash)) |
71 | 74 | ||
72 | 75 | ||
73 | /** | 76 | /** |
@@ -76,7 +79,8 @@ struct IBF_Count { | |||
76 | * An IBF is a counting bloom filter that has the ability to restore | 79 | * An IBF is a counting bloom filter that has the ability to restore |
77 | * the hashes of its stored elements with high probability. | 80 | * the hashes of its stored elements with high probability. |
78 | */ | 81 | */ |
79 | struct InvertibleBloomFilter { | 82 | struct InvertibleBloomFilter |
83 | { | ||
80 | /** | 84 | /** |
81 | * How many cells does this IBF have? | 85 | * How many cells does this IBF have? |
82 | */ | 86 | */ |
@@ -119,10 +123,10 @@ struct InvertibleBloomFilter { | |||
119 | * @param buf buffer to write the data to | 123 | * @param buf buffer to write the data to |
120 | */ | 124 | */ |
121 | void | 125 | void |
122 | ibf_write_slice(const struct InvertibleBloomFilter *ibf, | 126 | ibf_write_slice (const struct InvertibleBloomFilter *ibf, |
123 | uint32_t start, | 127 | uint32_t start, |
124 | uint32_t count, | 128 | uint32_t count, |
125 | void *buf); | 129 | void *buf); |
126 | 130 | ||
127 | 131 | ||
128 | /** | 132 | /** |
@@ -134,10 +138,10 @@ ibf_write_slice(const struct InvertibleBloomFilter *ibf, | |||
134 | * @param ibf the ibf to write to | 138 | * @param ibf the ibf to write to |
135 | */ | 139 | */ |
136 | void | 140 | void |
137 | ibf_read_slice(const void *buf, | 141 | ibf_read_slice (const void *buf, |
138 | uint32_t start, | 142 | uint32_t start, |
139 | uint32_t count, | 143 | uint32_t count, |
140 | struct InvertibleBloomFilter *ibf); | 144 | struct InvertibleBloomFilter *ibf); |
141 | 145 | ||
142 | 146 | ||
143 | /** | 147 | /** |
@@ -147,7 +151,7 @@ ibf_read_slice(const void *buf, | |||
147 | * @return a key | 151 | * @return a key |
148 | */ | 152 | */ |
149 | struct IBF_Key | 153 | struct IBF_Key |
150 | ibf_key_from_hashcode(const struct GNUNET_HashCode *hash); | 154 | ibf_key_from_hashcode (const struct GNUNET_HashCode *hash); |
151 | 155 | ||
152 | 156 | ||
153 | /** | 157 | /** |
@@ -158,7 +162,7 @@ ibf_key_from_hashcode(const struct GNUNET_HashCode *hash); | |||
158 | * @param dst hashcode to store the result in | 162 | * @param dst hashcode to store the result in |
159 | */ | 163 | */ |
160 | void | 164 | void |
161 | ibf_hashcode_from_key(struct IBF_Key key, struct GNUNET_HashCode *dst); | 165 | ibf_hashcode_from_key (struct IBF_Key key, struct GNUNET_HashCode *dst); |
162 | 166 | ||
163 | 167 | ||
164 | /** | 168 | /** |
@@ -169,7 +173,7 @@ ibf_hashcode_from_key(struct IBF_Key key, struct GNUNET_HashCode *dst); | |||
169 | * @return the newly created invertible bloom filter, NULL on error | 173 | * @return the newly created invertible bloom filter, NULL on error |
170 | */ | 174 | */ |
171 | struct InvertibleBloomFilter * | 175 | struct InvertibleBloomFilter * |
172 | ibf_create(uint32_t size, uint8_t hash_num); | 176 | ibf_create (uint32_t size, uint8_t hash_num); |
173 | 177 | ||
174 | 178 | ||
175 | /** | 179 | /** |
@@ -179,7 +183,7 @@ ibf_create(uint32_t size, uint8_t hash_num); | |||
179 | * @param key the element's hash code | 183 | * @param key the element's hash code |
180 | */ | 184 | */ |
181 | void | 185 | void |
182 | ibf_insert(struct InvertibleBloomFilter *ibf, struct IBF_Key key); | 186 | ibf_insert (struct InvertibleBloomFilter *ibf, struct IBF_Key key); |
183 | 187 | ||
184 | 188 | ||
185 | /** | 189 | /** |
@@ -189,7 +193,7 @@ ibf_insert(struct InvertibleBloomFilter *ibf, struct IBF_Key key); | |||
189 | * @param key the element's hash code | 193 | * @param key the element's hash code |
190 | */ | 194 | */ |
191 | void | 195 | void |
192 | ibf_remove(struct InvertibleBloomFilter *ibf, struct IBF_Key key); | 196 | ibf_remove (struct InvertibleBloomFilter *ibf, struct IBF_Key key); |
193 | 197 | ||
194 | 198 | ||
195 | /** | 199 | /** |
@@ -200,8 +204,8 @@ ibf_remove(struct InvertibleBloomFilter *ibf, struct IBF_Key key); | |||
200 | * @param ibf2 IBF that will be subtracted from ibf1 | 204 | * @param ibf2 IBF that will be subtracted from ibf1 |
201 | */ | 205 | */ |
202 | void | 206 | void |
203 | ibf_subtract(struct InvertibleBloomFilter *ibf1, | 207 | ibf_subtract (struct InvertibleBloomFilter *ibf1, |
204 | const struct InvertibleBloomFilter *ibf2); | 208 | const struct InvertibleBloomFilter *ibf2); |
205 | 209 | ||
206 | 210 | ||
207 | /** | 211 | /** |
@@ -217,9 +221,9 @@ ibf_subtract(struct InvertibleBloomFilter *ibf1, | |||
217 | * #GNUNET_SYSERR if the decoding has failed | 221 | * #GNUNET_SYSERR if the decoding has failed |
218 | */ | 222 | */ |
219 | int | 223 | int |
220 | ibf_decode(struct InvertibleBloomFilter *ibf, | 224 | ibf_decode (struct InvertibleBloomFilter *ibf, |
221 | int *ret_side, | 225 | int *ret_side, |
222 | struct IBF_Key *ret_id); | 226 | struct IBF_Key *ret_id); |
223 | 227 | ||
224 | 228 | ||
225 | /** | 229 | /** |
@@ -228,7 +232,7 @@ ibf_decode(struct InvertibleBloomFilter *ibf, | |||
228 | * @param ibf the IBF to copy | 232 | * @param ibf the IBF to copy |
229 | */ | 233 | */ |
230 | struct InvertibleBloomFilter * | 234 | struct InvertibleBloomFilter * |
231 | ibf_dup(const struct InvertibleBloomFilter *ibf); | 235 | ibf_dup (const struct InvertibleBloomFilter *ibf); |
232 | 236 | ||
233 | 237 | ||
234 | /** | 238 | /** |
@@ -238,7 +242,7 @@ ibf_dup(const struct InvertibleBloomFilter *ibf); | |||
238 | * @param ibf the intertible bloom filter to destroy | 242 | * @param ibf the intertible bloom filter to destroy |
239 | */ | 243 | */ |
240 | void | 244 | void |
241 | ibf_destroy(struct InvertibleBloomFilter *ibf); | 245 | ibf_destroy (struct InvertibleBloomFilter *ibf); |
242 | 246 | ||
243 | 247 | ||
244 | #if 0 /* keep Emacsens' auto-indent happy */ | 248 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/set/ibf_sim.c b/src/set/ibf_sim.c index 02b675f4a..226a9d751 100644 --- a/src/set/ibf_sim.c +++ b/src/set/ibf_sim.c | |||
@@ -50,7 +50,7 @@ | |||
50 | #define SLOW 0 | 50 | #define SLOW 0 |
51 | 51 | ||
52 | int | 52 | int |
53 | main(int argc, char **argv) | 53 | main (int argc, char **argv) |
54 | { | 54 | { |
55 | unsigned int round; | 55 | unsigned int round; |
56 | unsigned int buckets[31]; // max is 2^31 as 'random' returns only between 0 and 2^31 | 56 | unsigned int buckets[31]; // max is 2^31 as 'random' returns only between 0 and 2^31 |
@@ -62,77 +62,77 @@ main(int argc, char **argv) | |||
62 | unsigned int want; | 62 | unsigned int want; |
63 | double predict; | 63 | double predict; |
64 | 64 | ||
65 | srandom(time(NULL)); | 65 | srandom (time (NULL)); |
66 | total = 0; | 66 | total = 0; |
67 | want = atoi(argv[1]); | 67 | want = atoi (argv[1]); |
68 | for (round = 0; round < ROUNDS; round++) | 68 | for (round = 0; round < ROUNDS; round++) |
69 | { | ||
70 | memset (buckets, 0, sizeof(buckets)); | ||
71 | for (i = 0; i < want; i++) | ||
69 | { | 72 | { |
70 | memset(buckets, 0, sizeof(buckets)); | 73 | /* FIXME: might want to use 'better' PRNG to avoid |
71 | for (i = 0; i < want; i++) | 74 | PRNG-induced biases */ |
72 | { | 75 | r = random (); |
73 | /* FIXME: might want to use 'better' PRNG to avoid | 76 | if (0 == r) |
74 | PRNG-induced biases */ | 77 | continue; |
75 | r = random(); | ||
76 | if (0 == r) | ||
77 | continue; | ||
78 | #if SLOW | 78 | #if SLOW |
79 | for (j = 0; (j < 31) && (0 == (r & (1 << j))); j++) | 79 | for (j = 0; (j < 31) && (0 == (r & (1 << j))); j++) |
80 | ; | 80 | ; |
81 | #else | 81 | #else |
82 | /* use assembly / gcc */ | 82 | /* use assembly / gcc */ |
83 | j = __builtin_ffs(r) - 1; | 83 | j = __builtin_ffs (r) - 1; |
84 | #endif | 84 | #endif |
85 | buckets[j]++; | 85 | buckets[j]++; |
86 | } | 86 | } |
87 | ret = 0; | 87 | ret = 0; |
88 | predict = 0.0; | 88 | predict = 0.0; |
89 | for (j = 31; j >= 0; j--) | 89 | for (j = 31; j >= 0; j--) |
90 | { | 90 | { |
91 | #if FIX1 | 91 | #if FIX1 |
92 | /* improved algorithm, for 1000 elements with IBF-DECODE 8, I | 92 | /* improved algorithm, for 1000 elements with IBF-DECODE 8, I |
93 | get 990/1000 elements on average over 1 million runs; key | 93 | get 990/1000 elements on average over 1 million runs; key |
94 | idea being to stop short of the 'last' possible IBF as | 94 | idea being to stop short of the 'last' possible IBF as |
95 | otherwise a "lowball" per-chance would unduely influence the | 95 | otherwise a "lowball" per-chance would unduely influence the |
96 | result */ | 96 | result */ |
97 | if ((j > 0) && | 97 | if ((j > 0) && |
98 | (buckets[j - 1] > MAX_IBF_DECODE)) | 98 | (buckets[j - 1] > MAX_IBF_DECODE)) |
99 | { | 99 | { |
100 | ret *= (1 << (j + 1)); | 100 | ret *= (1 << (j + 1)); |
101 | break; | 101 | break; |
102 | } | 102 | } |
103 | #endif | 103 | #endif |
104 | #if FIX2 | 104 | #if FIX2 |
105 | /* another improvement: don't just always cut off the last one, | 105 | /* another improvement: don't just always cut off the last one, |
106 | but rather try to predict based on all previous values where | 106 | but rather try to predict based on all previous values where |
107 | that "last" one is; additional prediction can only really | 107 | that "last" one is; additional prediction can only really |
108 | work if MAX_IBF_DECODE is sufficiently high */ | 108 | work if MAX_IBF_DECODE is sufficiently high */ |
109 | if ((j > 0) && | 109 | if ((j > 0) && |
110 | ((buckets[j - 1] > MAX_IBF_DECODE) || | 110 | ((buckets[j - 1] > MAX_IBF_DECODE) || |
111 | (predict > MAX_IBF_DECODE))) | 111 | (predict > MAX_IBF_DECODE))) |
112 | { | 112 | { |
113 | ret *= (1 << (j + 1)); | 113 | ret *= (1 << (j + 1)); |
114 | break; | 114 | break; |
115 | } | 115 | } |
116 | #endif | 116 | #endif |
117 | #if STRATA | 117 | #if STRATA |
118 | /* original algorithm, for 1000 elements with IBF-DECODE 8, | 118 | /* original algorithm, for 1000 elements with IBF-DECODE 8, |
119 | I get 920/1000 elements on average over 1 million runs */ | 119 | I get 920/1000 elements on average over 1 million runs */ |
120 | if (buckets[j] > MAX_IBF_DECODE) | 120 | if (buckets[j] > MAX_IBF_DECODE) |
121 | { | 121 | { |
122 | ret *= (1 << (j + 1)); | 122 | ret *= (1 << (j + 1)); |
123 | break; | 123 | break; |
124 | } | 124 | } |
125 | #endif | 125 | #endif |
126 | ret += buckets[j]; | 126 | ret += buckets[j]; |
127 | predict = (buckets[j] + 2.0 * predict) / 2.0; | 127 | predict = (buckets[j] + 2.0 * predict) / 2.0; |
128 | } | 128 | } |
129 | #if VERBOSE | 129 | #if VERBOSE |
130 | fprintf(stderr, "%u ", ret); | 130 | fprintf (stderr, "%u ", ret); |
131 | #endif | 131 | #endif |
132 | total += ret; | 132 | total += ret; |
133 | } | 133 | } |
134 | fprintf(stderr, "\n"); | 134 | fprintf (stderr, "\n"); |
135 | fprintf(stdout, "average %llu\n", total / ROUNDS); | 135 | fprintf (stdout, "average %llu\n", total / ROUNDS); |
136 | return 0; | 136 | return 0; |
137 | } | 137 | } |
138 | 138 | ||
diff --git a/src/set/plugin_block_set_test.c b/src/set/plugin_block_set_test.c index e7322aea0..a9da9d549 100644 --- a/src/set/plugin_block_set_test.c +++ b/src/set/plugin_block_set_test.c | |||
@@ -46,20 +46,20 @@ | |||
46 | * @return characterization of result | 46 | * @return characterization of result |
47 | */ | 47 | */ |
48 | static enum GNUNET_BLOCK_EvaluationResult | 48 | static enum GNUNET_BLOCK_EvaluationResult |
49 | block_plugin_set_test_evaluate(void *cls, | 49 | block_plugin_set_test_evaluate (void *cls, |
50 | struct GNUNET_BLOCK_Context *ctx, | 50 | struct GNUNET_BLOCK_Context *ctx, |
51 | enum GNUNET_BLOCK_Type type, | 51 | enum GNUNET_BLOCK_Type type, |
52 | struct GNUNET_BLOCK_Group *group, | 52 | struct GNUNET_BLOCK_Group *group, |
53 | enum GNUNET_BLOCK_EvaluationOptions eo, | 53 | enum GNUNET_BLOCK_EvaluationOptions eo, |
54 | const struct GNUNET_HashCode *query, | 54 | const struct GNUNET_HashCode *query, |
55 | const void *xquery, | 55 | const void *xquery, |
56 | size_t xquery_size, | 56 | size_t xquery_size, |
57 | const void *reply_block, | 57 | const void *reply_block, |
58 | size_t reply_block_size) | 58 | size_t reply_block_size) |
59 | { | 59 | { |
60 | if ((NULL == reply_block) || | 60 | if ((NULL == reply_block) || |
61 | (reply_block_size == 0) || | 61 | (reply_block_size == 0) || |
62 | (0 != ((char *)reply_block)[0])) | 62 | (0 != ((char *) reply_block)[0])) |
63 | return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; | 63 | return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; |
64 | return GNUNET_BLOCK_EVALUATION_OK_MORE; | 64 | return GNUNET_BLOCK_EVALUATION_OK_MORE; |
65 | } | 65 | } |
@@ -77,11 +77,11 @@ block_plugin_set_test_evaluate(void *cls, | |||
77 | * (or if extracting a key from a block of this type does not work) | 77 | * (or if extracting a key from a block of this type does not work) |
78 | */ | 78 | */ |
79 | static int | 79 | static int |
80 | block_plugin_set_test_get_key(void *cls, | 80 | block_plugin_set_test_get_key (void *cls, |
81 | enum GNUNET_BLOCK_Type type, | 81 | enum GNUNET_BLOCK_Type type, |
82 | const void *block, | 82 | const void *block, |
83 | size_t block_size, | 83 | size_t block_size, |
84 | struct GNUNET_HashCode *key) | 84 | struct GNUNET_HashCode *key) |
85 | { | 85 | { |
86 | return GNUNET_SYSERR; | 86 | return GNUNET_SYSERR; |
87 | } | 87 | } |
@@ -91,16 +91,15 @@ block_plugin_set_test_get_key(void *cls, | |||
91 | * Entry point for the plugin. | 91 | * Entry point for the plugin. |
92 | */ | 92 | */ |
93 | void * | 93 | void * |
94 | libgnunet_plugin_block_set_test_init(void *cls) | 94 | libgnunet_plugin_block_set_test_init (void *cls) |
95 | { | 95 | { |
96 | static enum GNUNET_BLOCK_Type types[] = | 96 | static enum GNUNET_BLOCK_Type types[] = { |
97 | { | ||
98 | GNUNET_BLOCK_TYPE_SET_TEST, | 97 | GNUNET_BLOCK_TYPE_SET_TEST, |
99 | GNUNET_BLOCK_TYPE_ANY /* end of list */ | 98 | GNUNET_BLOCK_TYPE_ANY /* end of list */ |
100 | }; | 99 | }; |
101 | struct GNUNET_BLOCK_PluginFunctions *api; | 100 | struct GNUNET_BLOCK_PluginFunctions *api; |
102 | 101 | ||
103 | api = GNUNET_new(struct GNUNET_BLOCK_PluginFunctions); | 102 | api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions); |
104 | api->evaluate = &block_plugin_set_test_evaluate; | 103 | api->evaluate = &block_plugin_set_test_evaluate; |
105 | api->get_key = &block_plugin_set_test_get_key; | 104 | api->get_key = &block_plugin_set_test_get_key; |
106 | api->types = types; | 105 | api->types = types; |
@@ -112,11 +111,11 @@ libgnunet_plugin_block_set_test_init(void *cls) | |||
112 | * Exit point from the plugin. | 111 | * Exit point from the plugin. |
113 | */ | 112 | */ |
114 | void * | 113 | void * |
115 | libgnunet_plugin_block_set_test_done(void *cls) | 114 | libgnunet_plugin_block_set_test_done (void *cls) |
116 | { | 115 | { |
117 | struct GNUNET_BLOCK_PluginFunctions *api = cls; | 116 | struct GNUNET_BLOCK_PluginFunctions *api = cls; |
118 | 117 | ||
119 | GNUNET_free(api); | 118 | GNUNET_free (api); |
120 | return NULL; | 119 | return NULL; |
121 | } | 120 | } |
122 | 121 | ||
diff --git a/src/set/set.h b/src/set/set.h index 74c7ddda8..3fdfad5da 100644 --- a/src/set/set.h +++ b/src/set/set.h | |||
@@ -37,7 +37,8 @@ GNUNET_NETWORK_STRUCT_BEGIN | |||
37 | * a new set to perform operations with. Includes the desired | 37 | * a new set to perform operations with. Includes the desired |
38 | * set operation type. | 38 | * set operation type. |
39 | */ | 39 | */ |
40 | struct GNUNET_SET_CreateMessage { | 40 | struct GNUNET_SET_CreateMessage |
41 | { | ||
41 | /** | 42 | /** |
42 | * Type: #GNUNET_MESSAGE_TYPE_SET_CREATE | 43 | * Type: #GNUNET_MESSAGE_TYPE_SET_CREATE |
43 | */ | 44 | */ |
@@ -55,7 +56,8 @@ struct GNUNET_SET_CreateMessage { | |||
55 | * incoming requests to perform a certain type of set operation for a | 56 | * incoming requests to perform a certain type of set operation for a |
56 | * certain type of application. | 57 | * certain type of application. |
57 | */ | 58 | */ |
58 | struct GNUNET_SET_ListenMessage { | 59 | struct GNUNET_SET_ListenMessage |
60 | { | ||
59 | /** | 61 | /** |
60 | * Type: #GNUNET_MESSAGE_TYPE_SET_LISTEN | 62 | * Type: #GNUNET_MESSAGE_TYPE_SET_LISTEN |
61 | */ | 63 | */ |
@@ -77,7 +79,8 @@ struct GNUNET_SET_ListenMessage { | |||
77 | * Message sent by a listening client to the service to accept | 79 | * Message sent by a listening client to the service to accept |
78 | * performing the operation with the other peer. | 80 | * performing the operation with the other peer. |
79 | */ | 81 | */ |
80 | struct GNUNET_SET_AcceptMessage { | 82 | struct GNUNET_SET_AcceptMessage |
83 | { | ||
81 | /** | 84 | /** |
82 | * Type: #GNUNET_MESSAGE_TYPE_SET_ACCEPT | 85 | * Type: #GNUNET_MESSAGE_TYPE_SET_ACCEPT |
83 | */ | 86 | */ |
@@ -129,7 +132,8 @@ struct GNUNET_SET_AcceptMessage { | |||
129 | * Message sent by a listening client to the service to reject | 132 | * Message sent by a listening client to the service to reject |
130 | * performing the operation with the other peer. | 133 | * performing the operation with the other peer. |
131 | */ | 134 | */ |
132 | struct GNUNET_SET_RejectMessage { | 135 | struct GNUNET_SET_RejectMessage |
136 | { | ||
133 | /** | 137 | /** |
134 | * Type: #GNUNET_MESSAGE_TYPE_SET_REJECT | 138 | * Type: #GNUNET_MESSAGE_TYPE_SET_REJECT |
135 | */ | 139 | */ |
@@ -145,7 +149,8 @@ struct GNUNET_SET_RejectMessage { | |||
145 | /** | 149 | /** |
146 | * A request for an operation with another client. | 150 | * A request for an operation with another client. |
147 | */ | 151 | */ |
148 | struct GNUNET_SET_RequestMessage { | 152 | struct GNUNET_SET_RequestMessage |
153 | { | ||
149 | /** | 154 | /** |
150 | * Type: #GNUNET_MESSAGE_TYPE_SET_REQUEST. | 155 | * Type: #GNUNET_MESSAGE_TYPE_SET_REQUEST. |
151 | */ | 156 | */ |
@@ -172,7 +177,8 @@ struct GNUNET_SET_RequestMessage { | |||
172 | * client (not as listener). A set (which determines the operation | 177 | * client (not as listener). A set (which determines the operation |
173 | * type) must already exist in association with this client. | 178 | * type) must already exist in association with this client. |
174 | */ | 179 | */ |
175 | struct GNUNET_SET_EvaluateMessage { | 180 | struct GNUNET_SET_EvaluateMessage |
181 | { | ||
176 | /** | 182 | /** |
177 | * Type: #GNUNET_MESSAGE_TYPE_SET_EVALUATE | 183 | * Type: #GNUNET_MESSAGE_TYPE_SET_EVALUATE |
178 | */ | 184 | */ |
@@ -235,7 +241,8 @@ struct GNUNET_SET_EvaluateMessage { | |||
235 | * (set union) or part of the final result, depending on | 241 | * (set union) or part of the final result, depending on |
236 | * options specified for the operation. | 242 | * options specified for the operation. |
237 | */ | 243 | */ |
238 | struct GNUNET_SET_ResultMessage { | 244 | struct GNUNET_SET_ResultMessage |
245 | { | ||
239 | /** | 246 | /** |
240 | * Type: #GNUNET_MESSAGE_TYPE_SET_RESULT | 247 | * Type: #GNUNET_MESSAGE_TYPE_SET_RESULT |
241 | */ | 248 | */ |
@@ -270,7 +277,8 @@ struct GNUNET_SET_ResultMessage { | |||
270 | * Message sent by client to the service to add or remove | 277 | * Message sent by client to the service to add or remove |
271 | * an element to/from the set. | 278 | * an element to/from the set. |
272 | */ | 279 | */ |
273 | struct GNUNET_SET_ElementMessage { | 280 | struct GNUNET_SET_ElementMessage |
281 | { | ||
274 | /** | 282 | /** |
275 | * Type: #GNUNET_MESSAGE_TYPE_SET_ADD or | 283 | * Type: #GNUNET_MESSAGE_TYPE_SET_ADD or |
276 | * #GNUNET_MESSAGE_TYPE_SET_REMOVE | 284 | * #GNUNET_MESSAGE_TYPE_SET_REMOVE |
@@ -295,7 +303,8 @@ struct GNUNET_SET_ElementMessage { | |||
295 | * Sent to the service by the client | 303 | * Sent to the service by the client |
296 | * in order to cancel a set operation. | 304 | * in order to cancel a set operation. |
297 | */ | 305 | */ |
298 | struct GNUNET_SET_CancelMessage { | 306 | struct GNUNET_SET_CancelMessage |
307 | { | ||
299 | /** | 308 | /** |
300 | * Type: #GNUNET_MESSAGE_TYPE_SET_CANCEL | 309 | * Type: #GNUNET_MESSAGE_TYPE_SET_CANCEL |
301 | */ | 310 | */ |
@@ -312,7 +321,8 @@ struct GNUNET_SET_CancelMessage { | |||
312 | * Set element transmitted by service to client in response to a set | 321 | * Set element transmitted by service to client in response to a set |
313 | * iteration request. | 322 | * iteration request. |
314 | */ | 323 | */ |
315 | struct GNUNET_SET_IterResponseMessage { | 324 | struct GNUNET_SET_IterResponseMessage |
325 | { | ||
316 | /** | 326 | /** |
317 | * Type: #GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT | 327 | * Type: #GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT |
318 | */ | 328 | */ |
@@ -337,7 +347,8 @@ struct GNUNET_SET_IterResponseMessage { | |||
337 | /** | 347 | /** |
338 | * Client acknowledges receiving element in iteration. | 348 | * Client acknowledges receiving element in iteration. |
339 | */ | 349 | */ |
340 | struct GNUNET_SET_IterAckMessage { | 350 | struct GNUNET_SET_IterAckMessage |
351 | { | ||
341 | /** | 352 | /** |
342 | * Type: #GNUNET_MESSAGE_TYPE_SET_ITER_ACK | 353 | * Type: #GNUNET_MESSAGE_TYPE_SET_ITER_ACK |
343 | */ | 354 | */ |
@@ -353,7 +364,8 @@ struct GNUNET_SET_IterAckMessage { | |||
353 | /** | 364 | /** |
354 | * Server responds to a lazy copy request. | 365 | * Server responds to a lazy copy request. |
355 | */ | 366 | */ |
356 | struct GNUNET_SET_CopyLazyResponseMessage { | 367 | struct GNUNET_SET_CopyLazyResponseMessage |
368 | { | ||
357 | /** | 369 | /** |
358 | * Type: #GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE | 370 | * Type: #GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE |
359 | */ | 371 | */ |
@@ -369,7 +381,8 @@ struct GNUNET_SET_CopyLazyResponseMessage { | |||
369 | /** | 381 | /** |
370 | * Client connects to a lazily copied set. | 382 | * Client connects to a lazily copied set. |
371 | */ | 383 | */ |
372 | struct GNUNET_SET_CopyLazyConnectMessage { | 384 | struct GNUNET_SET_CopyLazyConnectMessage |
385 | { | ||
373 | /** | 386 | /** |
374 | * Type: #GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT | 387 | * Type: #GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT |
375 | */ | 388 | */ |
diff --git a/src/set/set_api.c b/src/set/set_api.c index 7db5abcbd..961bfdba9 100644 --- a/src/set/set_api.c +++ b/src/set/set_api.c | |||
@@ -30,9 +30,10 @@ | |||
30 | #include "set.h" | 30 | #include "set.h" |
31 | 31 | ||
32 | 32 | ||
33 | #define LOG(kind, ...) GNUNET_log_from(kind, "set-api", __VA_ARGS__) | 33 | #define LOG(kind, ...) GNUNET_log_from (kind, "set-api", __VA_ARGS__) |
34 | 34 | ||
35 | struct SetCopyRequest { | 35 | struct SetCopyRequest |
36 | { | ||
36 | struct SetCopyRequest *next; | 37 | struct SetCopyRequest *next; |
37 | 38 | ||
38 | struct SetCopyRequest *prev; | 39 | struct SetCopyRequest *prev; |
@@ -45,7 +46,8 @@ struct SetCopyRequest { | |||
45 | /** | 46 | /** |
46 | * Opaque handle to a set. | 47 | * Opaque handle to a set. |
47 | */ | 48 | */ |
48 | struct GNUNET_SET_Handle { | 49 | struct GNUNET_SET_Handle |
50 | { | ||
49 | /** | 51 | /** |
50 | * Message queue for @e client. | 52 | * Message queue for @e client. |
51 | */ | 53 | */ |
@@ -110,7 +112,8 @@ struct GNUNET_SET_Handle { | |||
110 | /** | 112 | /** |
111 | * Handle for a set operation request from another peer. | 113 | * Handle for a set operation request from another peer. |
112 | */ | 114 | */ |
113 | struct GNUNET_SET_Request { | 115 | struct GNUNET_SET_Request |
116 | { | ||
114 | /** | 117 | /** |
115 | * Id of the request, used to identify the request when | 118 | * Id of the request, used to identify the request when |
116 | * accepting/rejecting it. | 119 | * accepting/rejecting it. |
@@ -129,7 +132,8 @@ struct GNUNET_SET_Request { | |||
129 | * Handle to an operation. Only known to the service after committing | 132 | * Handle to an operation. Only known to the service after committing |
130 | * the handle with a set. | 133 | * the handle with a set. |
131 | */ | 134 | */ |
132 | struct GNUNET_SET_OperationHandle { | 135 | struct GNUNET_SET_OperationHandle |
136 | { | ||
133 | /** | 137 | /** |
134 | * Function to be called when we have a result, | 138 | * Function to be called when we have a result, |
135 | * or an error. | 139 | * or an error. |
@@ -179,11 +183,12 @@ struct GNUNET_SET_OperationHandle { | |||
179 | /** | 183 | /** |
180 | * Opaque handle to a listen operation. | 184 | * Opaque handle to a listen operation. |
181 | */ | 185 | */ |
182 | struct GNUNET_SET_ListenHandle { | 186 | struct GNUNET_SET_ListenHandle |
187 | { | ||
183 | /** | 188 | /** |
184 | * Message queue for the client. | 189 | * Message queue for the client. |
185 | */ | 190 | */ |
186 | struct GNUNET_MQ_Handle* mq; | 191 | struct GNUNET_MQ_Handle*mq; |
187 | 192 | ||
188 | /** | 193 | /** |
189 | * Configuration handle for the listener, stored | 194 | * Configuration handle for the listener, stored |
@@ -227,9 +232,9 @@ struct GNUNET_SET_ListenHandle { | |||
227 | 232 | ||
228 | /* mutual recursion with handle_copy_lazy */ | 233 | /* mutual recursion with handle_copy_lazy */ |
229 | static struct GNUNET_SET_Handle * | 234 | static struct GNUNET_SET_Handle * |
230 | create_internal(const struct GNUNET_CONFIGURATION_Handle *cfg, | 235 | create_internal (const struct GNUNET_CONFIGURATION_Handle *cfg, |
231 | enum GNUNET_SET_OperationType op, | 236 | enum GNUNET_SET_OperationType op, |
232 | const uint32_t *cookie); | 237 | const uint32_t *cookie); |
233 | 238 | ||
234 | 239 | ||
235 | /** | 240 | /** |
@@ -240,8 +245,8 @@ create_internal(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
240 | * @param msg the message | 245 | * @param msg the message |
241 | */ | 246 | */ |
242 | static void | 247 | static void |
243 | handle_copy_lazy(void *cls, | 248 | handle_copy_lazy (void *cls, |
244 | const struct GNUNET_SET_CopyLazyResponseMessage *msg) | 249 | const struct GNUNET_SET_CopyLazyResponseMessage *msg) |
245 | { | 250 | { |
246 | struct GNUNET_SET_Handle *set = cls; | 251 | struct GNUNET_SET_Handle *set = cls; |
247 | struct SetCopyRequest *req; | 252 | struct SetCopyRequest *req; |
@@ -249,24 +254,24 @@ handle_copy_lazy(void *cls, | |||
249 | 254 | ||
250 | req = set->copy_req_head; | 255 | req = set->copy_req_head; |
251 | if (NULL == req) | 256 | if (NULL == req) |
252 | { | 257 | { |
253 | /* Service sent us unsolicited lazy copy response */ | 258 | /* Service sent us unsolicited lazy copy response */ |
254 | GNUNET_break(0); | 259 | GNUNET_break (0); |
255 | return; | 260 | return; |
256 | } | 261 | } |
257 | 262 | ||
258 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 263 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
259 | "Handling response to lazy copy\n"); | 264 | "Handling response to lazy copy\n"); |
260 | GNUNET_CONTAINER_DLL_remove(set->copy_req_head, | 265 | GNUNET_CONTAINER_DLL_remove (set->copy_req_head, |
261 | set->copy_req_tail, | 266 | set->copy_req_tail, |
262 | req); | 267 | req); |
263 | // We pass none as operation here, since it doesn't matter when | 268 | // We pass none as operation here, since it doesn't matter when |
264 | // cloning. | 269 | // cloning. |
265 | new_set = create_internal(set->cfg, | 270 | new_set = create_internal (set->cfg, |
266 | GNUNET_SET_OPERATION_NONE, | 271 | GNUNET_SET_OPERATION_NONE, |
267 | &msg->cookie); | 272 | &msg->cookie); |
268 | req->cb(req->cls, new_set); | 273 | req->cb (req->cls, new_set); |
269 | GNUNET_free(req); | 274 | GNUNET_free (req); |
270 | } | 275 | } |
271 | 276 | ||
272 | 277 | ||
@@ -278,8 +283,8 @@ handle_copy_lazy(void *cls, | |||
278 | * @return #GNUNET_OK if message is well-formed | 283 | * @return #GNUNET_OK if message is well-formed |
279 | */ | 284 | */ |
280 | static int | 285 | static int |
281 | check_iter_element(void *cls, | 286 | check_iter_element (void *cls, |
282 | const struct GNUNET_SET_IterResponseMessage *msg) | 287 | const struct GNUNET_SET_IterResponseMessage *msg) |
283 | { | 288 | { |
284 | /* minimum size was already checked, everything else is OK! */ | 289 | /* minimum size was already checked, everything else is OK! */ |
285 | return GNUNET_OK; | 290 | return GNUNET_OK; |
@@ -294,8 +299,8 @@ check_iter_element(void *cls, | |||
294 | * @param mh the message | 299 | * @param mh the message |
295 | */ | 300 | */ |
296 | static void | 301 | static void |
297 | handle_iter_element(void *cls, | 302 | handle_iter_element (void *cls, |
298 | const struct GNUNET_SET_IterResponseMessage *msg) | 303 | const struct GNUNET_SET_IterResponseMessage *msg) |
299 | { | 304 | { |
300 | struct GNUNET_SET_Handle *set = cls; | 305 | struct GNUNET_SET_Handle *set = cls; |
301 | GNUNET_SET_ElementIterator iter = set->iterator; | 306 | GNUNET_SET_ElementIterator iter = set->iterator; |
@@ -304,26 +309,26 @@ handle_iter_element(void *cls, | |||
304 | struct GNUNET_MQ_Envelope *ev; | 309 | struct GNUNET_MQ_Envelope *ev; |
305 | uint16_t msize; | 310 | uint16_t msize; |
306 | 311 | ||
307 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 312 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
308 | "Received element in set iteration\n"); | 313 | "Received element in set iteration\n"); |
309 | msize = ntohs(msg->header.size); | 314 | msize = ntohs (msg->header.size); |
310 | if (set->iteration_id != ntohs(msg->iteration_id)) | 315 | if (set->iteration_id != ntohs (msg->iteration_id)) |
311 | { | 316 | { |
312 | /* element from a previous iteration, skip! */ | 317 | /* element from a previous iteration, skip! */ |
313 | iter = NULL; | 318 | iter = NULL; |
314 | } | 319 | } |
315 | if (NULL != iter) | 320 | if (NULL != iter) |
316 | { | 321 | { |
317 | element.size = msize - sizeof(struct GNUNET_SET_IterResponseMessage); | 322 | element.size = msize - sizeof(struct GNUNET_SET_IterResponseMessage); |
318 | element.element_type = ntohs(msg->element_type); | 323 | element.element_type = ntohs (msg->element_type); |
319 | element.data = &msg[1]; | 324 | element.data = &msg[1]; |
320 | iter(set->iterator_cls, | 325 | iter (set->iterator_cls, |
321 | &element); | 326 | &element); |
322 | } | 327 | } |
323 | ev = GNUNET_MQ_msg(ack_msg, | 328 | ev = GNUNET_MQ_msg (ack_msg, |
324 | GNUNET_MESSAGE_TYPE_SET_ITER_ACK); | 329 | GNUNET_MESSAGE_TYPE_SET_ITER_ACK); |
325 | ack_msg->send_more = htonl((NULL != iter)); | 330 | ack_msg->send_more = htonl ((NULL != iter)); |
326 | GNUNET_MQ_send(set->mq, ev); | 331 | GNUNET_MQ_send (set->mq, ev); |
327 | } | 332 | } |
328 | 333 | ||
329 | 334 | ||
@@ -335,31 +340,31 @@ handle_iter_element(void *cls, | |||
335 | * @param mh the message | 340 | * @param mh the message |
336 | */ | 341 | */ |
337 | static void | 342 | static void |
338 | handle_iter_done(void *cls, | 343 | handle_iter_done (void *cls, |
339 | const struct GNUNET_MessageHeader *mh) | 344 | const struct GNUNET_MessageHeader *mh) |
340 | { | 345 | { |
341 | struct GNUNET_SET_Handle *set = cls; | 346 | struct GNUNET_SET_Handle *set = cls; |
342 | GNUNET_SET_ElementIterator iter = set->iterator; | 347 | GNUNET_SET_ElementIterator iter = set->iterator; |
343 | 348 | ||
344 | if (NULL == iter) | 349 | if (NULL == iter) |
345 | { | 350 | { |
346 | /* FIXME: if this is true, could cancel+start a fresh one | 351 | /* FIXME: if this is true, could cancel+start a fresh one |
347 | cause elements to go to the wrong iteration? */ | 352 | cause elements to go to the wrong iteration? */ |
348 | LOG(GNUNET_ERROR_TYPE_INFO, | 353 | LOG (GNUNET_ERROR_TYPE_INFO, |
349 | "Service completed set iteration that was already cancelled\n"); | 354 | "Service completed set iteration that was already cancelled\n"); |
350 | return; | 355 | return; |
351 | } | 356 | } |
352 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 357 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
353 | "Set iteration completed\n"); | 358 | "Set iteration completed\n"); |
354 | set->destroy_requested = GNUNET_SYSERR; | 359 | set->destroy_requested = GNUNET_SYSERR; |
355 | set->iterator = NULL; | 360 | set->iterator = NULL; |
356 | set->iteration_id++; | 361 | set->iteration_id++; |
357 | iter(set->iterator_cls, | 362 | iter (set->iterator_cls, |
358 | NULL); | 363 | NULL); |
359 | if (GNUNET_SYSERR == set->destroy_requested) | 364 | if (GNUNET_SYSERR == set->destroy_requested) |
360 | set->destroy_requested = GNUNET_NO; | 365 | set->destroy_requested = GNUNET_NO; |
361 | if (GNUNET_YES == set->destroy_requested) | 366 | if (GNUNET_YES == set->destroy_requested) |
362 | GNUNET_SET_destroy(set); | 367 | GNUNET_SET_destroy (set); |
363 | } | 368 | } |
364 | 369 | ||
365 | 370 | ||
@@ -371,8 +376,8 @@ handle_iter_done(void *cls, | |||
371 | * @return #GNUNET_OK if message is well-formed | 376 | * @return #GNUNET_OK if message is well-formed |
372 | */ | 377 | */ |
373 | static int | 378 | static int |
374 | check_result(void *cls, | 379 | check_result (void *cls, |
375 | const struct GNUNET_SET_ResultMessage *msg) | 380 | const struct GNUNET_SET_ResultMessage *msg) |
376 | { | 381 | { |
377 | /* minimum size was already checked, everything else is OK! */ | 382 | /* minimum size was already checked, everything else is OK! */ |
378 | return GNUNET_OK; | 383 | return GNUNET_OK; |
@@ -386,8 +391,8 @@ check_result(void *cls, | |||
386 | * @param mh the message | 391 | * @param mh the message |
387 | */ | 392 | */ |
388 | static void | 393 | static void |
389 | handle_result(void *cls, | 394 | handle_result (void *cls, |
390 | const struct GNUNET_SET_ResultMessage *msg) | 395 | const struct GNUNET_SET_ResultMessage *msg) |
391 | { | 396 | { |
392 | struct GNUNET_SET_Handle *set = cls; | 397 | struct GNUNET_SET_Handle *set = cls; |
393 | struct GNUNET_SET_OperationHandle *oh; | 398 | struct GNUNET_SET_OperationHandle *oh; |
@@ -395,80 +400,80 @@ handle_result(void *cls, | |||
395 | enum GNUNET_SET_Status result_status; | 400 | enum GNUNET_SET_Status result_status; |
396 | int destroy_set; | 401 | int destroy_set; |
397 | 402 | ||
398 | GNUNET_assert(NULL != set->mq); | 403 | GNUNET_assert (NULL != set->mq); |
399 | result_status = (enum GNUNET_SET_Status)ntohs(msg->result_status); | 404 | result_status = (enum GNUNET_SET_Status) ntohs (msg->result_status); |
400 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 405 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
401 | "Got result message with status %d\n", | 406 | "Got result message with status %d\n", |
402 | result_status); | 407 | result_status); |
403 | 408 | ||
404 | oh = GNUNET_MQ_assoc_get(set->mq, | 409 | oh = GNUNET_MQ_assoc_get (set->mq, |
405 | ntohl(msg->request_id)); | 410 | ntohl (msg->request_id)); |
406 | if (NULL == oh) | 411 | if (NULL == oh) |
407 | { | 412 | { |
408 | /* 'oh' can be NULL if we canceled the operation, but the service | 413 | /* 'oh' can be NULL if we canceled the operation, but the service |
409 | did not get the cancel message yet. */ | 414 | did not get the cancel message yet. */ |
410 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 415 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
411 | "Ignoring result from canceled operation\n"); | 416 | "Ignoring result from canceled operation\n"); |
412 | return; | 417 | return; |
413 | } | 418 | } |
414 | 419 | ||
415 | switch (result_status) | 420 | switch (result_status) |
416 | { | 421 | { |
417 | case GNUNET_SET_STATUS_OK: | 422 | case GNUNET_SET_STATUS_OK: |
418 | case GNUNET_SET_STATUS_ADD_LOCAL: | 423 | case GNUNET_SET_STATUS_ADD_LOCAL: |
419 | case GNUNET_SET_STATUS_ADD_REMOTE: | 424 | case GNUNET_SET_STATUS_ADD_REMOTE: |
420 | goto do_element; | 425 | goto do_element; |
421 | 426 | ||
422 | case GNUNET_SET_STATUS_FAILURE: | 427 | case GNUNET_SET_STATUS_FAILURE: |
423 | case GNUNET_SET_STATUS_DONE: | 428 | case GNUNET_SET_STATUS_DONE: |
424 | goto do_final; | 429 | goto do_final; |
425 | 430 | ||
426 | case GNUNET_SET_STATUS_HALF_DONE: | 431 | case GNUNET_SET_STATUS_HALF_DONE: |
427 | /* not used anymore */ | 432 | /* not used anymore */ |
428 | GNUNET_assert(0); | 433 | GNUNET_assert (0); |
429 | } | 434 | } |
430 | 435 | ||
431 | do_final: | 436 | do_final: |
432 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 437 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
433 | "Treating result as final status\n"); | 438 | "Treating result as final status\n"); |
434 | GNUNET_MQ_assoc_remove(set->mq, | 439 | GNUNET_MQ_assoc_remove (set->mq, |
435 | ntohl(msg->request_id)); | 440 | ntohl (msg->request_id)); |
436 | GNUNET_CONTAINER_DLL_remove(set->ops_head, | 441 | GNUNET_CONTAINER_DLL_remove (set->ops_head, |
437 | set->ops_tail, | 442 | set->ops_tail, |
438 | oh); | 443 | oh); |
439 | /* Need to do this calculation _before_ the result callback, | 444 | /* Need to do this calculation _before_ the result callback, |
440 | as IF the application still has a valid set handle, it | 445 | as IF the application still has a valid set handle, it |
441 | may trigger destruction of the set during the callback. */ | 446 | may trigger destruction of the set during the callback. */ |
442 | destroy_set = (GNUNET_YES == set->destroy_requested) && | 447 | destroy_set = (GNUNET_YES == set->destroy_requested) && |
443 | (NULL == set->ops_head); | 448 | (NULL == set->ops_head); |
444 | if (NULL != oh->result_cb) | 449 | if (NULL != oh->result_cb) |
445 | { | 450 | { |
446 | oh->result_cb(oh->result_cls, | 451 | oh->result_cb (oh->result_cls, |
447 | NULL, | 452 | NULL, |
448 | GNUNET_ntohll(msg->current_size), | 453 | GNUNET_ntohll (msg->current_size), |
449 | result_status); | 454 | result_status); |
450 | } | 455 | } |
451 | else | 456 | else |
452 | { | 457 | { |
453 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 458 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
454 | "No callback for final status\n"); | 459 | "No callback for final status\n"); |
455 | } | 460 | } |
456 | if (destroy_set) | 461 | if (destroy_set) |
457 | GNUNET_SET_destroy(set); | 462 | GNUNET_SET_destroy (set); |
458 | GNUNET_free(oh); | 463 | GNUNET_free (oh); |
459 | return; | 464 | return; |
460 | 465 | ||
461 | do_element: | 466 | do_element: |
462 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 467 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
463 | "Treating result as element\n"); | 468 | "Treating result as element\n"); |
464 | e.data = &msg[1]; | 469 | e.data = &msg[1]; |
465 | e.size = ntohs(msg->header.size) - sizeof(struct GNUNET_SET_ResultMessage); | 470 | e.size = ntohs (msg->header.size) - sizeof(struct GNUNET_SET_ResultMessage); |
466 | e.element_type = ntohs(msg->element_type); | 471 | e.element_type = ntohs (msg->element_type); |
467 | if (NULL != oh->result_cb) | 472 | if (NULL != oh->result_cb) |
468 | oh->result_cb(oh->result_cls, | 473 | oh->result_cb (oh->result_cls, |
469 | &e, | 474 | &e, |
470 | GNUNET_ntohll(msg->current_size), | 475 | GNUNET_ntohll (msg->current_size), |
471 | result_status); | 476 | result_status); |
472 | } | 477 | } |
473 | 478 | ||
474 | 479 | ||
@@ -478,25 +483,25 @@ do_element: | |||
478 | * @param oh set operation to destroy | 483 | * @param oh set operation to destroy |
479 | */ | 484 | */ |
480 | static void | 485 | static void |
481 | set_operation_destroy(struct GNUNET_SET_OperationHandle *oh) | 486 | set_operation_destroy (struct GNUNET_SET_OperationHandle *oh) |
482 | { | 487 | { |
483 | struct GNUNET_SET_Handle *set = oh->set; | 488 | struct GNUNET_SET_Handle *set = oh->set; |
484 | struct GNUNET_SET_OperationHandle *h_assoc; | 489 | struct GNUNET_SET_OperationHandle *h_assoc; |
485 | 490 | ||
486 | if (NULL != oh->conclude_mqm) | 491 | if (NULL != oh->conclude_mqm) |
487 | GNUNET_MQ_discard(oh->conclude_mqm); | 492 | GNUNET_MQ_discard (oh->conclude_mqm); |
488 | /* is the operation already commited? */ | 493 | /* is the operation already commited? */ |
489 | if (NULL != set) | 494 | if (NULL != set) |
490 | { | 495 | { |
491 | GNUNET_CONTAINER_DLL_remove(set->ops_head, | 496 | GNUNET_CONTAINER_DLL_remove (set->ops_head, |
492 | set->ops_tail, | 497 | set->ops_tail, |
493 | oh); | 498 | oh); |
494 | h_assoc = GNUNET_MQ_assoc_remove(set->mq, | 499 | h_assoc = GNUNET_MQ_assoc_remove (set->mq, |
495 | oh->request_id); | 500 | oh->request_id); |
496 | GNUNET_assert((NULL == h_assoc) || | 501 | GNUNET_assert ((NULL == h_assoc) || |
497 | (h_assoc == oh)); | 502 | (h_assoc == oh)); |
498 | } | 503 | } |
499 | GNUNET_free(oh); | 504 | GNUNET_free (oh); |
500 | } | 505 | } |
501 | 506 | ||
502 | 507 | ||
@@ -508,29 +513,29 @@ set_operation_destroy(struct GNUNET_SET_OperationHandle *oh) | |||
508 | * @param oh set operation to cancel | 513 | * @param oh set operation to cancel |
509 | */ | 514 | */ |
510 | void | 515 | void |
511 | GNUNET_SET_operation_cancel(struct GNUNET_SET_OperationHandle *oh) | 516 | GNUNET_SET_operation_cancel (struct GNUNET_SET_OperationHandle *oh) |
512 | { | 517 | { |
513 | struct GNUNET_SET_Handle *set = oh->set; | 518 | struct GNUNET_SET_Handle *set = oh->set; |
514 | struct GNUNET_SET_CancelMessage *m; | 519 | struct GNUNET_SET_CancelMessage *m; |
515 | struct GNUNET_MQ_Envelope *mqm; | 520 | struct GNUNET_MQ_Envelope *mqm; |
516 | 521 | ||
517 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 522 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
518 | "Cancelling SET operation\n"); | 523 | "Cancelling SET operation\n"); |
519 | if (NULL != set) | 524 | if (NULL != set) |
520 | { | 525 | { |
521 | mqm = GNUNET_MQ_msg(m, GNUNET_MESSAGE_TYPE_SET_CANCEL); | 526 | mqm = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_SET_CANCEL); |
522 | m->request_id = htonl(oh->request_id); | 527 | m->request_id = htonl (oh->request_id); |
523 | GNUNET_MQ_send(set->mq, mqm); | 528 | GNUNET_MQ_send (set->mq, mqm); |
524 | } | 529 | } |
525 | set_operation_destroy(oh); | 530 | set_operation_destroy (oh); |
526 | if ((NULL != set) && | 531 | if ((NULL != set) && |
527 | (GNUNET_YES == set->destroy_requested) && | 532 | (GNUNET_YES == set->destroy_requested) && |
528 | (NULL == set->ops_head)) | 533 | (NULL == set->ops_head)) |
529 | { | 534 | { |
530 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 535 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
531 | "Destroying set after operation cancel\n"); | 536 | "Destroying set after operation cancel\n"); |
532 | GNUNET_SET_destroy(set); | 537 | GNUNET_SET_destroy (set); |
533 | } | 538 | } |
534 | } | 539 | } |
535 | 540 | ||
536 | 541 | ||
@@ -542,31 +547,31 @@ GNUNET_SET_operation_cancel(struct GNUNET_SET_OperationHandle *oh) | |||
542 | * @param error error code | 547 | * @param error error code |
543 | */ | 548 | */ |
544 | static void | 549 | static void |
545 | handle_client_set_error(void *cls, | 550 | handle_client_set_error (void *cls, |
546 | enum GNUNET_MQ_Error error) | 551 | enum GNUNET_MQ_Error error) |
547 | { | 552 | { |
548 | struct GNUNET_SET_Handle *set = cls; | 553 | struct GNUNET_SET_Handle *set = cls; |
549 | GNUNET_SET_ElementIterator iter = set->iterator; | 554 | GNUNET_SET_ElementIterator iter = set->iterator; |
550 | 555 | ||
551 | LOG(GNUNET_ERROR_TYPE_ERROR, | 556 | LOG (GNUNET_ERROR_TYPE_ERROR, |
552 | "Handling client set error %d\n", | 557 | "Handling client set error %d\n", |
553 | error); | 558 | error); |
554 | while (NULL != set->ops_head) | 559 | while (NULL != set->ops_head) |
555 | { | 560 | { |
556 | if ((NULL != set->ops_head->result_cb) && | 561 | if ((NULL != set->ops_head->result_cb) && |
557 | (GNUNET_NO == set->destroy_requested)) | 562 | (GNUNET_NO == set->destroy_requested)) |
558 | set->ops_head->result_cb(set->ops_head->result_cls, | 563 | set->ops_head->result_cb (set->ops_head->result_cls, |
559 | NULL, | 564 | NULL, |
560 | 0, | 565 | 0, |
561 | GNUNET_SET_STATUS_FAILURE); | 566 | GNUNET_SET_STATUS_FAILURE); |
562 | set_operation_destroy(set->ops_head); | 567 | set_operation_destroy (set->ops_head); |
563 | } | 568 | } |
564 | set->iterator = NULL; | 569 | set->iterator = NULL; |
565 | set->iteration_id++; | 570 | set->iteration_id++; |
566 | set->invalid = GNUNET_YES; | 571 | set->invalid = GNUNET_YES; |
567 | if (NULL != iter) | 572 | if (NULL != iter) |
568 | iter(set->iterator_cls, | 573 | iter (set->iterator_cls, |
569 | NULL); | 574 | NULL); |
570 | } | 575 | } |
571 | 576 | ||
572 | 577 | ||
@@ -574,65 +579,65 @@ handle_client_set_error(void *cls, | |||
574 | * FIXME. | 579 | * FIXME. |
575 | */ | 580 | */ |
576 | static struct GNUNET_SET_Handle * | 581 | static struct GNUNET_SET_Handle * |
577 | create_internal(const struct GNUNET_CONFIGURATION_Handle *cfg, | 582 | create_internal (const struct GNUNET_CONFIGURATION_Handle *cfg, |
578 | enum GNUNET_SET_OperationType op, | 583 | enum GNUNET_SET_OperationType op, |
579 | const uint32_t *cookie) | 584 | const uint32_t *cookie) |
580 | { | 585 | { |
581 | struct GNUNET_SET_Handle *set = GNUNET_new(struct GNUNET_SET_Handle); | 586 | struct GNUNET_SET_Handle *set = GNUNET_new (struct GNUNET_SET_Handle); |
582 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { | 587 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { |
583 | GNUNET_MQ_hd_var_size(result, | 588 | GNUNET_MQ_hd_var_size (result, |
584 | GNUNET_MESSAGE_TYPE_SET_RESULT, | 589 | GNUNET_MESSAGE_TYPE_SET_RESULT, |
585 | struct GNUNET_SET_ResultMessage, | 590 | struct GNUNET_SET_ResultMessage, |
586 | set), | 591 | set), |
587 | GNUNET_MQ_hd_var_size(iter_element, | 592 | GNUNET_MQ_hd_var_size (iter_element, |
588 | GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT, | 593 | GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT, |
589 | struct GNUNET_SET_IterResponseMessage, | 594 | struct GNUNET_SET_IterResponseMessage, |
590 | set), | 595 | set), |
591 | GNUNET_MQ_hd_fixed_size(iter_done, | 596 | GNUNET_MQ_hd_fixed_size (iter_done, |
592 | GNUNET_MESSAGE_TYPE_SET_ITER_DONE, | 597 | GNUNET_MESSAGE_TYPE_SET_ITER_DONE, |
593 | struct GNUNET_MessageHeader, | 598 | struct GNUNET_MessageHeader, |
594 | set), | 599 | set), |
595 | GNUNET_MQ_hd_fixed_size(copy_lazy, | 600 | GNUNET_MQ_hd_fixed_size (copy_lazy, |
596 | GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE, | 601 | GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE, |
597 | struct GNUNET_SET_CopyLazyResponseMessage, | 602 | struct GNUNET_SET_CopyLazyResponseMessage, |
598 | set), | 603 | set), |
599 | GNUNET_MQ_handler_end() | 604 | GNUNET_MQ_handler_end () |
600 | }; | 605 | }; |
601 | struct GNUNET_MQ_Envelope *mqm; | 606 | struct GNUNET_MQ_Envelope *mqm; |
602 | struct GNUNET_SET_CreateMessage *create_msg; | 607 | struct GNUNET_SET_CreateMessage *create_msg; |
603 | struct GNUNET_SET_CopyLazyConnectMessage *copy_msg; | 608 | struct GNUNET_SET_CopyLazyConnectMessage *copy_msg; |
604 | 609 | ||
605 | set->cfg = cfg; | 610 | set->cfg = cfg; |
606 | set->mq = GNUNET_CLIENT_connect(cfg, | 611 | set->mq = GNUNET_CLIENT_connect (cfg, |
607 | "set", | 612 | "set", |
608 | mq_handlers, | 613 | mq_handlers, |
609 | &handle_client_set_error, | 614 | &handle_client_set_error, |
610 | set); | 615 | set); |
611 | if (NULL == set->mq) | 616 | if (NULL == set->mq) |
612 | { | 617 | { |
613 | GNUNET_free(set); | 618 | GNUNET_free (set); |
614 | return NULL; | 619 | return NULL; |
615 | } | 620 | } |
616 | if (NULL == cookie) | 621 | if (NULL == cookie) |
617 | { | 622 | { |
618 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 623 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
619 | "Creating new set (operation %u)\n", | 624 | "Creating new set (operation %u)\n", |
620 | op); | 625 | op); |
621 | mqm = GNUNET_MQ_msg(create_msg, | 626 | mqm = GNUNET_MQ_msg (create_msg, |
622 | GNUNET_MESSAGE_TYPE_SET_CREATE); | 627 | GNUNET_MESSAGE_TYPE_SET_CREATE); |
623 | create_msg->operation = htonl(op); | 628 | create_msg->operation = htonl (op); |
624 | } | 629 | } |
625 | else | 630 | else |
626 | { | 631 | { |
627 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 632 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
628 | "Creating new set (lazy copy)\n", | 633 | "Creating new set (lazy copy)\n", |
629 | op); | 634 | op); |
630 | mqm = GNUNET_MQ_msg(copy_msg, | 635 | mqm = GNUNET_MQ_msg (copy_msg, |
631 | GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT); | 636 | GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT); |
632 | copy_msg->cookie = *cookie; | 637 | copy_msg->cookie = *cookie; |
633 | } | 638 | } |
634 | GNUNET_MQ_send(set->mq, | 639 | GNUNET_MQ_send (set->mq, |
635 | mqm); | 640 | mqm); |
636 | return set; | 641 | return set; |
637 | } | 642 | } |
638 | 643 | ||
@@ -649,18 +654,18 @@ create_internal(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
649 | * @return a handle to the set | 654 | * @return a handle to the set |
650 | */ | 655 | */ |
651 | struct GNUNET_SET_Handle * | 656 | struct GNUNET_SET_Handle * |
652 | GNUNET_SET_create(const struct GNUNET_CONFIGURATION_Handle *cfg, | 657 | GNUNET_SET_create (const struct GNUNET_CONFIGURATION_Handle *cfg, |
653 | enum GNUNET_SET_OperationType op) | 658 | enum GNUNET_SET_OperationType op) |
654 | { | 659 | { |
655 | struct GNUNET_SET_Handle *set; | 660 | struct GNUNET_SET_Handle *set; |
656 | 661 | ||
657 | set = create_internal(cfg, | 662 | set = create_internal (cfg, |
658 | op, | 663 | op, |
659 | NULL); | 664 | NULL); |
660 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 665 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
661 | "Creating set %p for operation %d\n", | 666 | "Creating set %p for operation %d\n", |
662 | set, | 667 | set, |
663 | op); | 668 | op); |
664 | return set; | 669 | return set; |
665 | } | 670 | } |
666 | 671 | ||
@@ -679,35 +684,35 @@ GNUNET_SET_create(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
679 | * set is invalid (e.g. the set service crashed) | 684 | * set is invalid (e.g. the set service crashed) |
680 | */ | 685 | */ |
681 | int | 686 | int |
682 | GNUNET_SET_add_element(struct GNUNET_SET_Handle *set, | 687 | GNUNET_SET_add_element (struct GNUNET_SET_Handle *set, |
683 | const struct GNUNET_SET_Element *element, | 688 | const struct GNUNET_SET_Element *element, |
684 | GNUNET_SET_Continuation cont, | 689 | GNUNET_SET_Continuation cont, |
685 | void *cont_cls) | 690 | void *cont_cls) |
686 | { | 691 | { |
687 | struct GNUNET_MQ_Envelope *mqm; | 692 | struct GNUNET_MQ_Envelope *mqm; |
688 | struct GNUNET_SET_ElementMessage *msg; | 693 | struct GNUNET_SET_ElementMessage *msg; |
689 | 694 | ||
690 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 695 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
691 | "adding element of type %u to set %p\n", | 696 | "adding element of type %u to set %p\n", |
692 | (unsigned int)element->element_type, | 697 | (unsigned int) element->element_type, |
693 | set); | 698 | set); |
694 | GNUNET_assert(NULL != set); | 699 | GNUNET_assert (NULL != set); |
695 | if (GNUNET_YES == set->invalid) | 700 | if (GNUNET_YES == set->invalid) |
696 | { | 701 | { |
697 | if (NULL != cont) | 702 | if (NULL != cont) |
698 | cont(cont_cls); | 703 | cont (cont_cls); |
699 | return GNUNET_SYSERR; | 704 | return GNUNET_SYSERR; |
700 | } | 705 | } |
701 | mqm = GNUNET_MQ_msg_extra(msg, | 706 | mqm = GNUNET_MQ_msg_extra (msg, |
702 | element->size, | 707 | element->size, |
703 | GNUNET_MESSAGE_TYPE_SET_ADD); | 708 | GNUNET_MESSAGE_TYPE_SET_ADD); |
704 | msg->element_type = htons(element->element_type); | 709 | msg->element_type = htons (element->element_type); |
705 | GNUNET_memcpy(&msg[1], | 710 | GNUNET_memcpy (&msg[1], |
706 | element->data, | 711 | element->data, |
707 | element->size); | 712 | element->size); |
708 | GNUNET_MQ_notify_sent(mqm, | 713 | GNUNET_MQ_notify_sent (mqm, |
709 | cont, cont_cls); | 714 | cont, cont_cls); |
710 | GNUNET_MQ_send(set->mq, mqm); | 715 | GNUNET_MQ_send (set->mq, mqm); |
711 | return GNUNET_OK; | 716 | return GNUNET_OK; |
712 | } | 717 | } |
713 | 718 | ||
@@ -726,33 +731,33 @@ GNUNET_SET_add_element(struct GNUNET_SET_Handle *set, | |||
726 | * set is invalid (e.g. the set service crashed) | 731 | * set is invalid (e.g. the set service crashed) |
727 | */ | 732 | */ |
728 | int | 733 | int |
729 | GNUNET_SET_remove_element(struct GNUNET_SET_Handle *set, | 734 | GNUNET_SET_remove_element (struct GNUNET_SET_Handle *set, |
730 | const struct GNUNET_SET_Element *element, | 735 | const struct GNUNET_SET_Element *element, |
731 | GNUNET_SET_Continuation cont, | 736 | GNUNET_SET_Continuation cont, |
732 | void *cont_cls) | 737 | void *cont_cls) |
733 | { | 738 | { |
734 | struct GNUNET_MQ_Envelope *mqm; | 739 | struct GNUNET_MQ_Envelope *mqm; |
735 | struct GNUNET_SET_ElementMessage *msg; | 740 | struct GNUNET_SET_ElementMessage *msg; |
736 | 741 | ||
737 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 742 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
738 | "Removing element from set %p\n", | 743 | "Removing element from set %p\n", |
739 | set); | 744 | set); |
740 | if (GNUNET_YES == set->invalid) | 745 | if (GNUNET_YES == set->invalid) |
741 | { | 746 | { |
742 | if (NULL != cont) | 747 | if (NULL != cont) |
743 | cont(cont_cls); | 748 | cont (cont_cls); |
744 | return GNUNET_SYSERR; | 749 | return GNUNET_SYSERR; |
745 | } | 750 | } |
746 | mqm = GNUNET_MQ_msg_extra(msg, | 751 | mqm = GNUNET_MQ_msg_extra (msg, |
747 | element->size, | 752 | element->size, |
748 | GNUNET_MESSAGE_TYPE_SET_REMOVE); | 753 | GNUNET_MESSAGE_TYPE_SET_REMOVE); |
749 | msg->element_type = htons(element->element_type); | 754 | msg->element_type = htons (element->element_type); |
750 | GNUNET_memcpy(&msg[1], | 755 | GNUNET_memcpy (&msg[1], |
751 | element->data, | 756 | element->data, |
752 | element->size); | 757 | element->size); |
753 | GNUNET_MQ_notify_sent(mqm, | 758 | GNUNET_MQ_notify_sent (mqm, |
754 | cont, cont_cls); | 759 | cont, cont_cls); |
755 | GNUNET_MQ_send(set->mq, mqm); | 760 | GNUNET_MQ_send (set->mq, mqm); |
756 | return GNUNET_OK; | 761 | return GNUNET_OK; |
757 | } | 762 | } |
758 | 763 | ||
@@ -764,29 +769,29 @@ GNUNET_SET_remove_element(struct GNUNET_SET_Handle *set, | |||
764 | * @param set set handle to destroy | 769 | * @param set set handle to destroy |
765 | */ | 770 | */ |
766 | void | 771 | void |
767 | GNUNET_SET_destroy(struct GNUNET_SET_Handle *set) | 772 | GNUNET_SET_destroy (struct GNUNET_SET_Handle *set) |
768 | { | 773 | { |
769 | /* destroying set while iterator is active is currently | 774 | /* destroying set while iterator is active is currently |
770 | not supported; we should expand the API to allow | 775 | not supported; we should expand the API to allow |
771 | clients to explicitly cancel the iteration! */ | 776 | clients to explicitly cancel the iteration! */ |
772 | GNUNET_assert(NULL != set); | 777 | GNUNET_assert (NULL != set); |
773 | if ((NULL != set->ops_head) || | 778 | if ((NULL != set->ops_head) || |
774 | (NULL != set->iterator) || | 779 | (NULL != set->iterator) || |
775 | (GNUNET_SYSERR == set->destroy_requested)) | 780 | (GNUNET_SYSERR == set->destroy_requested)) |
776 | { | 781 | { |
777 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 782 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
778 | "Set operations are pending, delaying set destruction\n"); | 783 | "Set operations are pending, delaying set destruction\n"); |
779 | set->destroy_requested = GNUNET_YES; | 784 | set->destroy_requested = GNUNET_YES; |
780 | return; | 785 | return; |
781 | } | 786 | } |
782 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 787 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
783 | "Really destroying set\n"); | 788 | "Really destroying set\n"); |
784 | if (NULL != set->mq) | 789 | if (NULL != set->mq) |
785 | { | 790 | { |
786 | GNUNET_MQ_destroy(set->mq); | 791 | GNUNET_MQ_destroy (set->mq); |
787 | set->mq = NULL; | 792 | set->mq = NULL; |
788 | } | 793 | } |
789 | GNUNET_free(set); | 794 | GNUNET_free (set); |
790 | } | 795 | } |
791 | 796 | ||
792 | 797 | ||
@@ -805,53 +810,53 @@ GNUNET_SET_destroy(struct GNUNET_SET_Handle *set) | |||
805 | * @return a handle to cancel the operation | 810 | * @return a handle to cancel the operation |
806 | */ | 811 | */ |
807 | struct GNUNET_SET_OperationHandle * | 812 | struct GNUNET_SET_OperationHandle * |
808 | GNUNET_SET_prepare(const struct GNUNET_PeerIdentity *other_peer, | 813 | GNUNET_SET_prepare (const struct GNUNET_PeerIdentity *other_peer, |
809 | const struct GNUNET_HashCode *app_id, | 814 | const struct GNUNET_HashCode *app_id, |
810 | const struct GNUNET_MessageHeader *context_msg, | 815 | const struct GNUNET_MessageHeader *context_msg, |
811 | enum GNUNET_SET_ResultMode result_mode, | 816 | enum GNUNET_SET_ResultMode result_mode, |
812 | struct GNUNET_SET_Option options[], | 817 | struct GNUNET_SET_Option options[], |
813 | GNUNET_SET_ResultIterator result_cb, | 818 | GNUNET_SET_ResultIterator result_cb, |
814 | void *result_cls) | 819 | void *result_cls) |
815 | { | 820 | { |
816 | struct GNUNET_MQ_Envelope *mqm; | 821 | struct GNUNET_MQ_Envelope *mqm; |
817 | struct GNUNET_SET_OperationHandle *oh; | 822 | struct GNUNET_SET_OperationHandle *oh; |
818 | struct GNUNET_SET_EvaluateMessage *msg; | 823 | struct GNUNET_SET_EvaluateMessage *msg; |
819 | struct GNUNET_SET_Option *opt; | 824 | struct GNUNET_SET_Option *opt; |
820 | 825 | ||
821 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 826 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
822 | "Client prepares set operation (%d)\n", | 827 | "Client prepares set operation (%d)\n", |
823 | result_mode); | 828 | result_mode); |
824 | oh = GNUNET_new(struct GNUNET_SET_OperationHandle); | 829 | oh = GNUNET_new (struct GNUNET_SET_OperationHandle); |
825 | oh->result_cb = result_cb; | 830 | oh->result_cb = result_cb; |
826 | oh->result_cls = result_cls; | 831 | oh->result_cls = result_cls; |
827 | mqm = GNUNET_MQ_msg_nested_mh(msg, | 832 | mqm = GNUNET_MQ_msg_nested_mh (msg, |
828 | GNUNET_MESSAGE_TYPE_SET_EVALUATE, | 833 | GNUNET_MESSAGE_TYPE_SET_EVALUATE, |
829 | context_msg); | 834 | context_msg); |
830 | msg->app_id = *app_id; | 835 | msg->app_id = *app_id; |
831 | msg->result_mode = htonl(result_mode); | 836 | msg->result_mode = htonl (result_mode); |
832 | msg->target_peer = *other_peer; | 837 | msg->target_peer = *other_peer; |
833 | for (opt = options; opt->type != 0; opt++) | 838 | for (opt = options; opt->type != 0; opt++) |
839 | { | ||
840 | switch (opt->type) | ||
834 | { | 841 | { |
835 | switch (opt->type) | 842 | case GNUNET_SET_OPTION_BYZANTINE: |
836 | { | 843 | msg->byzantine = GNUNET_YES; |
837 | case GNUNET_SET_OPTION_BYZANTINE: | 844 | msg->byzantine_lower_bound = opt->v.num; |
838 | msg->byzantine = GNUNET_YES; | 845 | break; |
839 | msg->byzantine_lower_bound = opt->v.num; | 846 | |
840 | break; | 847 | case GNUNET_SET_OPTION_FORCE_FULL: |
841 | 848 | msg->force_full = GNUNET_YES; | |
842 | case GNUNET_SET_OPTION_FORCE_FULL: | 849 | break; |
843 | msg->force_full = GNUNET_YES; | 850 | |
844 | break; | 851 | case GNUNET_SET_OPTION_FORCE_DELTA: |
845 | 852 | msg->force_delta = GNUNET_YES; | |
846 | case GNUNET_SET_OPTION_FORCE_DELTA: | 853 | break; |
847 | msg->force_delta = GNUNET_YES; | 854 | |
848 | break; | 855 | default: |
849 | 856 | LOG (GNUNET_ERROR_TYPE_ERROR, | |
850 | default: | 857 | "Option with type %d not recognized\n", (int) opt->type); |
851 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
852 | "Option with type %d not recognized\n", (int)opt->type); | ||
853 | } | ||
854 | } | 858 | } |
859 | } | ||
855 | oh->conclude_mqm = mqm; | 860 | oh->conclude_mqm = mqm; |
856 | oh->request_id_addr = &msg->request_id; | 861 | oh->request_id_addr = &msg->request_id; |
857 | 862 | ||
@@ -865,7 +870,7 @@ GNUNET_SET_prepare(const struct GNUNET_PeerIdentity *other_peer, | |||
865 | * @param cls the `struct GNUNET_SET_ListenHandle *` to connect | 870 | * @param cls the `struct GNUNET_SET_ListenHandle *` to connect |
866 | */ | 871 | */ |
867 | static void | 872 | static void |
868 | listen_connect(void *cls); | 873 | listen_connect (void *cls); |
869 | 874 | ||
870 | 875 | ||
871 | /** | 876 | /** |
@@ -876,20 +881,20 @@ listen_connect(void *cls); | |||
876 | * @return #GNUNET_OK if the message is well-formed | 881 | * @return #GNUNET_OK if the message is well-formed |
877 | */ | 882 | */ |
878 | static int | 883 | static int |
879 | check_request(void *cls, | 884 | check_request (void *cls, |
880 | const struct GNUNET_SET_RequestMessage *msg) | 885 | const struct GNUNET_SET_RequestMessage *msg) |
881 | { | 886 | { |
882 | const struct GNUNET_MessageHeader *context_msg; | 887 | const struct GNUNET_MessageHeader *context_msg; |
883 | 888 | ||
884 | if (ntohs(msg->header.size) == sizeof(*msg)) | 889 | if (ntohs (msg->header.size) == sizeof(*msg)) |
885 | return GNUNET_OK; /* no context message is OK */ | 890 | return GNUNET_OK; /* no context message is OK */ |
886 | context_msg = GNUNET_MQ_extract_nested_mh(msg); | 891 | context_msg = GNUNET_MQ_extract_nested_mh (msg); |
887 | if (NULL == context_msg) | 892 | if (NULL == context_msg) |
888 | { | 893 | { |
889 | /* malformed context message is NOT ok */ | 894 | /* malformed context message is NOT ok */ |
890 | GNUNET_break_op(0); | 895 | GNUNET_break_op (0); |
891 | return GNUNET_SYSERR; | 896 | return GNUNET_SYSERR; |
892 | } | 897 | } |
893 | return GNUNET_OK; | 898 | return GNUNET_OK; |
894 | } | 899 | } |
895 | 900 | ||
@@ -901,8 +906,8 @@ check_request(void *cls, | |||
901 | * @param msg the message | 906 | * @param msg the message |
902 | */ | 907 | */ |
903 | static void | 908 | static void |
904 | handle_request(void *cls, | 909 | handle_request (void *cls, |
905 | const struct GNUNET_SET_RequestMessage *msg) | 910 | const struct GNUNET_SET_RequestMessage *msg) |
906 | { | 911 | { |
907 | struct GNUNET_SET_ListenHandle *lh = cls; | 912 | struct GNUNET_SET_ListenHandle *lh = cls; |
908 | struct GNUNET_SET_Request req; | 913 | struct GNUNET_SET_Request req; |
@@ -910,28 +915,28 @@ handle_request(void *cls, | |||
910 | struct GNUNET_MQ_Envelope *mqm; | 915 | struct GNUNET_MQ_Envelope *mqm; |
911 | struct GNUNET_SET_RejectMessage *rmsg; | 916 | struct GNUNET_SET_RejectMessage *rmsg; |
912 | 917 | ||
913 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 918 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
914 | "Processing incoming operation request with id %u\n", | 919 | "Processing incoming operation request with id %u\n", |
915 | ntohl(msg->accept_id)); | 920 | ntohl (msg->accept_id)); |
916 | /* we got another valid request => reset the backoff */ | 921 | /* we got another valid request => reset the backoff */ |
917 | lh->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS; | 922 | lh->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS; |
918 | req.accept_id = ntohl(msg->accept_id); | 923 | req.accept_id = ntohl (msg->accept_id); |
919 | req.accepted = GNUNET_NO; | 924 | req.accepted = GNUNET_NO; |
920 | context_msg = GNUNET_MQ_extract_nested_mh(msg); | 925 | context_msg = GNUNET_MQ_extract_nested_mh (msg); |
921 | /* calling #GNUNET_SET_accept() in the listen cb will set req->accepted */ | 926 | /* calling #GNUNET_SET_accept() in the listen cb will set req->accepted */ |
922 | lh->listen_cb(lh->listen_cls, | 927 | lh->listen_cb (lh->listen_cls, |
923 | &msg->peer_id, | 928 | &msg->peer_id, |
924 | context_msg, | 929 | context_msg, |
925 | &req); | 930 | &req); |
926 | if (GNUNET_YES == req.accepted) | 931 | if (GNUNET_YES == req.accepted) |
927 | return; /* the accept-case is handled in #GNUNET_SET_accept() */ | 932 | return; /* the accept-case is handled in #GNUNET_SET_accept() */ |
928 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 933 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
929 | "Rejected request %u\n", | 934 | "Rejected request %u\n", |
930 | ntohl(msg->accept_id)); | 935 | ntohl (msg->accept_id)); |
931 | mqm = GNUNET_MQ_msg(rmsg, | 936 | mqm = GNUNET_MQ_msg (rmsg, |
932 | GNUNET_MESSAGE_TYPE_SET_REJECT); | 937 | GNUNET_MESSAGE_TYPE_SET_REJECT); |
933 | rmsg->accept_reject_id = msg->accept_id; | 938 | rmsg->accept_reject_id = msg->accept_id; |
934 | GNUNET_MQ_send(lh->mq, mqm); | 939 | GNUNET_MQ_send (lh->mq, mqm); |
935 | } | 940 | } |
936 | 941 | ||
937 | 942 | ||
@@ -943,20 +948,20 @@ handle_request(void *cls, | |||
943 | * @param error reason for the disconnect | 948 | * @param error reason for the disconnect |
944 | */ | 949 | */ |
945 | static void | 950 | static void |
946 | handle_client_listener_error(void *cls, | 951 | handle_client_listener_error (void *cls, |
947 | enum GNUNET_MQ_Error error) | 952 | enum GNUNET_MQ_Error error) |
948 | { | 953 | { |
949 | struct GNUNET_SET_ListenHandle *lh = cls; | 954 | struct GNUNET_SET_ListenHandle *lh = cls; |
950 | 955 | ||
951 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 956 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
952 | "Listener broke down (%d), re-connecting\n", | 957 | "Listener broke down (%d), re-connecting\n", |
953 | (int)error); | 958 | (int) error); |
954 | GNUNET_MQ_destroy(lh->mq); | 959 | GNUNET_MQ_destroy (lh->mq); |
955 | lh->mq = NULL; | 960 | lh->mq = NULL; |
956 | lh->reconnect_task = GNUNET_SCHEDULER_add_delayed(lh->reconnect_backoff, | 961 | lh->reconnect_task = GNUNET_SCHEDULER_add_delayed (lh->reconnect_backoff, |
957 | &listen_connect, | 962 | &listen_connect, |
958 | lh); | 963 | lh); |
959 | lh->reconnect_backoff = GNUNET_TIME_STD_BACKOFF(lh->reconnect_backoff); | 964 | lh->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (lh->reconnect_backoff); |
960 | } | 965 | } |
961 | 966 | ||
962 | 967 | ||
@@ -966,33 +971,33 @@ handle_client_listener_error(void *cls, | |||
966 | * @param cls the `struct GNUNET_SET_ListenHandle *` to connect | 971 | * @param cls the `struct GNUNET_SET_ListenHandle *` to connect |
967 | */ | 972 | */ |
968 | static void | 973 | static void |
969 | listen_connect(void *cls) | 974 | listen_connect (void *cls) |
970 | { | 975 | { |
971 | struct GNUNET_SET_ListenHandle *lh = cls; | 976 | struct GNUNET_SET_ListenHandle *lh = cls; |
972 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { | 977 | struct GNUNET_MQ_MessageHandler mq_handlers[] = { |
973 | GNUNET_MQ_hd_var_size(request, | 978 | GNUNET_MQ_hd_var_size (request, |
974 | GNUNET_MESSAGE_TYPE_SET_REQUEST, | 979 | GNUNET_MESSAGE_TYPE_SET_REQUEST, |
975 | struct GNUNET_SET_RequestMessage, | 980 | struct GNUNET_SET_RequestMessage, |
976 | lh), | 981 | lh), |
977 | GNUNET_MQ_handler_end() | 982 | GNUNET_MQ_handler_end () |
978 | }; | 983 | }; |
979 | struct GNUNET_MQ_Envelope *mqm; | 984 | struct GNUNET_MQ_Envelope *mqm; |
980 | struct GNUNET_SET_ListenMessage *msg; | 985 | struct GNUNET_SET_ListenMessage *msg; |
981 | 986 | ||
982 | lh->reconnect_task = NULL; | 987 | lh->reconnect_task = NULL; |
983 | GNUNET_assert(NULL == lh->mq); | 988 | GNUNET_assert (NULL == lh->mq); |
984 | lh->mq = GNUNET_CLIENT_connect(lh->cfg, | 989 | lh->mq = GNUNET_CLIENT_connect (lh->cfg, |
985 | "set", | 990 | "set", |
986 | mq_handlers, | 991 | mq_handlers, |
987 | &handle_client_listener_error, | 992 | &handle_client_listener_error, |
988 | lh); | 993 | lh); |
989 | if (NULL == lh->mq) | 994 | if (NULL == lh->mq) |
990 | return; | 995 | return; |
991 | mqm = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_SET_LISTEN); | 996 | mqm = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SET_LISTEN); |
992 | msg->operation = htonl(lh->operation); | 997 | msg->operation = htonl (lh->operation); |
993 | msg->app_id = lh->app_id; | 998 | msg->app_id = lh->app_id; |
994 | GNUNET_MQ_send(lh->mq, | 999 | GNUNET_MQ_send (lh->mq, |
995 | mqm); | 1000 | mqm); |
996 | } | 1001 | } |
997 | 1002 | ||
998 | 1003 | ||
@@ -1009,30 +1014,30 @@ listen_connect(void *cls) | |||
1009 | * @return a handle that can be used to cancel the listen operation | 1014 | * @return a handle that can be used to cancel the listen operation |
1010 | */ | 1015 | */ |
1011 | struct GNUNET_SET_ListenHandle * | 1016 | struct GNUNET_SET_ListenHandle * |
1012 | GNUNET_SET_listen(const struct GNUNET_CONFIGURATION_Handle *cfg, | 1017 | GNUNET_SET_listen (const struct GNUNET_CONFIGURATION_Handle *cfg, |
1013 | enum GNUNET_SET_OperationType operation, | 1018 | enum GNUNET_SET_OperationType operation, |
1014 | const struct GNUNET_HashCode *app_id, | 1019 | const struct GNUNET_HashCode *app_id, |
1015 | GNUNET_SET_ListenCallback listen_cb, | 1020 | GNUNET_SET_ListenCallback listen_cb, |
1016 | void *listen_cls) | 1021 | void *listen_cls) |
1017 | { | 1022 | { |
1018 | struct GNUNET_SET_ListenHandle *lh; | 1023 | struct GNUNET_SET_ListenHandle *lh; |
1019 | 1024 | ||
1020 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1025 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1021 | "Starting listener for app %s\n", | 1026 | "Starting listener for app %s\n", |
1022 | GNUNET_h2s(app_id)); | 1027 | GNUNET_h2s (app_id)); |
1023 | lh = GNUNET_new(struct GNUNET_SET_ListenHandle); | 1028 | lh = GNUNET_new (struct GNUNET_SET_ListenHandle); |
1024 | lh->listen_cb = listen_cb; | 1029 | lh->listen_cb = listen_cb; |
1025 | lh->listen_cls = listen_cls; | 1030 | lh->listen_cls = listen_cls; |
1026 | lh->cfg = cfg; | 1031 | lh->cfg = cfg; |
1027 | lh->operation = operation; | 1032 | lh->operation = operation; |
1028 | lh->app_id = *app_id; | 1033 | lh->app_id = *app_id; |
1029 | lh->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS; | 1034 | lh->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS; |
1030 | listen_connect(lh); | 1035 | listen_connect (lh); |
1031 | if (NULL == lh->mq) | 1036 | if (NULL == lh->mq) |
1032 | { | 1037 | { |
1033 | GNUNET_free(lh); | 1038 | GNUNET_free (lh); |
1034 | return NULL; | 1039 | return NULL; |
1035 | } | 1040 | } |
1036 | return lh; | 1041 | return lh; |
1037 | } | 1042 | } |
1038 | 1043 | ||
@@ -1043,22 +1048,22 @@ GNUNET_SET_listen(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
1043 | * @param lh handle for the listen operation | 1048 | * @param lh handle for the listen operation |
1044 | */ | 1049 | */ |
1045 | void | 1050 | void |
1046 | GNUNET_SET_listen_cancel(struct GNUNET_SET_ListenHandle *lh) | 1051 | GNUNET_SET_listen_cancel (struct GNUNET_SET_ListenHandle *lh) |
1047 | { | 1052 | { |
1048 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1053 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1049 | "Canceling listener %s\n", | 1054 | "Canceling listener %s\n", |
1050 | GNUNET_h2s(&lh->app_id)); | 1055 | GNUNET_h2s (&lh->app_id)); |
1051 | if (NULL != lh->mq) | 1056 | if (NULL != lh->mq) |
1052 | { | 1057 | { |
1053 | GNUNET_MQ_destroy(lh->mq); | 1058 | GNUNET_MQ_destroy (lh->mq); |
1054 | lh->mq = NULL; | 1059 | lh->mq = NULL; |
1055 | } | 1060 | } |
1056 | if (NULL != lh->reconnect_task) | 1061 | if (NULL != lh->reconnect_task) |
1057 | { | 1062 | { |
1058 | GNUNET_SCHEDULER_cancel(lh->reconnect_task); | 1063 | GNUNET_SCHEDULER_cancel (lh->reconnect_task); |
1059 | lh->reconnect_task = NULL; | 1064 | lh->reconnect_task = NULL; |
1060 | } | 1065 | } |
1061 | GNUNET_free(lh); | 1066 | GNUNET_free (lh); |
1062 | } | 1067 | } |
1063 | 1068 | ||
1064 | 1069 | ||
@@ -1077,27 +1082,27 @@ GNUNET_SET_listen_cancel(struct GNUNET_SET_ListenHandle *lh) | |||
1077 | * @return a handle to cancel the operation | 1082 | * @return a handle to cancel the operation |
1078 | */ | 1083 | */ |
1079 | struct GNUNET_SET_OperationHandle * | 1084 | struct GNUNET_SET_OperationHandle * |
1080 | GNUNET_SET_accept(struct GNUNET_SET_Request *request, | 1085 | GNUNET_SET_accept (struct GNUNET_SET_Request *request, |
1081 | enum GNUNET_SET_ResultMode result_mode, | 1086 | enum GNUNET_SET_ResultMode result_mode, |
1082 | struct GNUNET_SET_Option options[], | 1087 | struct GNUNET_SET_Option options[], |
1083 | GNUNET_SET_ResultIterator result_cb, | 1088 | GNUNET_SET_ResultIterator result_cb, |
1084 | void *result_cls) | 1089 | void *result_cls) |
1085 | { | 1090 | { |
1086 | struct GNUNET_MQ_Envelope *mqm; | 1091 | struct GNUNET_MQ_Envelope *mqm; |
1087 | struct GNUNET_SET_OperationHandle *oh; | 1092 | struct GNUNET_SET_OperationHandle *oh; |
1088 | struct GNUNET_SET_AcceptMessage *msg; | 1093 | struct GNUNET_SET_AcceptMessage *msg; |
1089 | 1094 | ||
1090 | GNUNET_assert(GNUNET_NO == request->accepted); | 1095 | GNUNET_assert (GNUNET_NO == request->accepted); |
1091 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1096 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1092 | "Client accepts set operation (%d) with id %u\n", | 1097 | "Client accepts set operation (%d) with id %u\n", |
1093 | result_mode, | 1098 | result_mode, |
1094 | request->accept_id); | 1099 | request->accept_id); |
1095 | request->accepted = GNUNET_YES; | 1100 | request->accepted = GNUNET_YES; |
1096 | mqm = GNUNET_MQ_msg(msg, | 1101 | mqm = GNUNET_MQ_msg (msg, |
1097 | GNUNET_MESSAGE_TYPE_SET_ACCEPT); | 1102 | GNUNET_MESSAGE_TYPE_SET_ACCEPT); |
1098 | msg->accept_reject_id = htonl(request->accept_id); | 1103 | msg->accept_reject_id = htonl (request->accept_id); |
1099 | msg->result_mode = htonl(result_mode); | 1104 | msg->result_mode = htonl (result_mode); |
1100 | oh = GNUNET_new(struct GNUNET_SET_OperationHandle); | 1105 | oh = GNUNET_new (struct GNUNET_SET_OperationHandle); |
1101 | oh->result_cb = result_cb; | 1106 | oh->result_cb = result_cb; |
1102 | oh->result_cls = result_cls; | 1107 | oh->result_cls = result_cls; |
1103 | oh->conclude_mqm = mqm; | 1108 | oh->conclude_mqm = mqm; |
@@ -1120,31 +1125,31 @@ GNUNET_SET_accept(struct GNUNET_SET_Request *request, | |||
1120 | * set is invalid (e.g. the set service crashed) | 1125 | * set is invalid (e.g. the set service crashed) |
1121 | */ | 1126 | */ |
1122 | int | 1127 | int |
1123 | GNUNET_SET_commit(struct GNUNET_SET_OperationHandle *oh, | 1128 | GNUNET_SET_commit (struct GNUNET_SET_OperationHandle *oh, |
1124 | struct GNUNET_SET_Handle *set) | 1129 | struct GNUNET_SET_Handle *set) |
1125 | { | 1130 | { |
1126 | if (NULL != oh->set) | 1131 | if (NULL != oh->set) |
1127 | { | 1132 | { |
1128 | /* Some other set was already committed for this | 1133 | /* Some other set was already committed for this |
1129 | * operation, there is a logic bug in the client of this API */ | 1134 | * operation, there is a logic bug in the client of this API */ |
1130 | GNUNET_break(0); | 1135 | GNUNET_break (0); |
1131 | return GNUNET_OK; | 1136 | return GNUNET_OK; |
1132 | } | 1137 | } |
1133 | GNUNET_assert(NULL != set); | 1138 | GNUNET_assert (NULL != set); |
1134 | if (GNUNET_YES == set->invalid) | 1139 | if (GNUNET_YES == set->invalid) |
1135 | return GNUNET_SYSERR; | 1140 | return GNUNET_SYSERR; |
1136 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1141 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1137 | "Client commits to SET\n"); | 1142 | "Client commits to SET\n"); |
1138 | GNUNET_assert(NULL != oh->conclude_mqm); | 1143 | GNUNET_assert (NULL != oh->conclude_mqm); |
1139 | oh->set = set; | 1144 | oh->set = set; |
1140 | GNUNET_CONTAINER_DLL_insert(set->ops_head, | 1145 | GNUNET_CONTAINER_DLL_insert (set->ops_head, |
1141 | set->ops_tail, | 1146 | set->ops_tail, |
1142 | oh); | 1147 | oh); |
1143 | oh->request_id = GNUNET_MQ_assoc_add(set->mq, | 1148 | oh->request_id = GNUNET_MQ_assoc_add (set->mq, |
1144 | oh); | 1149 | oh); |
1145 | *oh->request_id_addr = htonl(oh->request_id); | 1150 | *oh->request_id_addr = htonl (oh->request_id); |
1146 | GNUNET_MQ_send(set->mq, | 1151 | GNUNET_MQ_send (set->mq, |
1147 | oh->conclude_mqm); | 1152 | oh->conclude_mqm); |
1148 | oh->conclude_mqm = NULL; | 1153 | oh->conclude_mqm = NULL; |
1149 | oh->request_id_addr = NULL; | 1154 | oh->request_id_addr = NULL; |
1150 | return GNUNET_OK; | 1155 | return GNUNET_OK; |
@@ -1164,46 +1169,46 @@ GNUNET_SET_commit(struct GNUNET_SET_OperationHandle *oh, | |||
1164 | * #GNUNET_SYSERR if the set is invalid (e.g. the server crashed, disconnected) | 1169 | * #GNUNET_SYSERR if the set is invalid (e.g. the server crashed, disconnected) |
1165 | */ | 1170 | */ |
1166 | int | 1171 | int |
1167 | GNUNET_SET_iterate(struct GNUNET_SET_Handle *set, | 1172 | GNUNET_SET_iterate (struct GNUNET_SET_Handle *set, |
1168 | GNUNET_SET_ElementIterator iter, | 1173 | GNUNET_SET_ElementIterator iter, |
1169 | void *iter_cls) | 1174 | void *iter_cls) |
1170 | { | 1175 | { |
1171 | struct GNUNET_MQ_Envelope *ev; | 1176 | struct GNUNET_MQ_Envelope *ev; |
1172 | 1177 | ||
1173 | GNUNET_assert(NULL != iter); | 1178 | GNUNET_assert (NULL != iter); |
1174 | if (GNUNET_YES == set->invalid) | 1179 | if (GNUNET_YES == set->invalid) |
1175 | return GNUNET_SYSERR; | 1180 | return GNUNET_SYSERR; |
1176 | if (NULL != set->iterator) | 1181 | if (NULL != set->iterator) |
1177 | return GNUNET_NO; | 1182 | return GNUNET_NO; |
1178 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1183 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1179 | "Iterating over set\n"); | 1184 | "Iterating over set\n"); |
1180 | set->iterator = iter; | 1185 | set->iterator = iter; |
1181 | set->iterator_cls = iter_cls; | 1186 | set->iterator_cls = iter_cls; |
1182 | ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_SET_ITER_REQUEST); | 1187 | ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_ITER_REQUEST); |
1183 | GNUNET_MQ_send(set->mq, ev); | 1188 | GNUNET_MQ_send (set->mq, ev); |
1184 | return GNUNET_YES; | 1189 | return GNUNET_YES; |
1185 | } | 1190 | } |
1186 | 1191 | ||
1187 | 1192 | ||
1188 | void | 1193 | void |
1189 | GNUNET_SET_copy_lazy(struct GNUNET_SET_Handle *set, | 1194 | GNUNET_SET_copy_lazy (struct GNUNET_SET_Handle *set, |
1190 | GNUNET_SET_CopyReadyCallback cb, | 1195 | GNUNET_SET_CopyReadyCallback cb, |
1191 | void *cls) | 1196 | void *cls) |
1192 | { | 1197 | { |
1193 | struct GNUNET_MQ_Envelope *ev; | 1198 | struct GNUNET_MQ_Envelope *ev; |
1194 | struct SetCopyRequest *req; | 1199 | struct SetCopyRequest *req; |
1195 | 1200 | ||
1196 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1201 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1197 | "Creating lazy copy of set\n"); | 1202 | "Creating lazy copy of set\n"); |
1198 | ev = GNUNET_MQ_msg_header(GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_PREPARE); | 1203 | ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_PREPARE); |
1199 | GNUNET_MQ_send(set->mq, ev); | 1204 | GNUNET_MQ_send (set->mq, ev); |
1200 | 1205 | ||
1201 | req = GNUNET_new(struct SetCopyRequest); | 1206 | req = GNUNET_new (struct SetCopyRequest); |
1202 | req->cb = cb; | 1207 | req->cb = cb; |
1203 | req->cls = cls; | 1208 | req->cls = cls; |
1204 | GNUNET_CONTAINER_DLL_insert(set->copy_req_head, | 1209 | GNUNET_CONTAINER_DLL_insert (set->copy_req_head, |
1205 | set->copy_req_tail, | 1210 | set->copy_req_tail, |
1206 | req); | 1211 | req); |
1207 | } | 1212 | } |
1208 | 1213 | ||
1209 | 1214 | ||
@@ -1215,17 +1220,17 @@ GNUNET_SET_copy_lazy(struct GNUNET_SET_Handle *set, | |||
1215 | * @return the copied element | 1220 | * @return the copied element |
1216 | */ | 1221 | */ |
1217 | struct GNUNET_SET_Element * | 1222 | struct GNUNET_SET_Element * |
1218 | GNUNET_SET_element_dup(const struct GNUNET_SET_Element *element) | 1223 | GNUNET_SET_element_dup (const struct GNUNET_SET_Element *element) |
1219 | { | 1224 | { |
1220 | struct GNUNET_SET_Element *copy; | 1225 | struct GNUNET_SET_Element *copy; |
1221 | 1226 | ||
1222 | copy = GNUNET_malloc(element->size + sizeof(struct GNUNET_SET_Element)); | 1227 | copy = GNUNET_malloc (element->size + sizeof(struct GNUNET_SET_Element)); |
1223 | copy->size = element->size; | 1228 | copy->size = element->size; |
1224 | copy->element_type = element->element_type; | 1229 | copy->element_type = element->element_type; |
1225 | copy->data = ©[1]; | 1230 | copy->data = ©[1]; |
1226 | GNUNET_memcpy(©[1], | 1231 | GNUNET_memcpy (©[1], |
1227 | element->data, | 1232 | element->data, |
1228 | copy->size); | 1233 | copy->size); |
1229 | return copy; | 1234 | return copy; |
1230 | } | 1235 | } |
1231 | 1236 | ||
@@ -1238,17 +1243,18 @@ GNUNET_SET_element_dup(const struct GNUNET_SET_Element *element) | |||
1238 | * should be stored | 1243 | * should be stored |
1239 | */ | 1244 | */ |
1240 | void | 1245 | void |
1241 | GNUNET_SET_element_hash(const struct GNUNET_SET_Element *element, | 1246 | GNUNET_SET_element_hash (const struct GNUNET_SET_Element *element, |
1242 | struct GNUNET_HashCode *ret_hash) | 1247 | struct GNUNET_HashCode *ret_hash) |
1243 | { | 1248 | { |
1244 | struct GNUNET_HashContext *ctx = GNUNET_CRYPTO_hash_context_start(); | 1249 | struct GNUNET_HashContext *ctx = GNUNET_CRYPTO_hash_context_start (); |
1245 | 1250 | ||
1246 | /* It's not guaranteed that the element data is always after the element header, | 1251 | /* It's not guaranteed that the element data is always after the element header, |
1247 | so we need to hash the chunks separately. */ | 1252 | so we need to hash the chunks separately. */ |
1248 | GNUNET_CRYPTO_hash_context_read(ctx, &element->size, sizeof(uint16_t)); | 1253 | GNUNET_CRYPTO_hash_context_read (ctx, &element->size, sizeof(uint16_t)); |
1249 | GNUNET_CRYPTO_hash_context_read(ctx, &element->element_type, sizeof(uint16_t)); | 1254 | GNUNET_CRYPTO_hash_context_read (ctx, &element->element_type, |
1250 | GNUNET_CRYPTO_hash_context_read(ctx, element->data, element->size); | 1255 | sizeof(uint16_t)); |
1251 | GNUNET_CRYPTO_hash_context_finish(ctx, ret_hash); | 1256 | GNUNET_CRYPTO_hash_context_read (ctx, element->data, element->size); |
1257 | GNUNET_CRYPTO_hash_context_finish (ctx, ret_hash); | ||
1252 | } | 1258 | } |
1253 | 1259 | ||
1254 | /* end of set_api.c */ | 1260 | /* end of set_api.c */ |
diff --git a/src/set/test_set_api.c b/src/set/test_set_api.c index 7cfa222b1..4b9b0ff82 100644 --- a/src/set/test_set_api.c +++ b/src/set/test_set_api.c | |||
@@ -53,106 +53,106 @@ static struct GNUNET_SCHEDULER_Task *tt; | |||
53 | 53 | ||
54 | 54 | ||
55 | static void | 55 | static void |
56 | result_cb_set1(void *cls, | 56 | result_cb_set1 (void *cls, |
57 | const struct GNUNET_SET_Element *element, | 57 | const struct GNUNET_SET_Element *element, |
58 | uint64_t size, | 58 | uint64_t size, |
59 | enum GNUNET_SET_Status status) | 59 | enum GNUNET_SET_Status status) |
60 | { | 60 | { |
61 | switch (status) | 61 | switch (status) |
62 | { | ||
63 | case GNUNET_SET_STATUS_OK: | ||
64 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: got element\n"); | ||
65 | break; | ||
66 | |||
67 | case GNUNET_SET_STATUS_FAILURE: | ||
68 | GNUNET_break (0); | ||
69 | oh1 = NULL; | ||
70 | fprintf (stderr, "set 1: received failure status!\n"); | ||
71 | ret = 1; | ||
72 | if (NULL != tt) | ||
62 | { | 73 | { |
63 | case GNUNET_SET_STATUS_OK: | 74 | GNUNET_SCHEDULER_cancel (tt); |
64 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "set 1: got element\n"); | 75 | tt = NULL; |
65 | break; | 76 | } |
66 | 77 | GNUNET_SCHEDULER_shutdown (); | |
67 | case GNUNET_SET_STATUS_FAILURE: | 78 | break; |
68 | GNUNET_break(0); | 79 | |
69 | oh1 = NULL; | 80 | case GNUNET_SET_STATUS_DONE: |
70 | fprintf(stderr, "set 1: received failure status!\n"); | 81 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: done\n"); |
71 | ret = 1; | 82 | oh1 = NULL; |
72 | if (NULL != tt) | 83 | if (NULL != set1) |
73 | { | 84 | { |
74 | GNUNET_SCHEDULER_cancel(tt); | 85 | GNUNET_SET_destroy (set1); |
75 | tt = NULL; | 86 | set1 = NULL; |
76 | } | ||
77 | GNUNET_SCHEDULER_shutdown(); | ||
78 | break; | ||
79 | |||
80 | case GNUNET_SET_STATUS_DONE: | ||
81 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "set 1: done\n"); | ||
82 | oh1 = NULL; | ||
83 | if (NULL != set1) | ||
84 | { | ||
85 | GNUNET_SET_destroy(set1); | ||
86 | set1 = NULL; | ||
87 | } | ||
88 | if (NULL == set2) | ||
89 | { | ||
90 | GNUNET_SCHEDULER_cancel(tt); | ||
91 | tt = NULL; | ||
92 | GNUNET_SCHEDULER_shutdown(); | ||
93 | } | ||
94 | break; | ||
95 | |||
96 | default: | ||
97 | GNUNET_assert(0); | ||
98 | } | 87 | } |
88 | if (NULL == set2) | ||
89 | { | ||
90 | GNUNET_SCHEDULER_cancel (tt); | ||
91 | tt = NULL; | ||
92 | GNUNET_SCHEDULER_shutdown (); | ||
93 | } | ||
94 | break; | ||
95 | |||
96 | default: | ||
97 | GNUNET_assert (0); | ||
98 | } | ||
99 | } | 99 | } |
100 | 100 | ||
101 | 101 | ||
102 | static void | 102 | static void |
103 | result_cb_set2(void *cls, | 103 | result_cb_set2 (void *cls, |
104 | const struct GNUNET_SET_Element *element, | 104 | const struct GNUNET_SET_Element *element, |
105 | uint64_t size, | 105 | uint64_t size, |
106 | enum GNUNET_SET_Status status) | 106 | enum GNUNET_SET_Status status) |
107 | { | 107 | { |
108 | switch (status) | 108 | switch (status) |
109 | { | ||
110 | case GNUNET_SET_STATUS_OK: | ||
111 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: got element\n"); | ||
112 | break; | ||
113 | |||
114 | case GNUNET_SET_STATUS_FAILURE: | ||
115 | GNUNET_break (0); | ||
116 | oh2 = NULL; | ||
117 | fprintf (stderr, "set 2: received failure status\n"); | ||
118 | GNUNET_SCHEDULER_shutdown (); | ||
119 | ret = 1; | ||
120 | break; | ||
121 | |||
122 | case GNUNET_SET_STATUS_DONE: | ||
123 | oh2 = NULL; | ||
124 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: done\n"); | ||
125 | GNUNET_SET_destroy (set2); | ||
126 | set2 = NULL; | ||
127 | if (NULL == set1) | ||
109 | { | 128 | { |
110 | case GNUNET_SET_STATUS_OK: | 129 | GNUNET_SCHEDULER_cancel (tt); |
111 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "set 2: got element\n"); | 130 | tt = NULL; |
112 | break; | 131 | GNUNET_SCHEDULER_shutdown (); |
113 | |||
114 | case GNUNET_SET_STATUS_FAILURE: | ||
115 | GNUNET_break(0); | ||
116 | oh2 = NULL; | ||
117 | fprintf(stderr, "set 2: received failure status\n"); | ||
118 | GNUNET_SCHEDULER_shutdown(); | ||
119 | ret = 1; | ||
120 | break; | ||
121 | |||
122 | case GNUNET_SET_STATUS_DONE: | ||
123 | oh2 = NULL; | ||
124 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "set 2: done\n"); | ||
125 | GNUNET_SET_destroy(set2); | ||
126 | set2 = NULL; | ||
127 | if (NULL == set1) | ||
128 | { | ||
129 | GNUNET_SCHEDULER_cancel(tt); | ||
130 | tt = NULL; | ||
131 | GNUNET_SCHEDULER_shutdown(); | ||
132 | } | ||
133 | break; | ||
134 | |||
135 | default: | ||
136 | GNUNET_assert(0); | ||
137 | } | 132 | } |
133 | break; | ||
134 | |||
135 | default: | ||
136 | GNUNET_assert (0); | ||
137 | } | ||
138 | } | 138 | } |
139 | 139 | ||
140 | 140 | ||
141 | static void | 141 | static void |
142 | listen_cb(void *cls, | 142 | listen_cb (void *cls, |
143 | const struct GNUNET_PeerIdentity *other_peer, | 143 | const struct GNUNET_PeerIdentity *other_peer, |
144 | const struct GNUNET_MessageHeader *context_msg, | 144 | const struct GNUNET_MessageHeader *context_msg, |
145 | struct GNUNET_SET_Request *request) | 145 | struct GNUNET_SET_Request *request) |
146 | { | 146 | { |
147 | GNUNET_assert(NULL != context_msg); | 147 | GNUNET_assert (NULL != context_msg); |
148 | GNUNET_assert(ntohs(context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); | 148 | GNUNET_assert (ntohs (context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); |
149 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "listen cb called\n"); | 149 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "listen cb called\n"); |
150 | oh2 = GNUNET_SET_accept(request, | 150 | oh2 = GNUNET_SET_accept (request, |
151 | GNUNET_SET_RESULT_ADDED, | 151 | GNUNET_SET_RESULT_ADDED, |
152 | (struct GNUNET_SET_Option[]){ 0 }, | 152 | (struct GNUNET_SET_Option[]){ 0 }, |
153 | &result_cb_set2, | 153 | &result_cb_set2, |
154 | NULL); | 154 | NULL); |
155 | GNUNET_SET_commit(oh2, set2); | 155 | GNUNET_SET_commit (oh2, set2); |
156 | } | 156 | } |
157 | 157 | ||
158 | 158 | ||
@@ -162,26 +162,26 @@ listen_cb(void *cls, | |||
162 | * @param cls closure, unused | 162 | * @param cls closure, unused |
163 | */ | 163 | */ |
164 | static void | 164 | static void |
165 | start(void *cls) | 165 | start (void *cls) |
166 | { | 166 | { |
167 | struct GNUNET_MessageHeader context_msg; | 167 | struct GNUNET_MessageHeader context_msg; |
168 | 168 | ||
169 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Starting reconciliation\n"); | 169 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting reconciliation\n"); |
170 | context_msg.size = htons(sizeof context_msg); | 170 | context_msg.size = htons (sizeof context_msg); |
171 | context_msg.type = htons(GNUNET_MESSAGE_TYPE_DUMMY); | 171 | context_msg.type = htons (GNUNET_MESSAGE_TYPE_DUMMY); |
172 | listen_handle = GNUNET_SET_listen(config, | 172 | listen_handle = GNUNET_SET_listen (config, |
173 | GNUNET_SET_OPERATION_UNION, | 173 | GNUNET_SET_OPERATION_UNION, |
174 | &app_id, | 174 | &app_id, |
175 | &listen_cb, | 175 | &listen_cb, |
176 | NULL); | 176 | NULL); |
177 | oh1 = GNUNET_SET_prepare(&local_id, | 177 | oh1 = GNUNET_SET_prepare (&local_id, |
178 | &app_id, | 178 | &app_id, |
179 | &context_msg, | 179 | &context_msg, |
180 | GNUNET_SET_RESULT_ADDED, | 180 | GNUNET_SET_RESULT_ADDED, |
181 | (struct GNUNET_SET_Option[]){ 0 }, | 181 | (struct GNUNET_SET_Option[]){ 0 }, |
182 | &result_cb_set1, | 182 | &result_cb_set1, |
183 | NULL); | 183 | NULL); |
184 | GNUNET_SET_commit(oh1, set1); | 184 | GNUNET_SET_commit (oh1, set1); |
185 | } | 185 | } |
186 | 186 | ||
187 | 187 | ||
@@ -191,22 +191,22 @@ start(void *cls) | |||
191 | * @param cls closure, unused | 191 | * @param cls closure, unused |
192 | */ | 192 | */ |
193 | static void | 193 | static void |
194 | init_set2(void *cls) | 194 | init_set2 (void *cls) |
195 | { | 195 | { |
196 | struct GNUNET_SET_Element element; | 196 | struct GNUNET_SET_Element element; |
197 | 197 | ||
198 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "initializing set 2\n"); | 198 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initializing set 2\n"); |
199 | 199 | ||
200 | element.element_type = 0; | 200 | element.element_type = 0; |
201 | element.data = "hello"; | 201 | element.data = "hello"; |
202 | element.size = strlen(element.data); | 202 | element.size = strlen (element.data); |
203 | GNUNET_SET_add_element(set2, &element, NULL, NULL); | 203 | GNUNET_SET_add_element (set2, &element, NULL, NULL); |
204 | element.data = "quux"; | 204 | element.data = "quux"; |
205 | element.size = strlen(element.data); | 205 | element.size = strlen (element.data); |
206 | GNUNET_SET_add_element(set2, &element, NULL, NULL); | 206 | GNUNET_SET_add_element (set2, &element, NULL, NULL); |
207 | element.data = "baz"; | 207 | element.data = "baz"; |
208 | element.size = strlen(element.data); | 208 | element.size = strlen (element.data); |
209 | GNUNET_SET_add_element(set2, &element, &start, NULL); | 209 | GNUNET_SET_add_element (set2, &element, &start, NULL); |
210 | } | 210 | } |
211 | 211 | ||
212 | 212 | ||
@@ -214,63 +214,63 @@ init_set2(void *cls) | |||
214 | * Initialize the first set, continue. | 214 | * Initialize the first set, continue. |
215 | */ | 215 | */ |
216 | static void | 216 | static void |
217 | init_set1(void) | 217 | init_set1 (void) |
218 | { | 218 | { |
219 | struct GNUNET_SET_Element element; | 219 | struct GNUNET_SET_Element element; |
220 | 220 | ||
221 | element.element_type = 0; | 221 | element.element_type = 0; |
222 | element.data = "hello"; | 222 | element.data = "hello"; |
223 | element.size = strlen(element.data); | 223 | element.size = strlen (element.data); |
224 | GNUNET_SET_add_element(set1, &element, NULL, NULL); | 224 | GNUNET_SET_add_element (set1, &element, NULL, NULL); |
225 | element.data = "bar"; | 225 | element.data = "bar"; |
226 | element.size = strlen(element.data); | 226 | element.size = strlen (element.data); |
227 | GNUNET_SET_add_element(set1, &element, &init_set2, NULL); | 227 | GNUNET_SET_add_element (set1, &element, &init_set2, NULL); |
228 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "initialized set 1\n"); | 228 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized set 1\n"); |
229 | } | 229 | } |
230 | 230 | ||
231 | 231 | ||
232 | static int | 232 | static int |
233 | iter_cb(void *cls, const struct GNUNET_SET_Element *element) | 233 | iter_cb (void *cls, const struct GNUNET_SET_Element *element) |
234 | { | 234 | { |
235 | struct GNUNET_SET_Handle *set = cls; | 235 | struct GNUNET_SET_Handle *set = cls; |
236 | 236 | ||
237 | if (NULL == element) | 237 | if (NULL == element) |
238 | { | 238 | { |
239 | GNUNET_assert(3 == iter_count); | 239 | GNUNET_assert (3 == iter_count); |
240 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 240 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
241 | "Iteration finished, destroying set %p\n", | 241 | "Iteration finished, destroying set %p\n", |
242 | set); | 242 | set); |
243 | GNUNET_SET_destroy(set); | 243 | GNUNET_SET_destroy (set); |
244 | return GNUNET_YES; | 244 | return GNUNET_YES; |
245 | } | 245 | } |
246 | iter_count++; | 246 | iter_count++; |
247 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "iter: got element %u\n", iter_count); | 247 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "iter: got element %u\n", iter_count); |
248 | return GNUNET_YES; | 248 | return GNUNET_YES; |
249 | } | 249 | } |
250 | 250 | ||
251 | 251 | ||
252 | static void | 252 | static void |
253 | test_iter() | 253 | test_iter () |
254 | { | 254 | { |
255 | struct GNUNET_SET_Element element; | 255 | struct GNUNET_SET_Element element; |
256 | struct GNUNET_SET_Handle *iter_set; | 256 | struct GNUNET_SET_Handle *iter_set; |
257 | 257 | ||
258 | iter_set = GNUNET_SET_create(config, GNUNET_SET_OPERATION_UNION); | 258 | iter_set = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION); |
259 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 259 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
260 | "Testing iteration over 3 elements on set %p\n", | 260 | "Testing iteration over 3 elements on set %p\n", |
261 | iter_set); | 261 | iter_set); |
262 | element.element_type = 0; | 262 | element.element_type = 0; |
263 | 263 | ||
264 | element.data = "hello"; | 264 | element.data = "hello"; |
265 | element.size = strlen(element.data); | 265 | element.size = strlen (element.data); |
266 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); | 266 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); |
267 | element.data = "bar"; | 267 | element.data = "bar"; |
268 | element.size = strlen(element.data); | 268 | element.size = strlen (element.data); |
269 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); | 269 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); |
270 | element.data = "quux"; | 270 | element.data = "quux"; |
271 | element.size = strlen(element.data); | 271 | element.size = strlen (element.data); |
272 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); | 272 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); |
273 | GNUNET_SET_iterate(iter_set, &iter_cb, iter_set); | 273 | GNUNET_SET_iterate (iter_set, &iter_cb, iter_set); |
274 | } | 274 | } |
275 | 275 | ||
276 | 276 | ||
@@ -280,11 +280,11 @@ test_iter() | |||
280 | * @param cls closure | 280 | * @param cls closure |
281 | */ | 281 | */ |
282 | static void | 282 | static void |
283 | timeout_fail(void *cls) | 283 | timeout_fail (void *cls) |
284 | { | 284 | { |
285 | tt = NULL; | 285 | tt = NULL; |
286 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, "Testcase failed with timeout\n"); | 286 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Testcase failed with timeout\n"); |
287 | GNUNET_SCHEDULER_shutdown(); | 287 | GNUNET_SCHEDULER_shutdown (); |
288 | ret = 1; | 288 | ret = 1; |
289 | } | 289 | } |
290 | 290 | ||
@@ -295,38 +295,38 @@ timeout_fail(void *cls) | |||
295 | * @param cls closure | 295 | * @param cls closure |
296 | */ | 296 | */ |
297 | static void | 297 | static void |
298 | do_shutdown(void *cls) | 298 | do_shutdown (void *cls) |
299 | { | 299 | { |
300 | if (NULL != tt) | 300 | if (NULL != tt) |
301 | { | 301 | { |
302 | GNUNET_SCHEDULER_cancel(tt); | 302 | GNUNET_SCHEDULER_cancel (tt); |
303 | tt = NULL; | 303 | tt = NULL; |
304 | } | 304 | } |
305 | if (NULL != oh1) | 305 | if (NULL != oh1) |
306 | { | 306 | { |
307 | GNUNET_SET_operation_cancel(oh1); | 307 | GNUNET_SET_operation_cancel (oh1); |
308 | oh1 = NULL; | 308 | oh1 = NULL; |
309 | } | 309 | } |
310 | if (NULL != oh2) | 310 | if (NULL != oh2) |
311 | { | 311 | { |
312 | GNUNET_SET_operation_cancel(oh2); | 312 | GNUNET_SET_operation_cancel (oh2); |
313 | oh2 = NULL; | 313 | oh2 = NULL; |
314 | } | 314 | } |
315 | if (NULL != set1) | 315 | if (NULL != set1) |
316 | { | 316 | { |
317 | GNUNET_SET_destroy(set1); | 317 | GNUNET_SET_destroy (set1); |
318 | set1 = NULL; | 318 | set1 = NULL; |
319 | } | 319 | } |
320 | if (NULL != set2) | 320 | if (NULL != set2) |
321 | { | 321 | { |
322 | GNUNET_SET_destroy(set2); | 322 | GNUNET_SET_destroy (set2); |
323 | set2 = NULL; | 323 | set2 = NULL; |
324 | } | 324 | } |
325 | if (NULL != listen_handle) | 325 | if (NULL != listen_handle) |
326 | { | 326 | { |
327 | GNUNET_SET_listen_cancel(listen_handle); | 327 | GNUNET_SET_listen_cancel (listen_handle); |
328 | listen_handle = NULL; | 328 | listen_handle = NULL; |
329 | } | 329 | } |
330 | } | 330 | } |
331 | 331 | ||
332 | 332 | ||
@@ -339,65 +339,65 @@ do_shutdown(void *cls) | |||
339 | * @param peer identity of the peer that was created | 339 | * @param peer identity of the peer that was created |
340 | */ | 340 | */ |
341 | static void | 341 | static void |
342 | run(void *cls, | 342 | run (void *cls, |
343 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 343 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
344 | struct GNUNET_TESTING_Peer *peer) | 344 | struct GNUNET_TESTING_Peer *peer) |
345 | { | 345 | { |
346 | struct GNUNET_SET_OperationHandle *my_oh; | 346 | struct GNUNET_SET_OperationHandle *my_oh; |
347 | 347 | ||
348 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Running preparatory tests\n"); | 348 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running preparatory tests\n"); |
349 | tt = GNUNET_SCHEDULER_add_delayed( | 349 | tt = GNUNET_SCHEDULER_add_delayed ( |
350 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5), | 350 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5), |
351 | &timeout_fail, | 351 | &timeout_fail, |
352 | NULL); | 352 | NULL); |
353 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL); | 353 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); |
354 | 354 | ||
355 | config = cfg; | 355 | config = cfg; |
356 | GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_get_peer_identity(cfg, &local_id)); | 356 | GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_get_peer_identity (cfg, &local_id)); |
357 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 357 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
358 | "my id (from CRYPTO): %s\n", | 358 | "my id (from CRYPTO): %s\n", |
359 | GNUNET_i2s(&local_id)); | 359 | GNUNET_i2s (&local_id)); |
360 | GNUNET_TESTING_peer_get_identity(peer, &local_id); | 360 | GNUNET_TESTING_peer_get_identity (peer, &local_id); |
361 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 361 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
362 | "my id (from TESTING): %s\n", | 362 | "my id (from TESTING): %s\n", |
363 | GNUNET_i2s(&local_id)); | 363 | GNUNET_i2s (&local_id)); |
364 | test_iter(); | 364 | test_iter (); |
365 | 365 | ||
366 | set1 = GNUNET_SET_create(cfg, GNUNET_SET_OPERATION_UNION); | 366 | set1 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION); |
367 | set2 = GNUNET_SET_create(cfg, GNUNET_SET_OPERATION_UNION); | 367 | set2 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION); |
368 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 368 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
369 | "Created sets %p and %p for union operation\n", | 369 | "Created sets %p and %p for union operation\n", |
370 | set1, | 370 | set1, |
371 | set2); | 371 | set2); |
372 | GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &app_id); | 372 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id); |
373 | 373 | ||
374 | /* test if canceling an uncommited request works! */ | 374 | /* test if canceling an uncommited request works! */ |
375 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 375 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
376 | "Launching and instantly stopping set operation\n"); | 376 | "Launching and instantly stopping set operation\n"); |
377 | my_oh = GNUNET_SET_prepare(&local_id, | 377 | my_oh = GNUNET_SET_prepare (&local_id, |
378 | &app_id, | 378 | &app_id, |
379 | NULL, | 379 | NULL, |
380 | GNUNET_SET_RESULT_ADDED, | 380 | GNUNET_SET_RESULT_ADDED, |
381 | (struct GNUNET_SET_Option[]){ 0 }, | 381 | (struct GNUNET_SET_Option[]){ 0 }, |
382 | NULL, | 382 | NULL, |
383 | NULL); | 383 | NULL); |
384 | GNUNET_SET_operation_cancel(my_oh); | 384 | GNUNET_SET_operation_cancel (my_oh); |
385 | 385 | ||
386 | /* test the real set reconciliation */ | 386 | /* test the real set reconciliation */ |
387 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Running real set-reconciliation\n"); | 387 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running real set-reconciliation\n"); |
388 | init_set1(); | 388 | init_set1 (); |
389 | } | 389 | } |
390 | 390 | ||
391 | 391 | ||
392 | int | 392 | int |
393 | main(int argc, char **argv) | 393 | main (int argc, char **argv) |
394 | { | 394 | { |
395 | GNUNET_log_setup("test_set_api", "WARNING", NULL); | 395 | GNUNET_log_setup ("test_set_api", "WARNING", NULL); |
396 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Launching peer\n"); | 396 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Launching peer\n"); |
397 | if (0 != | 397 | if (0 != |
398 | GNUNET_TESTING_peer_run("test_set_api", "test_set.conf", &run, NULL)) | 398 | GNUNET_TESTING_peer_run ("test_set_api", "test_set.conf", &run, NULL)) |
399 | { | 399 | { |
400 | return 1; | 400 | return 1; |
401 | } | 401 | } |
402 | return ret; | 402 | return ret; |
403 | } | 403 | } |
diff --git a/src/set/test_set_intersection_result_full.c b/src/set/test_set_intersection_result_full.c index 12ebcb64f..42dedb846 100644 --- a/src/set/test_set_intersection_result_full.c +++ b/src/set/test_set_intersection_result_full.c | |||
@@ -54,96 +54,96 @@ static struct GNUNET_SET_OperationHandle *oh2; | |||
54 | 54 | ||
55 | 55 | ||
56 | static void | 56 | static void |
57 | result_cb_set1(void *cls, | 57 | result_cb_set1 (void *cls, |
58 | const struct GNUNET_SET_Element *element, | 58 | const struct GNUNET_SET_Element *element, |
59 | uint64_t current_size, | 59 | uint64_t current_size, |
60 | enum GNUNET_SET_Status status) | 60 | enum GNUNET_SET_Status status) |
61 | { | 61 | { |
62 | static int count; | 62 | static int count; |
63 | 63 | ||
64 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 64 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
65 | "Processing result set 1 (%d)\n", | 65 | "Processing result set 1 (%d)\n", |
66 | status); | 66 | status); |
67 | switch (status) | 67 | switch (status) |
68 | { | 68 | { |
69 | case GNUNET_SET_STATUS_OK: | 69 | case GNUNET_SET_STATUS_OK: |
70 | count++; | 70 | count++; |
71 | break; | 71 | break; |
72 | 72 | ||
73 | case GNUNET_SET_STATUS_FAILURE: | 73 | case GNUNET_SET_STATUS_FAILURE: |
74 | oh1 = NULL; | 74 | oh1 = NULL; |
75 | ret = 1; | 75 | ret = 1; |
76 | break; | 76 | break; |
77 | 77 | ||
78 | case GNUNET_SET_STATUS_DONE: | 78 | case GNUNET_SET_STATUS_DONE: |
79 | oh1 = NULL; | 79 | oh1 = NULL; |
80 | GNUNET_assert(1 == count); | 80 | GNUNET_assert (1 == count); |
81 | GNUNET_SET_destroy(set1); | 81 | GNUNET_SET_destroy (set1); |
82 | set1 = NULL; | 82 | set1 = NULL; |
83 | if (NULL == set2) | 83 | if (NULL == set2) |
84 | GNUNET_SCHEDULER_shutdown(); | 84 | GNUNET_SCHEDULER_shutdown (); |
85 | break; | 85 | break; |
86 | 86 | ||
87 | default: | 87 | default: |
88 | GNUNET_assert(0); | 88 | GNUNET_assert (0); |
89 | } | 89 | } |
90 | } | 90 | } |
91 | 91 | ||
92 | 92 | ||
93 | static void | 93 | static void |
94 | result_cb_set2(void *cls, | 94 | result_cb_set2 (void *cls, |
95 | const struct GNUNET_SET_Element *element, | 95 | const struct GNUNET_SET_Element *element, |
96 | uint64_t current_size, | 96 | uint64_t current_size, |
97 | enum GNUNET_SET_Status status) | 97 | enum GNUNET_SET_Status status) |
98 | { | 98 | { |
99 | static int count; | 99 | static int count; |
100 | 100 | ||
101 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 101 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
102 | "Processing result set 2 (%d)\n", | 102 | "Processing result set 2 (%d)\n", |
103 | status); | 103 | status); |
104 | switch (status) | 104 | switch (status) |
105 | { | 105 | { |
106 | case GNUNET_SET_STATUS_OK: | 106 | case GNUNET_SET_STATUS_OK: |
107 | count++; | 107 | count++; |
108 | break; | 108 | break; |
109 | 109 | ||
110 | case GNUNET_SET_STATUS_FAILURE: | 110 | case GNUNET_SET_STATUS_FAILURE: |
111 | oh2 = NULL; | 111 | oh2 = NULL; |
112 | ret = 1; | 112 | ret = 1; |
113 | break; | 113 | break; |
114 | 114 | ||
115 | case GNUNET_SET_STATUS_DONE: | 115 | case GNUNET_SET_STATUS_DONE: |
116 | oh2 = NULL; | 116 | oh2 = NULL; |
117 | GNUNET_assert(1 == count); | 117 | GNUNET_assert (1 == count); |
118 | GNUNET_SET_destroy(set2); | 118 | GNUNET_SET_destroy (set2); |
119 | set2 = NULL; | 119 | set2 = NULL; |
120 | if (NULL == set1) | 120 | if (NULL == set1) |
121 | GNUNET_SCHEDULER_shutdown(); | 121 | GNUNET_SCHEDULER_shutdown (); |
122 | break; | 122 | break; |
123 | 123 | ||
124 | default: | 124 | default: |
125 | GNUNET_assert(0); | 125 | GNUNET_assert (0); |
126 | } | 126 | } |
127 | } | 127 | } |
128 | 128 | ||
129 | 129 | ||
130 | static void | 130 | static void |
131 | listen_cb(void *cls, | 131 | listen_cb (void *cls, |
132 | const struct GNUNET_PeerIdentity *other_peer, | 132 | const struct GNUNET_PeerIdentity *other_peer, |
133 | const struct GNUNET_MessageHeader *context_msg, | 133 | const struct GNUNET_MessageHeader *context_msg, |
134 | struct GNUNET_SET_Request *request) | 134 | struct GNUNET_SET_Request *request) |
135 | { | 135 | { |
136 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 136 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
137 | "starting intersection by accepting and committing\n"); | 137 | "starting intersection by accepting and committing\n"); |
138 | GNUNET_assert(NULL != context_msg); | 138 | GNUNET_assert (NULL != context_msg); |
139 | GNUNET_assert(ntohs(context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); | 139 | GNUNET_assert (ntohs (context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); |
140 | oh2 = GNUNET_SET_accept(request, | 140 | oh2 = GNUNET_SET_accept (request, |
141 | GNUNET_SET_RESULT_FULL, | 141 | GNUNET_SET_RESULT_FULL, |
142 | (struct GNUNET_SET_Option[]) { 0 }, | 142 | (struct GNUNET_SET_Option[]) { 0 }, |
143 | &result_cb_set2, | 143 | &result_cb_set2, |
144 | NULL); | 144 | NULL); |
145 | GNUNET_SET_commit(oh2, | 145 | GNUNET_SET_commit (oh2, |
146 | set2); | 146 | set2); |
147 | } | 147 | } |
148 | 148 | ||
149 | 149 | ||
@@ -153,28 +153,28 @@ listen_cb(void *cls, | |||
153 | * @param cls closure, unused | 153 | * @param cls closure, unused |
154 | */ | 154 | */ |
155 | static void | 155 | static void |
156 | start(void *cls) | 156 | start (void *cls) |
157 | { | 157 | { |
158 | struct GNUNET_MessageHeader context_msg; | 158 | struct GNUNET_MessageHeader context_msg; |
159 | 159 | ||
160 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 160 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
161 | "starting listener\n"); | 161 | "starting listener\n"); |
162 | context_msg.size = htons(sizeof context_msg); | 162 | context_msg.size = htons (sizeof context_msg); |
163 | context_msg.type = htons(GNUNET_MESSAGE_TYPE_DUMMY); | 163 | context_msg.type = htons (GNUNET_MESSAGE_TYPE_DUMMY); |
164 | listen_handle = GNUNET_SET_listen(config, | 164 | listen_handle = GNUNET_SET_listen (config, |
165 | GNUNET_SET_OPERATION_INTERSECTION, | 165 | GNUNET_SET_OPERATION_INTERSECTION, |
166 | &app_id, | 166 | &app_id, |
167 | &listen_cb, | 167 | &listen_cb, |
168 | NULL); | 168 | NULL); |
169 | oh1 = GNUNET_SET_prepare(&local_id, | 169 | oh1 = GNUNET_SET_prepare (&local_id, |
170 | &app_id, | 170 | &app_id, |
171 | &context_msg, | 171 | &context_msg, |
172 | GNUNET_SET_RESULT_FULL, | 172 | GNUNET_SET_RESULT_FULL, |
173 | (struct GNUNET_SET_Option[]) { 0 }, | 173 | (struct GNUNET_SET_Option[]) { 0 }, |
174 | &result_cb_set1, | 174 | &result_cb_set1, |
175 | NULL); | 175 | NULL); |
176 | GNUNET_SET_commit(oh1, | 176 | GNUNET_SET_commit (oh1, |
177 | set1); | 177 | set1); |
178 | } | 178 | } |
179 | 179 | ||
180 | 180 | ||
@@ -184,31 +184,31 @@ start(void *cls) | |||
184 | * @param cls closure, unused | 184 | * @param cls closure, unused |
185 | */ | 185 | */ |
186 | static void | 186 | static void |
187 | init_set2(void *cls) | 187 | init_set2 (void *cls) |
188 | { | 188 | { |
189 | struct GNUNET_SET_Element element; | 189 | struct GNUNET_SET_Element element; |
190 | 190 | ||
191 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 191 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
192 | "initializing set 2\n"); | 192 | "initializing set 2\n"); |
193 | element.element_type = 0; | 193 | element.element_type = 0; |
194 | element.data = "hello"; | 194 | element.data = "hello"; |
195 | element.size = strlen(element.data); | 195 | element.size = strlen (element.data); |
196 | GNUNET_SET_add_element(set2, | 196 | GNUNET_SET_add_element (set2, |
197 | &element, | 197 | &element, |
198 | NULL, | 198 | NULL, |
199 | NULL); | 199 | NULL); |
200 | element.data = "quux"; | 200 | element.data = "quux"; |
201 | element.size = strlen(element.data); | 201 | element.size = strlen (element.data); |
202 | GNUNET_SET_add_element(set2, | 202 | GNUNET_SET_add_element (set2, |
203 | &element, | 203 | &element, |
204 | NULL, | 204 | NULL, |
205 | NULL); | 205 | NULL); |
206 | element.data = "baz"; | 206 | element.data = "baz"; |
207 | element.size = strlen(element.data); | 207 | element.size = strlen (element.data); |
208 | GNUNET_SET_add_element(set2, | 208 | GNUNET_SET_add_element (set2, |
209 | &element, | 209 | &element, |
210 | &start, | 210 | &start, |
211 | NULL); | 211 | NULL); |
212 | } | 212 | } |
213 | 213 | ||
214 | 214 | ||
@@ -216,73 +216,73 @@ init_set2(void *cls) | |||
216 | * Initialize the first set, continue. | 216 | * Initialize the first set, continue. |
217 | */ | 217 | */ |
218 | static void | 218 | static void |
219 | init_set1(void) | 219 | init_set1 (void) |
220 | { | 220 | { |
221 | struct GNUNET_SET_Element element; | 221 | struct GNUNET_SET_Element element; |
222 | 222 | ||
223 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | 223 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
224 | "initializing set 1\n"); | 224 | "initializing set 1\n"); |
225 | element.element_type = 0; | 225 | element.element_type = 0; |
226 | element.data = "hello"; | 226 | element.data = "hello"; |
227 | element.size = strlen(element.data); | 227 | element.size = strlen (element.data); |
228 | GNUNET_SET_add_element(set1, | 228 | GNUNET_SET_add_element (set1, |
229 | &element, | 229 | &element, |
230 | NULL, | 230 | NULL, |
231 | NULL); | 231 | NULL); |
232 | element.data = "bar"; | 232 | element.data = "bar"; |
233 | element.size = strlen(element.data); | 233 | element.size = strlen (element.data); |
234 | GNUNET_SET_add_element(set1, | 234 | GNUNET_SET_add_element (set1, |
235 | &element, | 235 | &element, |
236 | &init_set2, | 236 | &init_set2, |
237 | NULL); | 237 | NULL); |
238 | } | 238 | } |
239 | 239 | ||
240 | 240 | ||
241 | static int | 241 | static int |
242 | iter_cb(void *cls, | 242 | iter_cb (void *cls, |
243 | const struct GNUNET_SET_Element *element) | 243 | const struct GNUNET_SET_Element *element) |
244 | { | 244 | { |
245 | if (NULL == element) | 245 | if (NULL == element) |
246 | { | 246 | { |
247 | GNUNET_assert(iter_count == 3); | 247 | GNUNET_assert (iter_count == 3); |
248 | GNUNET_SET_destroy(cls); | 248 | GNUNET_SET_destroy (cls); |
249 | return GNUNET_YES; | 249 | return GNUNET_YES; |
250 | } | 250 | } |
251 | iter_count++; | 251 | iter_count++; |
252 | return GNUNET_YES; | 252 | return GNUNET_YES; |
253 | } | 253 | } |
254 | 254 | ||
255 | 255 | ||
256 | static void | 256 | static void |
257 | test_iter() | 257 | test_iter () |
258 | { | 258 | { |
259 | struct GNUNET_SET_Element element; | 259 | struct GNUNET_SET_Element element; |
260 | struct GNUNET_SET_Handle *iter_set; | 260 | struct GNUNET_SET_Handle *iter_set; |
261 | 261 | ||
262 | iter_set = GNUNET_SET_create(config, | 262 | iter_set = GNUNET_SET_create (config, |
263 | GNUNET_SET_OPERATION_INTERSECTION); | 263 | GNUNET_SET_OPERATION_INTERSECTION); |
264 | element.element_type = 0; | 264 | element.element_type = 0; |
265 | element.data = "hello"; | 265 | element.data = "hello"; |
266 | element.size = strlen(element.data); | 266 | element.size = strlen (element.data); |
267 | GNUNET_SET_add_element(iter_set, | 267 | GNUNET_SET_add_element (iter_set, |
268 | &element, | 268 | &element, |
269 | NULL, | 269 | NULL, |
270 | NULL); | 270 | NULL); |
271 | element.data = "bar"; | 271 | element.data = "bar"; |
272 | element.size = strlen(element.data); | 272 | element.size = strlen (element.data); |
273 | GNUNET_SET_add_element(iter_set, | 273 | GNUNET_SET_add_element (iter_set, |
274 | &element, | 274 | &element, |
275 | NULL, | 275 | NULL, |
276 | NULL); | 276 | NULL); |
277 | element.data = "quux"; | 277 | element.data = "quux"; |
278 | element.size = strlen(element.data); | 278 | element.size = strlen (element.data); |
279 | GNUNET_SET_add_element(iter_set, | 279 | GNUNET_SET_add_element (iter_set, |
280 | &element, | 280 | &element, |
281 | NULL, | 281 | NULL, |
282 | NULL); | 282 | NULL); |
283 | GNUNET_SET_iterate(iter_set, | 283 | GNUNET_SET_iterate (iter_set, |
284 | &iter_cb, | 284 | &iter_cb, |
285 | iter_set); | 285 | iter_set); |
286 | } | 286 | } |
287 | 287 | ||
288 | 288 | ||
@@ -292,38 +292,38 @@ test_iter() | |||
292 | * @param cls closure | 292 | * @param cls closure |
293 | */ | 293 | */ |
294 | static void | 294 | static void |
295 | do_shutdown(void *cls) | 295 | do_shutdown (void *cls) |
296 | { | 296 | { |
297 | if (NULL != tt) | 297 | if (NULL != tt) |
298 | { | 298 | { |
299 | GNUNET_SCHEDULER_cancel(tt); | 299 | GNUNET_SCHEDULER_cancel (tt); |
300 | tt = NULL; | 300 | tt = NULL; |
301 | } | 301 | } |
302 | if (NULL != oh1) | 302 | if (NULL != oh1) |
303 | { | 303 | { |
304 | GNUNET_SET_operation_cancel(oh1); | 304 | GNUNET_SET_operation_cancel (oh1); |
305 | oh1 = NULL; | 305 | oh1 = NULL; |
306 | } | 306 | } |
307 | if (NULL != oh2) | 307 | if (NULL != oh2) |
308 | { | 308 | { |
309 | GNUNET_SET_operation_cancel(oh2); | 309 | GNUNET_SET_operation_cancel (oh2); |
310 | oh2 = NULL; | 310 | oh2 = NULL; |
311 | } | 311 | } |
312 | if (NULL != set1) | 312 | if (NULL != set1) |
313 | { | 313 | { |
314 | GNUNET_SET_destroy(set1); | 314 | GNUNET_SET_destroy (set1); |
315 | set1 = NULL; | 315 | set1 = NULL; |
316 | } | 316 | } |
317 | if (NULL != set2) | 317 | if (NULL != set2) |
318 | { | 318 | { |
319 | GNUNET_SET_destroy(set2); | 319 | GNUNET_SET_destroy (set2); |
320 | set2 = NULL; | 320 | set2 = NULL; |
321 | } | 321 | } |
322 | if (NULL != listen_handle) | 322 | if (NULL != listen_handle) |
323 | { | 323 | { |
324 | GNUNET_SET_listen_cancel(listen_handle); | 324 | GNUNET_SET_listen_cancel (listen_handle); |
325 | listen_handle = NULL; | 325 | listen_handle = NULL; |
326 | } | 326 | } |
327 | } | 327 | } |
328 | 328 | ||
329 | 329 | ||
@@ -333,12 +333,12 @@ do_shutdown(void *cls) | |||
333 | * @param cls closure | 333 | * @param cls closure |
334 | */ | 334 | */ |
335 | static void | 335 | static void |
336 | timeout_fail(void *cls) | 336 | timeout_fail (void *cls) |
337 | { | 337 | { |
338 | tt = NULL; | 338 | tt = NULL; |
339 | GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, | 339 | GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, |
340 | "Testcase failed with timeout\n"); | 340 | "Testcase failed with timeout\n"); |
341 | GNUNET_SCHEDULER_shutdown(); | 341 | GNUNET_SCHEDULER_shutdown (); |
342 | ret = 1; | 342 | ret = 1; |
343 | } | 343 | } |
344 | 344 | ||
@@ -352,41 +352,42 @@ timeout_fail(void *cls) | |||
352 | * @param peer identity of the peer that was created | 352 | * @param peer identity of the peer that was created |
353 | */ | 353 | */ |
354 | static void | 354 | static void |
355 | run(void *cls, | 355 | run (void *cls, |
356 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 356 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
357 | struct GNUNET_TESTING_Peer *peer) | 357 | struct GNUNET_TESTING_Peer *peer) |
358 | { | 358 | { |
359 | config = cfg; | 359 | config = cfg; |
360 | GNUNET_TESTING_peer_get_identity(peer, | 360 | GNUNET_TESTING_peer_get_identity (peer, |
361 | &local_id); | 361 | &local_id); |
362 | if (0) | 362 | if (0) |
363 | test_iter(); | 363 | test_iter (); |
364 | 364 | ||
365 | tt = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5), | 365 | tt = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply ( |
366 | &timeout_fail, | 366 | GNUNET_TIME_UNIT_SECONDS, 5), |
367 | NULL); | 367 | &timeout_fail, |
368 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, | 368 | NULL); |
369 | NULL); | 369 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, |
370 | 370 | NULL); | |
371 | set1 = GNUNET_SET_create(cfg, | 371 | |
372 | GNUNET_SET_OPERATION_INTERSECTION); | 372 | set1 = GNUNET_SET_create (cfg, |
373 | set2 = GNUNET_SET_create(cfg, | 373 | GNUNET_SET_OPERATION_INTERSECTION); |
374 | GNUNET_SET_OPERATION_INTERSECTION); | 374 | set2 = GNUNET_SET_create (cfg, |
375 | GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, | 375 | GNUNET_SET_OPERATION_INTERSECTION); |
376 | &app_id); | 376 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, |
377 | &app_id); | ||
377 | 378 | ||
378 | /* test the real set reconciliation */ | 379 | /* test the real set reconciliation */ |
379 | init_set1(); | 380 | init_set1 (); |
380 | } | 381 | } |
381 | 382 | ||
382 | 383 | ||
383 | int | 384 | int |
384 | main(int argc, | 385 | main (int argc, |
385 | char **argv) | 386 | char **argv) |
386 | { | 387 | { |
387 | if (0 != GNUNET_TESTING_peer_run("test_set_intersection_result_full", | 388 | if (0 != GNUNET_TESTING_peer_run ("test_set_intersection_result_full", |
388 | "test_set.conf", | 389 | "test_set.conf", |
389 | &run, NULL)) | 390 | &run, NULL)) |
390 | return 1; | 391 | return 1; |
391 | return ret; | 392 | return ret; |
392 | } | 393 | } |
diff --git a/src/set/test_set_union_copy.c b/src/set/test_set_union_copy.c index ab76668cc..908527017 100644 --- a/src/set/test_set_union_copy.c +++ b/src/set/test_set_union_copy.c | |||
@@ -47,34 +47,34 @@ static struct GNUNET_SCHEDULER_Task *tt; | |||
47 | 47 | ||
48 | 48 | ||
49 | static void | 49 | static void |
50 | add_element_str(struct GNUNET_SET_Handle *set, | 50 | add_element_str (struct GNUNET_SET_Handle *set, |
51 | char *str) | 51 | char *str) |
52 | { | 52 | { |
53 | struct GNUNET_SET_Element element; | 53 | struct GNUNET_SET_Element element; |
54 | 54 | ||
55 | element.element_type = 0; | 55 | element.element_type = 0; |
56 | element.data = str; | 56 | element.data = str; |
57 | element.size = strlen(str); | 57 | element.size = strlen (str); |
58 | GNUNET_SET_add_element(set, | 58 | GNUNET_SET_add_element (set, |
59 | &element, | 59 | &element, |
60 | NULL, | 60 | NULL, |
61 | NULL); | 61 | NULL); |
62 | } | 62 | } |
63 | 63 | ||
64 | 64 | ||
65 | static void | 65 | static void |
66 | remove_element_str(struct GNUNET_SET_Handle *set, | 66 | remove_element_str (struct GNUNET_SET_Handle *set, |
67 | char *str) | 67 | char *str) |
68 | { | 68 | { |
69 | struct GNUNET_SET_Element element; | 69 | struct GNUNET_SET_Element element; |
70 | 70 | ||
71 | element.element_type = 0; | 71 | element.element_type = 0; |
72 | element.data = str; | 72 | element.data = str; |
73 | element.size = strlen(str); | 73 | element.size = strlen (str); |
74 | GNUNET_SET_remove_element(set, | 74 | GNUNET_SET_remove_element (set, |
75 | &element, | 75 | &element, |
76 | NULL, | 76 | NULL, |
77 | NULL); | 77 | NULL); |
78 | } | 78 | } |
79 | 79 | ||
80 | 80 | ||
@@ -84,15 +84,16 @@ remove_element_str(struct GNUNET_SET_Handle *set, | |||
84 | * @param cls closure | 84 | * @param cls closure |
85 | */ | 85 | */ |
86 | static void | 86 | static void |
87 | timeout_fail(void *cls) | 87 | timeout_fail (void *cls) |
88 | { | 88 | { |
89 | tt = NULL; | 89 | tt = NULL; |
90 | GNUNET_SCHEDULER_shutdown(); | 90 | GNUNET_SCHEDULER_shutdown (); |
91 | ret = 1; | 91 | ret = 1; |
92 | } | 92 | } |
93 | 93 | ||
94 | 94 | ||
95 | struct CountIterClosure { | 95 | struct CountIterClosure |
96 | { | ||
96 | unsigned int expected_count; | 97 | unsigned int expected_count; |
97 | unsigned int ongoing_count; | 98 | unsigned int ongoing_count; |
98 | GNUNET_SCHEDULER_TaskCallback cont; | 99 | GNUNET_SCHEDULER_TaskCallback cont; |
@@ -102,33 +103,33 @@ struct CountIterClosure { | |||
102 | 103 | ||
103 | 104 | ||
104 | static int | 105 | static int |
105 | check_count_iter(void *cls, | 106 | check_count_iter (void *cls, |
106 | const struct GNUNET_SET_Element *element) | 107 | const struct GNUNET_SET_Element *element) |
107 | { | 108 | { |
108 | struct CountIterClosure *ci_cls = cls; | 109 | struct CountIterClosure *ci_cls = cls; |
109 | 110 | ||
110 | if (NULL == element) | 111 | if (NULL == element) |
112 | { | ||
113 | if (ci_cls->expected_count != ci_cls->ongoing_count) | ||
111 | { | 114 | { |
112 | if (ci_cls->expected_count != ci_cls->ongoing_count) | 115 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
113 | { | 116 | "Expected count (what: %s) to be %u, but it's actually %u\n", |
114 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 117 | ci_cls->what, |
115 | "Expected count (what: %s) to be %u, but it's actually %u\n", | 118 | ci_cls->expected_count, |
116 | ci_cls->what, | 119 | ci_cls->ongoing_count); |
117 | ci_cls->expected_count, | 120 | ret = 1; |
118 | ci_cls->ongoing_count); | 121 | GNUNET_SCHEDULER_shutdown (); |
119 | ret = 1; | ||
120 | GNUNET_SCHEDULER_shutdown(); | ||
121 | return GNUNET_NO; | ||
122 | } | ||
123 | ci_cls->cont(ci_cls->cont_cls); | ||
124 | GNUNET_free(ci_cls); | ||
125 | return GNUNET_NO; | 122 | return GNUNET_NO; |
126 | } | 123 | } |
127 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 124 | ci_cls->cont (ci_cls->cont_cls); |
128 | "Set `%s' has element %.*s\n", | 125 | GNUNET_free (ci_cls); |
129 | ci_cls->what, | 126 | return GNUNET_NO; |
130 | (int)element->size, | 127 | } |
131 | (const char *)element->data); | 128 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
129 | "Set `%s' has element %.*s\n", | ||
130 | ci_cls->what, | ||
131 | (int) element->size, | ||
132 | (const char *) element->data); | ||
132 | 133 | ||
133 | ci_cls->ongoing_count++; | 134 | ci_cls->ongoing_count++; |
134 | return GNUNET_YES; | 135 | return GNUNET_YES; |
@@ -136,17 +137,17 @@ check_count_iter(void *cls, | |||
136 | 137 | ||
137 | 138 | ||
138 | static void | 139 | static void |
139 | check_count(struct GNUNET_SET_Handle *set, | 140 | check_count (struct GNUNET_SET_Handle *set, |
140 | char *what, | 141 | char *what, |
141 | unsigned int expected_count, | 142 | unsigned int expected_count, |
142 | GNUNET_SCHEDULER_TaskCallback cont, | 143 | GNUNET_SCHEDULER_TaskCallback cont, |
143 | void *cont_cls) | 144 | void *cont_cls) |
144 | { | 145 | { |
145 | struct CountIterClosure *ci_cls = GNUNET_new(struct CountIterClosure); | 146 | struct CountIterClosure *ci_cls = GNUNET_new (struct CountIterClosure); |
146 | 147 | ||
147 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 148 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
148 | "Checking count of %s\n", | 149 | "Checking count of %s\n", |
149 | what); | 150 | what); |
150 | 151 | ||
151 | ci_cls->expected_count = expected_count; | 152 | ci_cls->expected_count = expected_count; |
152 | ci_cls->ongoing_count = 0; | 153 | ci_cls->ongoing_count = 0; |
@@ -154,65 +155,65 @@ check_count(struct GNUNET_SET_Handle *set, | |||
154 | ci_cls->cont_cls = cont_cls; | 155 | ci_cls->cont_cls = cont_cls; |
155 | ci_cls->what = what; | 156 | ci_cls->what = what; |
156 | 157 | ||
157 | GNUNET_assert(GNUNET_YES == | 158 | GNUNET_assert (GNUNET_YES == |
158 | GNUNET_SET_iterate(set, | 159 | GNUNET_SET_iterate (set, |
159 | &check_count_iter, | 160 | &check_count_iter, |
160 | ci_cls)); | 161 | ci_cls)); |
161 | } | 162 | } |
162 | 163 | ||
163 | 164 | ||
164 | static void | 165 | static void |
165 | test_done(void *cls) | 166 | test_done (void *cls) |
166 | { | 167 | { |
167 | GNUNET_SCHEDULER_shutdown(); | 168 | GNUNET_SCHEDULER_shutdown (); |
168 | } | 169 | } |
169 | 170 | ||
170 | 171 | ||
171 | static void | 172 | static void |
172 | check_new_set_count(void *cls) | 173 | check_new_set_count (void *cls) |
173 | { | 174 | { |
174 | check_count(set2, | 175 | check_count (set2, |
175 | "new set", | 176 | "new set", |
176 | 3, | 177 | 3, |
177 | &test_done, | 178 | &test_done, |
178 | NULL); | 179 | NULL); |
179 | } | 180 | } |
180 | 181 | ||
181 | 182 | ||
182 | static void | 183 | static void |
183 | copy_done(void *cls, | 184 | copy_done (void *cls, |
184 | struct GNUNET_SET_Handle *new_set) | 185 | struct GNUNET_SET_Handle *new_set) |
185 | { | 186 | { |
186 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 187 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
187 | "copy done\n"); | 188 | "copy done\n"); |
188 | set2 = new_set; | 189 | set2 = new_set; |
189 | remove_element_str(set2, | 190 | remove_element_str (set2, |
190 | "k5555"); | 191 | "k5555"); |
191 | add_element_str(set2, | 192 | add_element_str (set2, |
192 | "n66666"); | 193 | "n66666"); |
193 | add_element_str(set2, | 194 | add_element_str (set2, |
194 | "new2butremoved"); | 195 | "new2butremoved"); |
195 | remove_element_str(set2, | 196 | remove_element_str (set2, |
196 | "new2butremoved"); | 197 | "new2butremoved"); |
197 | remove_element_str(set2, | 198 | remove_element_str (set2, |
198 | "new3justremoved"); | 199 | "new3justremoved"); |
199 | // Check that set1 didn't change. | 200 | // Check that set1 didn't change. |
200 | check_count(set1, | 201 | check_count (set1, |
201 | "old set", | 202 | "old set", |
202 | 3, | 203 | 3, |
203 | &check_new_set_count, | 204 | &check_new_set_count, |
204 | NULL); | 205 | NULL); |
205 | } | 206 | } |
206 | 207 | ||
207 | 208 | ||
208 | static void | 209 | static void |
209 | test_copy(void *cls) | 210 | test_copy (void *cls) |
210 | { | 211 | { |
211 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 212 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
212 | "about to copy\n"); | 213 | "about to copy\n"); |
213 | GNUNET_SET_copy_lazy(set1, | 214 | GNUNET_SET_copy_lazy (set1, |
214 | ©_done, | 215 | ©_done, |
215 | NULL); | 216 | NULL); |
216 | } | 217 | } |
217 | 218 | ||
218 | 219 | ||
@@ -222,23 +223,23 @@ test_copy(void *cls) | |||
222 | * @param cls closure | 223 | * @param cls closure |
223 | */ | 224 | */ |
224 | static void | 225 | static void |
225 | do_shutdown(void *cls) | 226 | do_shutdown (void *cls) |
226 | { | 227 | { |
227 | if (NULL != tt) | 228 | if (NULL != tt) |
228 | { | 229 | { |
229 | GNUNET_SCHEDULER_cancel(tt); | 230 | GNUNET_SCHEDULER_cancel (tt); |
230 | tt = NULL; | 231 | tt = NULL; |
231 | } | 232 | } |
232 | if (NULL != set1) | 233 | if (NULL != set1) |
233 | { | 234 | { |
234 | GNUNET_SET_destroy(set1); | 235 | GNUNET_SET_destroy (set1); |
235 | set1 = NULL; | 236 | set1 = NULL; |
236 | } | 237 | } |
237 | if (NULL != set2) | 238 | if (NULL != set2) |
238 | { | 239 | { |
239 | GNUNET_SET_destroy(set2); | 240 | GNUNET_SET_destroy (set2); |
240 | set2 = NULL; | 241 | set2 = NULL; |
241 | } | 242 | } |
242 | } | 243 | } |
243 | 244 | ||
244 | 245 | ||
@@ -251,59 +252,60 @@ do_shutdown(void *cls) | |||
251 | * @param peer identity of the peer that was created | 252 | * @param peer identity of the peer that was created |
252 | */ | 253 | */ |
253 | static void | 254 | static void |
254 | run(void *cls, | 255 | run (void *cls, |
255 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 256 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
256 | struct GNUNET_TESTING_Peer *peer) | 257 | struct GNUNET_TESTING_Peer *peer) |
257 | { | 258 | { |
258 | tt = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5), | 259 | tt = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply ( |
259 | &timeout_fail, | 260 | GNUNET_TIME_UNIT_SECONDS, 5), |
260 | NULL); | 261 | &timeout_fail, |
261 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, | 262 | NULL); |
262 | NULL); | 263 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, |
264 | NULL); | ||
263 | config = cfg; | 265 | config = cfg; |
264 | GNUNET_TESTING_peer_get_identity(peer, | 266 | GNUNET_TESTING_peer_get_identity (peer, |
265 | &local_id); | 267 | &local_id); |
266 | 268 | ||
267 | set1 = GNUNET_SET_create(cfg, | 269 | set1 = GNUNET_SET_create (cfg, |
268 | GNUNET_SET_OPERATION_UNION); | 270 | GNUNET_SET_OPERATION_UNION); |
269 | add_element_str(set1, | 271 | add_element_str (set1, |
270 | "333"); | 272 | "333"); |
271 | add_element_str(set1, | 273 | add_element_str (set1, |
272 | "k444"); | 274 | "k444"); |
273 | /* duplicate -- ignored */ | 275 | /* duplicate -- ignored */ |
274 | add_element_str(set1, | 276 | add_element_str (set1, |
275 | "k444"); | 277 | "k444"); |
276 | remove_element_str(set1, | 278 | remove_element_str (set1, |
277 | "333"); | 279 | "333"); |
278 | /* non-existent -- ignored */ | 280 | /* non-existent -- ignored */ |
279 | remove_element_str(set1, | 281 | remove_element_str (set1, |
280 | "999999999"); | 282 | "999999999"); |
281 | add_element_str(set1, | 283 | add_element_str (set1, |
282 | "k5555"); | 284 | "k5555"); |
283 | /* duplicate -- ignored */ | 285 | /* duplicate -- ignored */ |
284 | remove_element_str(set1, | 286 | remove_element_str (set1, |
285 | "333"); | 287 | "333"); |
286 | add_element_str(set1, | 288 | add_element_str (set1, |
287 | "k2"); | 289 | "k2"); |
288 | 290 | ||
289 | check_count(set1, | 291 | check_count (set1, |
290 | "initial test", | 292 | "initial test", |
291 | 3, | 293 | 3, |
292 | &test_copy, | 294 | &test_copy, |
293 | NULL); | 295 | NULL); |
294 | } | 296 | } |
295 | 297 | ||
296 | 298 | ||
297 | int | 299 | int |
298 | main(int argc, char **argv) | 300 | main (int argc, char **argv) |
299 | { | 301 | { |
300 | if (0 != GNUNET_TESTING_peer_run("test_set_union_copy", | 302 | if (0 != GNUNET_TESTING_peer_run ("test_set_union_copy", |
301 | "test_set.conf", | 303 | "test_set.conf", |
302 | &run, NULL)) | 304 | &run, NULL)) |
303 | { | 305 | { |
304 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 306 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
305 | "failed to start testing peer\n"); | 307 | "failed to start testing peer\n"); |
306 | return 1; | 308 | return 1; |
307 | } | 309 | } |
308 | return ret; | 310 | return ret; |
309 | } | 311 | } |
diff --git a/src/set/test_set_union_result_symmetric.c b/src/set/test_set_union_result_symmetric.c index 5238aa596..b6c7a82f6 100644 --- a/src/set/test_set_union_result_symmetric.c +++ b/src/set/test_set_union_result_symmetric.c | |||
@@ -75,128 +75,128 @@ static struct GNUNET_SCHEDULER_Task *timeout_task; | |||
75 | 75 | ||
76 | 76 | ||
77 | static void | 77 | static void |
78 | result_cb_set1(void *cls, | 78 | result_cb_set1 (void *cls, |
79 | const struct GNUNET_SET_Element *element, | 79 | const struct GNUNET_SET_Element *element, |
80 | uint64_t current_size, | 80 | uint64_t current_size, |
81 | enum GNUNET_SET_Status status) | 81 | enum GNUNET_SET_Status status) |
82 | { | 82 | { |
83 | switch (status) | 83 | switch (status) |
84 | { | ||
85 | case GNUNET_SET_STATUS_ADD_LOCAL: | ||
86 | count_set1++; | ||
87 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
88 | "set 1: got element\n"); | ||
89 | break; | ||
90 | |||
91 | case GNUNET_SET_STATUS_FAILURE: | ||
92 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
93 | "set 1: failure\n"); | ||
94 | oh1 = NULL; | ||
95 | ret = 1; | ||
96 | if (NULL != timeout_task) | ||
97 | { | ||
98 | GNUNET_SCHEDULER_cancel (timeout_task); | ||
99 | timeout_task = NULL; | ||
100 | } | ||
101 | GNUNET_SCHEDULER_shutdown (); | ||
102 | break; | ||
103 | |||
104 | case GNUNET_SET_STATUS_DONE: | ||
105 | oh1 = NULL; | ||
106 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
107 | "set 1: done\n"); | ||
108 | GNUNET_SET_destroy (set1); | ||
109 | set1 = NULL; | ||
110 | if (NULL == set2) | ||
84 | { | 111 | { |
85 | case GNUNET_SET_STATUS_ADD_LOCAL: | ||
86 | count_set1++; | ||
87 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
88 | "set 1: got element\n"); | ||
89 | break; | ||
90 | |||
91 | case GNUNET_SET_STATUS_FAILURE: | ||
92 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
93 | "set 1: failure\n"); | ||
94 | oh1 = NULL; | ||
95 | ret = 1; | ||
96 | if (NULL != timeout_task) | 112 | if (NULL != timeout_task) |
97 | { | 113 | { |
98 | GNUNET_SCHEDULER_cancel(timeout_task); | 114 | GNUNET_SCHEDULER_cancel (timeout_task); |
99 | timeout_task = NULL; | 115 | timeout_task = NULL; |
100 | } | 116 | } |
101 | GNUNET_SCHEDULER_shutdown(); | 117 | GNUNET_SCHEDULER_shutdown (); |
102 | break; | ||
103 | |||
104 | case GNUNET_SET_STATUS_DONE: | ||
105 | oh1 = NULL; | ||
106 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
107 | "set 1: done\n"); | ||
108 | GNUNET_SET_destroy(set1); | ||
109 | set1 = NULL; | ||
110 | if (NULL == set2) | ||
111 | { | ||
112 | if (NULL != timeout_task) | ||
113 | { | ||
114 | GNUNET_SCHEDULER_cancel(timeout_task); | ||
115 | timeout_task = NULL; | ||
116 | } | ||
117 | GNUNET_SCHEDULER_shutdown(); | ||
118 | } | ||
119 | break; | ||
120 | |||
121 | case GNUNET_SET_STATUS_ADD_REMOTE: | ||
122 | break; | ||
123 | |||
124 | default: | ||
125 | GNUNET_assert(0); | ||
126 | } | 118 | } |
119 | break; | ||
120 | |||
121 | case GNUNET_SET_STATUS_ADD_REMOTE: | ||
122 | break; | ||
123 | |||
124 | default: | ||
125 | GNUNET_assert (0); | ||
126 | } | ||
127 | } | 127 | } |
128 | 128 | ||
129 | 129 | ||
130 | static void | 130 | static void |
131 | result_cb_set2(void *cls, | 131 | result_cb_set2 (void *cls, |
132 | const struct GNUNET_SET_Element *element, | 132 | const struct GNUNET_SET_Element *element, |
133 | uint64_t current_size, | 133 | uint64_t current_size, |
134 | enum GNUNET_SET_Status status) | 134 | enum GNUNET_SET_Status status) |
135 | { | 135 | { |
136 | switch (status) | 136 | switch (status) |
137 | { | ||
138 | case GNUNET_SET_STATUS_ADD_LOCAL: | ||
139 | count_set2++; | ||
140 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
141 | "set 2: got element\n"); | ||
142 | break; | ||
143 | |||
144 | case GNUNET_SET_STATUS_FAILURE: | ||
145 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
146 | "set 2: failure\n"); | ||
147 | oh2 = NULL; | ||
148 | ret = 1; | ||
149 | if (NULL != timeout_task) | ||
150 | { | ||
151 | GNUNET_SCHEDULER_cancel (timeout_task); | ||
152 | timeout_task = NULL; | ||
153 | } | ||
154 | GNUNET_SCHEDULER_shutdown (); | ||
155 | break; | ||
156 | |||
157 | case GNUNET_SET_STATUS_DONE: | ||
158 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
159 | "set 2: done\n"); | ||
160 | oh2 = NULL; | ||
161 | GNUNET_SET_destroy (set2); | ||
162 | set2 = NULL; | ||
163 | if (NULL == set1) | ||
137 | { | 164 | { |
138 | case GNUNET_SET_STATUS_ADD_LOCAL: | ||
139 | count_set2++; | ||
140 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
141 | "set 2: got element\n"); | ||
142 | break; | ||
143 | |||
144 | case GNUNET_SET_STATUS_FAILURE: | ||
145 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
146 | "set 2: failure\n"); | ||
147 | oh2 = NULL; | ||
148 | ret = 1; | ||
149 | if (NULL != timeout_task) | 165 | if (NULL != timeout_task) |
150 | { | 166 | { |
151 | GNUNET_SCHEDULER_cancel(timeout_task); | 167 | GNUNET_SCHEDULER_cancel (timeout_task); |
152 | timeout_task = NULL; | 168 | timeout_task = NULL; |
153 | } | 169 | } |
154 | GNUNET_SCHEDULER_shutdown(); | 170 | GNUNET_SCHEDULER_shutdown (); |
155 | break; | ||
156 | |||
157 | case GNUNET_SET_STATUS_DONE: | ||
158 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
159 | "set 2: done\n"); | ||
160 | oh2 = NULL; | ||
161 | GNUNET_SET_destroy(set2); | ||
162 | set2 = NULL; | ||
163 | if (NULL == set1) | ||
164 | { | ||
165 | if (NULL != timeout_task) | ||
166 | { | ||
167 | GNUNET_SCHEDULER_cancel(timeout_task); | ||
168 | timeout_task = NULL; | ||
169 | } | ||
170 | GNUNET_SCHEDULER_shutdown(); | ||
171 | } | ||
172 | break; | ||
173 | |||
174 | case GNUNET_SET_STATUS_ADD_REMOTE: | ||
175 | break; | ||
176 | |||
177 | default: | ||
178 | GNUNET_assert(0); | ||
179 | } | 171 | } |
172 | break; | ||
173 | |||
174 | case GNUNET_SET_STATUS_ADD_REMOTE: | ||
175 | break; | ||
176 | |||
177 | default: | ||
178 | GNUNET_assert (0); | ||
179 | } | ||
180 | } | 180 | } |
181 | 181 | ||
182 | 182 | ||
183 | static void | 183 | static void |
184 | listen_cb(void *cls, | 184 | listen_cb (void *cls, |
185 | const struct GNUNET_PeerIdentity *other_peer, | 185 | const struct GNUNET_PeerIdentity *other_peer, |
186 | const struct GNUNET_MessageHeader *context_msg, | 186 | const struct GNUNET_MessageHeader *context_msg, |
187 | struct GNUNET_SET_Request *request) | 187 | struct GNUNET_SET_Request *request) |
188 | { | 188 | { |
189 | GNUNET_assert(NULL != context_msg); | 189 | GNUNET_assert (NULL != context_msg); |
190 | GNUNET_assert(ntohs(context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); | 190 | GNUNET_assert (ntohs (context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY); |
191 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 191 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
192 | "listen cb called\n"); | 192 | "listen cb called\n"); |
193 | oh2 = GNUNET_SET_accept(request, | 193 | oh2 = GNUNET_SET_accept (request, |
194 | GNUNET_SET_RESULT_SYMMETRIC, | 194 | GNUNET_SET_RESULT_SYMMETRIC, |
195 | (struct GNUNET_SET_Option[]) { 0 }, | 195 | (struct GNUNET_SET_Option[]) { 0 }, |
196 | &result_cb_set2, | 196 | &result_cb_set2, |
197 | NULL); | 197 | NULL); |
198 | GNUNET_SET_commit(oh2, | 198 | GNUNET_SET_commit (oh2, |
199 | set2); | 199 | set2); |
200 | } | 200 | } |
201 | 201 | ||
202 | 202 | ||
@@ -206,24 +206,24 @@ listen_cb(void *cls, | |||
206 | * @param cls closure, unused | 206 | * @param cls closure, unused |
207 | */ | 207 | */ |
208 | static void | 208 | static void |
209 | start(void *cls) | 209 | start (void *cls) |
210 | { | 210 | { |
211 | struct GNUNET_MessageHeader context_msg; | 211 | struct GNUNET_MessageHeader context_msg; |
212 | 212 | ||
213 | context_msg.size = htons(sizeof context_msg); | 213 | context_msg.size = htons (sizeof context_msg); |
214 | context_msg.type = htons(GNUNET_MESSAGE_TYPE_DUMMY); | 214 | context_msg.type = htons (GNUNET_MESSAGE_TYPE_DUMMY); |
215 | 215 | ||
216 | listen_handle = GNUNET_SET_listen(config, | 216 | listen_handle = GNUNET_SET_listen (config, |
217 | GNUNET_SET_OPERATION_UNION, | 217 | GNUNET_SET_OPERATION_UNION, |
218 | &app_id, | 218 | &app_id, |
219 | &listen_cb, NULL); | 219 | &listen_cb, NULL); |
220 | oh1 = GNUNET_SET_prepare(&local_id, | 220 | oh1 = GNUNET_SET_prepare (&local_id, |
221 | &app_id, | 221 | &app_id, |
222 | &context_msg, | 222 | &context_msg, |
223 | GNUNET_SET_RESULT_SYMMETRIC, | 223 | GNUNET_SET_RESULT_SYMMETRIC, |
224 | (struct GNUNET_SET_Option[]) { 0 }, | 224 | (struct GNUNET_SET_Option[]) { 0 }, |
225 | &result_cb_set1, NULL); | 225 | &result_cb_set1, NULL); |
226 | GNUNET_SET_commit(oh1, set1); | 226 | GNUNET_SET_commit (oh1, set1); |
227 | } | 227 | } |
228 | 228 | ||
229 | 229 | ||
@@ -233,35 +233,35 @@ start(void *cls) | |||
233 | * @param cls closure, unused | 233 | * @param cls closure, unused |
234 | */ | 234 | */ |
235 | static void | 235 | static void |
236 | init_set2(void *cls) | 236 | init_set2 (void *cls) |
237 | { | 237 | { |
238 | struct GNUNET_SET_Element element; | 238 | struct GNUNET_SET_Element element; |
239 | 239 | ||
240 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 240 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
241 | "initializing set 2\n"); | 241 | "initializing set 2\n"); |
242 | if (empty) | 242 | if (empty) |
243 | { | 243 | { |
244 | start(NULL); | 244 | start (NULL); |
245 | return; | 245 | return; |
246 | } | 246 | } |
247 | element.element_type = 0; | 247 | element.element_type = 0; |
248 | element.data = "hello"; | 248 | element.data = "hello"; |
249 | element.size = strlen(element.data); | 249 | element.size = strlen (element.data); |
250 | GNUNET_SET_add_element(set2, | 250 | GNUNET_SET_add_element (set2, |
251 | &element, | 251 | &element, |
252 | NULL, | 252 | NULL, |
253 | NULL); | 253 | NULL); |
254 | element.data = "quux"; | 254 | element.data = "quux"; |
255 | element.size = strlen(element.data); | 255 | element.size = strlen (element.data); |
256 | GNUNET_SET_add_element(set2, | 256 | GNUNET_SET_add_element (set2, |
257 | &element, | 257 | &element, |
258 | NULL, | 258 | NULL, |
259 | NULL); | 259 | NULL); |
260 | element.data = "baz"; | 260 | element.data = "baz"; |
261 | element.size = strlen(element.data); | 261 | element.size = strlen (element.data); |
262 | GNUNET_SET_add_element(set2, | 262 | GNUNET_SET_add_element (set2, |
263 | &element, | 263 | &element, |
264 | &start, NULL); | 264 | &start, NULL); |
265 | } | 265 | } |
266 | 266 | ||
267 | 267 | ||
@@ -269,72 +269,72 @@ init_set2(void *cls) | |||
269 | * Initialize the first set, continue. | 269 | * Initialize the first set, continue. |
270 | */ | 270 | */ |
271 | static void | 271 | static void |
272 | init_set1(void) | 272 | init_set1 (void) |
273 | { | 273 | { |
274 | struct GNUNET_SET_Element element; | 274 | struct GNUNET_SET_Element element; |
275 | 275 | ||
276 | if (empty) | 276 | if (empty) |
277 | { | 277 | { |
278 | init_set2(NULL); | 278 | init_set2 (NULL); |
279 | return; | 279 | return; |
280 | } | 280 | } |
281 | element.element_type = 0; | 281 | element.element_type = 0; |
282 | element.data = "hello"; | 282 | element.data = "hello"; |
283 | element.size = strlen(element.data); | 283 | element.size = strlen (element.data); |
284 | GNUNET_SET_add_element(set1, | 284 | GNUNET_SET_add_element (set1, |
285 | &element, | 285 | &element, |
286 | NULL, | 286 | NULL, |
287 | NULL); | 287 | NULL); |
288 | element.data = "bar"; | 288 | element.data = "bar"; |
289 | element.size = strlen(element.data); | 289 | element.size = strlen (element.data); |
290 | GNUNET_SET_add_element(set1, | 290 | GNUNET_SET_add_element (set1, |
291 | &element, | 291 | &element, |
292 | &init_set2, | 292 | &init_set2, |
293 | NULL); | 293 | NULL); |
294 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 294 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
295 | "initialized set 1\n"); | 295 | "initialized set 1\n"); |
296 | } | 296 | } |
297 | 297 | ||
298 | 298 | ||
299 | static int | 299 | static int |
300 | iter_cb(void *cls, | 300 | iter_cb (void *cls, |
301 | const struct GNUNET_SET_Element *element) | 301 | const struct GNUNET_SET_Element *element) |
302 | { | 302 | { |
303 | if (NULL == element) | 303 | if (NULL == element) |
304 | { | 304 | { |
305 | GNUNET_assert(iter_count == 3); | 305 | GNUNET_assert (iter_count == 3); |
306 | GNUNET_SET_destroy(cls); | 306 | GNUNET_SET_destroy (cls); |
307 | return GNUNET_YES; | 307 | return GNUNET_YES; |
308 | } | 308 | } |
309 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | 309 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
310 | "iter: got element\n"); | 310 | "iter: got element\n"); |
311 | iter_count++; | 311 | iter_count++; |
312 | return GNUNET_YES; | 312 | return GNUNET_YES; |
313 | } | 313 | } |
314 | 314 | ||
315 | 315 | ||
316 | static void | 316 | static void |
317 | test_iter() | 317 | test_iter () |
318 | { | 318 | { |
319 | struct GNUNET_SET_Element element; | 319 | struct GNUNET_SET_Element element; |
320 | struct GNUNET_SET_Handle *iter_set; | 320 | struct GNUNET_SET_Handle *iter_set; |
321 | 321 | ||
322 | iter_count = 0; | 322 | iter_count = 0; |
323 | iter_set = GNUNET_SET_create(config, GNUNET_SET_OPERATION_UNION); | 323 | iter_set = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION); |
324 | element.element_type = 0; | 324 | element.element_type = 0; |
325 | element.data = "hello"; | 325 | element.data = "hello"; |
326 | element.size = strlen(element.data); | 326 | element.size = strlen (element.data); |
327 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); | 327 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); |
328 | element.data = "bar"; | 328 | element.data = "bar"; |
329 | element.size = strlen(element.data); | 329 | element.size = strlen (element.data); |
330 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); | 330 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); |
331 | element.data = "quux"; | 331 | element.data = "quux"; |
332 | element.size = strlen(element.data); | 332 | element.size = strlen (element.data); |
333 | GNUNET_SET_add_element(iter_set, &element, NULL, NULL); | 333 | GNUNET_SET_add_element (iter_set, &element, NULL, NULL); |
334 | 334 | ||
335 | GNUNET_SET_iterate(iter_set, | 335 | GNUNET_SET_iterate (iter_set, |
336 | &iter_cb, | 336 | &iter_cb, |
337 | iter_set); | 337 | iter_set); |
338 | } | 338 | } |
339 | 339 | ||
340 | 340 | ||
@@ -344,12 +344,12 @@ test_iter() | |||
344 | * @param cls closure | 344 | * @param cls closure |
345 | */ | 345 | */ |
346 | static void | 346 | static void |
347 | timeout_fail(void *cls) | 347 | timeout_fail (void *cls) |
348 | { | 348 | { |
349 | timeout_task = NULL; | 349 | timeout_task = NULL; |
350 | GNUNET_SCHEDULER_shutdown(); | 350 | GNUNET_SCHEDULER_shutdown (); |
351 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 351 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
352 | "test timed out\n"); | 352 | "test timed out\n"); |
353 | ret = 1; | 353 | ret = 1; |
354 | } | 354 | } |
355 | 355 | ||
@@ -360,38 +360,38 @@ timeout_fail(void *cls) | |||
360 | * @param cls closure | 360 | * @param cls closure |
361 | */ | 361 | */ |
362 | static void | 362 | static void |
363 | do_shutdown(void *cls) | 363 | do_shutdown (void *cls) |
364 | { | 364 | { |
365 | if (NULL != timeout_task) | 365 | if (NULL != timeout_task) |
366 | { | 366 | { |
367 | GNUNET_SCHEDULER_cancel(timeout_task); | 367 | GNUNET_SCHEDULER_cancel (timeout_task); |
368 | timeout_task = NULL; | 368 | timeout_task = NULL; |
369 | } | 369 | } |
370 | if (NULL != oh1) | 370 | if (NULL != oh1) |
371 | { | 371 | { |
372 | GNUNET_SET_operation_cancel(oh1); | 372 | GNUNET_SET_operation_cancel (oh1); |
373 | oh1 = NULL; | 373 | oh1 = NULL; |
374 | } | 374 | } |
375 | if (NULL != oh2) | 375 | if (NULL != oh2) |
376 | { | 376 | { |
377 | GNUNET_SET_operation_cancel(oh2); | 377 | GNUNET_SET_operation_cancel (oh2); |
378 | oh2 = NULL; | 378 | oh2 = NULL; |
379 | } | 379 | } |
380 | if (NULL != set1) | 380 | if (NULL != set1) |
381 | { | 381 | { |
382 | GNUNET_SET_destroy(set1); | 382 | GNUNET_SET_destroy (set1); |
383 | set1 = NULL; | 383 | set1 = NULL; |
384 | } | 384 | } |
385 | if (NULL != set2) | 385 | if (NULL != set2) |
386 | { | 386 | { |
387 | GNUNET_SET_destroy(set2); | 387 | GNUNET_SET_destroy (set2); |
388 | set2 = NULL; | 388 | set2 = NULL; |
389 | } | 389 | } |
390 | if (NULL != listen_handle) | 390 | if (NULL != listen_handle) |
391 | { | 391 | { |
392 | GNUNET_SET_listen_cancel(listen_handle); | 392 | GNUNET_SET_listen_cancel (listen_handle); |
393 | listen_handle = NULL; | 393 | listen_handle = NULL; |
394 | } | 394 | } |
395 | } | 395 | } |
396 | 396 | ||
397 | 397 | ||
@@ -404,51 +404,52 @@ do_shutdown(void *cls) | |||
404 | * @param peer identity of the peer that was created | 404 | * @param peer identity of the peer that was created |
405 | */ | 405 | */ |
406 | static void | 406 | static void |
407 | run(void *cls, | 407 | run (void *cls, |
408 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 408 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
409 | struct GNUNET_TESTING_Peer *peer) | 409 | struct GNUNET_TESTING_Peer *peer) |
410 | { | 410 | { |
411 | timeout_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5), | 411 | timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply ( |
412 | &timeout_fail, | 412 | GNUNET_TIME_UNIT_SECONDS, 5), |
413 | NULL); | 413 | &timeout_fail, |
414 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, | 414 | NULL); |
415 | NULL); | 415 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, |
416 | NULL); | ||
416 | config = cfg; | 417 | config = cfg; |
417 | GNUNET_TESTING_peer_get_identity(peer, | 418 | GNUNET_TESTING_peer_get_identity (peer, |
418 | &local_id); | 419 | &local_id); |
419 | 420 | ||
420 | if (0) | 421 | if (0) |
421 | test_iter(); | 422 | test_iter (); |
422 | 423 | ||
423 | set1 = GNUNET_SET_create(cfg, GNUNET_SET_OPERATION_UNION); | 424 | set1 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION); |
424 | set2 = GNUNET_SET_create(cfg, GNUNET_SET_OPERATION_UNION); | 425 | set2 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION); |
425 | GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &app_id); | 426 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id); |
426 | 427 | ||
427 | /* test the real set reconciliation */ | 428 | /* test the real set reconciliation */ |
428 | init_set1(); | 429 | init_set1 (); |
429 | } | 430 | } |
430 | 431 | ||
431 | 432 | ||
432 | int | 433 | int |
433 | main(int argc, char **argv) | 434 | main (int argc, char **argv) |
434 | { | 435 | { |
435 | empty = 1; | 436 | empty = 1; |
436 | if (0 != GNUNET_TESTING_peer_run("test_set_api", | 437 | if (0 != GNUNET_TESTING_peer_run ("test_set_api", |
437 | "test_set.conf", | 438 | "test_set.conf", |
438 | &run, NULL)) | 439 | &run, NULL)) |
439 | { | 440 | { |
440 | return 1; | 441 | return 1; |
441 | } | 442 | } |
442 | GNUNET_assert(0 == count_set1); | 443 | GNUNET_assert (0 == count_set1); |
443 | GNUNET_assert(0 == count_set2); | 444 | GNUNET_assert (0 == count_set2); |
444 | empty = 0; | 445 | empty = 0; |
445 | if (0 != GNUNET_TESTING_peer_run("test_set_api", | 446 | if (0 != GNUNET_TESTING_peer_run ("test_set_api", |
446 | "test_set.conf", | 447 | "test_set.conf", |
447 | &run, NULL)) | 448 | &run, NULL)) |
448 | { | 449 | { |
449 | return 1; | 450 | return 1; |
450 | } | 451 | } |
451 | GNUNET_break(2 == count_set1); | 452 | GNUNET_break (2 == count_set1); |
452 | GNUNET_break(1 == count_set2); | 453 | GNUNET_break (1 == count_set2); |
453 | return ret; | 454 | return ret; |
454 | } | 455 | } |