diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-07-17 10:50:45 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-07-17 10:50:45 +0200 |
commit | a7ccf828ae4f7e306ffe3e7efebc0e678615f6c5 (patch) | |
tree | 71489a2649bb3c9100fccc19d135d832d3cbea05 /src/fs | |
parent | 963c4fe2e94208a251b269e3a6918a71e8de1939 (diff) | |
download | gnunet-a7ccf828ae4f7e306ffe3e7efebc0e678615f6c5.tar.gz gnunet-a7ccf828ae4f7e306ffe3e7efebc0e678615f6c5.zip |
remove duplication MQ options, make conversation build
Diffstat (limited to 'src/fs')
-rw-r--r-- | src/fs/gnunet-service-fs_cadet_client.c | 243 |
1 files changed, 105 insertions, 138 deletions
diff --git a/src/fs/gnunet-service-fs_cadet_client.c b/src/fs/gnunet-service-fs_cadet_client.c index 9f654849d..81afe0411 100644 --- a/src/fs/gnunet-service-fs_cadet_client.c +++ b/src/fs/gnunet-service-fs_cadet_client.c | |||
@@ -41,7 +41,8 @@ | |||
41 | /** | 41 | /** |
42 | * After how long do we reset connections without replies? | 42 | * After how long do we reset connections without replies? |
43 | */ | 43 | */ |
44 | #define CLIENT_RETRY_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) | 44 | #define CLIENT_RETRY_TIMEOUT \ |
45 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) | ||
45 | 46 | ||
46 | 47 | ||
47 | /** | 48 | /** |
@@ -143,7 +144,6 @@ struct CadetHandle | |||
143 | * callback from the cadet API). | 144 | * callback from the cadet API). |
144 | */ | 145 | */ |
145 | struct GNUNET_SCHEDULER_Task *reset_task; | 146 | struct GNUNET_SCHEDULER_Task *reset_task; |
146 | |||
147 | }; | 147 | }; |
148 | 148 | ||
149 | 149 | ||
@@ -181,20 +181,15 @@ transmit_pending (void *cls); | |||
181 | * @return #GNUNET_YES (continue to iterate) | 181 | * @return #GNUNET_YES (continue to iterate) |
182 | */ | 182 | */ |
183 | static int | 183 | static int |
184 | move_to_pending (void *cls, | 184 | move_to_pending (void *cls, const struct GNUNET_HashCode *key, void *value) |
185 | const struct GNUNET_HashCode *key, | ||
186 | void *value) | ||
187 | { | 185 | { |
188 | struct CadetHandle *mh = cls; | 186 | struct CadetHandle *mh = cls; |
189 | struct GSF_CadetRequest *sr = value; | 187 | struct GSF_CadetRequest *sr = value; |
190 | 188 | ||
191 | GNUNET_assert (GNUNET_YES == | 189 | GNUNET_assert ( |
192 | GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map, | 190 | GNUNET_YES == |
193 | key, | 191 | GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map, key, value)); |
194 | value)); | 192 | GNUNET_CONTAINER_DLL_insert (mh->pending_head, mh->pending_tail, sr); |
195 | GNUNET_CONTAINER_DLL_insert (mh->pending_head, | ||
196 | mh->pending_tail, | ||
197 | sr); | ||
198 | sr->was_transmitted = GNUNET_NO; | 193 | sr->was_transmitted = GNUNET_NO; |
199 | return GNUNET_YES; | 194 | return GNUNET_YES; |
200 | } | 195 | } |
@@ -209,8 +204,7 @@ move_to_pending (void *cls, | |||
209 | * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing | 204 | * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing |
210 | */ | 205 | */ |
211 | static int | 206 | static int |
212 | check_reply (void *cls, | 207 | check_reply (void *cls, const struct CadetReplyMessage *srm) |
213 | const struct CadetReplyMessage *srm) | ||
214 | { | 208 | { |
215 | /* We check later... */ | 209 | /* We check later... */ |
216 | return GNUNET_OK; | 210 | return GNUNET_OK; |
@@ -237,8 +231,7 @@ reset_cadet_async (struct CadetHandle *mh) | |||
237 | { | 231 | { |
238 | if (NULL != mh->reset_task) | 232 | if (NULL != mh->reset_task) |
239 | GNUNET_SCHEDULER_cancel (mh->reset_task); | 233 | GNUNET_SCHEDULER_cancel (mh->reset_task); |
240 | mh->reset_task = GNUNET_SCHEDULER_add_now (&reset_cadet_task, | 234 | mh->reset_task = GNUNET_SCHEDULER_add_now (&reset_cadet_task, mh); |
241 | mh); | ||
242 | } | 235 | } |
243 | 236 | ||
244 | 237 | ||
@@ -285,18 +278,16 @@ struct HandleReplyClosure | |||
285 | * @return #GNUNET_YES (continue to iterate) | 278 | * @return #GNUNET_YES (continue to iterate) |
286 | */ | 279 | */ |
287 | static int | 280 | static int |
288 | process_reply (void *cls, | 281 | process_reply (void *cls, const struct GNUNET_HashCode *key, void *value) |
289 | const struct GNUNET_HashCode *key, | ||
290 | void *value) | ||
291 | { | 282 | { |
292 | struct HandleReplyClosure *hrc = cls; | 283 | struct HandleReplyClosure *hrc = cls; |
293 | struct GSF_CadetRequest *sr = value; | 284 | struct GSF_CadetRequest *sr = value; |
294 | 285 | ||
295 | sr->proc (sr->proc_cls, | 286 | sr->proc (sr->proc_cls, |
296 | hrc->type, | 287 | hrc->type, |
297 | hrc->expiration, | 288 | hrc->expiration, |
298 | hrc->data_size, | 289 | hrc->data_size, |
299 | hrc->data); | 290 | hrc->data); |
300 | sr->proc = NULL; | 291 | sr->proc = NULL; |
301 | GSF_cadet_query_cancel (sr); | 292 | GSF_cadet_query_cancel (sr); |
302 | hrc->found = GNUNET_YES; | 293 | hrc->found = GNUNET_YES; |
@@ -315,9 +306,7 @@ process_reply (void *cls, | |||
315 | * @return #GNUNET_YES (continue to iterate) | 306 | * @return #GNUNET_YES (continue to iterate) |
316 | */ | 307 | */ |
317 | static int | 308 | static int |
318 | free_waiting_entry (void *cls, | 309 | free_waiting_entry (void *cls, const struct GNUNET_HashCode *key, void *value) |
319 | const struct GNUNET_HashCode *key, | ||
320 | void *value) | ||
321 | { | 310 | { |
322 | struct GSF_CadetRequest *sr = value; | 311 | struct GSF_CadetRequest *sr = value; |
323 | 312 | ||
@@ -334,8 +323,7 @@ free_waiting_entry (void *cls, | |||
334 | * @param srm the actual message | 323 | * @param srm the actual message |
335 | */ | 324 | */ |
336 | static void | 325 | static void |
337 | handle_reply (void *cls, | 326 | handle_reply (void *cls, const struct CadetReplyMessage *srm) |
338 | const struct CadetReplyMessage *srm) | ||
339 | { | 327 | { |
340 | struct CadetHandle *mh = cls; | 328 | struct CadetHandle *mh = cls; |
341 | struct HandleReplyClosure hrc; | 329 | struct HandleReplyClosure hrc; |
@@ -346,43 +334,43 @@ handle_reply (void *cls, | |||
346 | msize = ntohs (srm->header.size) - sizeof (struct CadetReplyMessage); | 334 | msize = ntohs (srm->header.size) - sizeof (struct CadetReplyMessage); |
347 | type = (enum GNUNET_BLOCK_Type) ntohl (srm->type); | 335 | type = (enum GNUNET_BLOCK_Type) ntohl (srm->type); |
348 | if (GNUNET_YES != | 336 | if (GNUNET_YES != |
349 | GNUNET_BLOCK_get_key (GSF_block_ctx, | 337 | GNUNET_BLOCK_get_key (GSF_block_ctx, type, &srm[1], msize, &query)) |
350 | type, | ||
351 | &srm[1], | ||
352 | msize, | ||
353 | &query)) | ||
354 | { | 338 | { |
355 | GNUNET_break_op (0); | 339 | GNUNET_break_op (0); |
356 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 340 | GNUNET_log ( |
357 | "Received bogus reply of type %u with %u bytes via cadet from peer %s\n", | 341 | GNUNET_ERROR_TYPE_WARNING, |
358 | type, | 342 | "Received bogus reply of type %u with %u bytes via cadet from peer %s\n", |
359 | msize, | 343 | type, |
360 | GNUNET_i2s (&mh->target)); | 344 | msize, |
345 | GNUNET_i2s (&mh->target)); | ||
361 | reset_cadet_async (mh); | 346 | reset_cadet_async (mh); |
362 | return; | 347 | return; |
363 | } | 348 | } |
364 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 349 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
365 | "Received reply `%s' via cadet from peer %s\n", | 350 | "Received reply `%s' via cadet from peer %s\n", |
366 | GNUNET_h2s (&query), | 351 | GNUNET_h2s (&query), |
367 | GNUNET_i2s (&mh->target)); | 352 | GNUNET_i2s (&mh->target)); |
368 | GNUNET_CADET_receive_done (mh->channel); | 353 | GNUNET_CADET_receive_done (mh->channel); |
369 | GNUNET_STATISTICS_update (GSF_stats, | 354 | GNUNET_STATISTICS_update (GSF_stats, |
370 | gettext_noop ("# replies received via cadet"), 1, | 355 | gettext_noop ("# replies received via cadet"), |
371 | GNUNET_NO); | 356 | 1, |
357 | GNUNET_NO); | ||
372 | hrc.data = &srm[1]; | 358 | hrc.data = &srm[1]; |
373 | hrc.data_size = msize; | 359 | hrc.data_size = msize; |
374 | hrc.expiration = GNUNET_TIME_absolute_ntoh (srm->expiration); | 360 | hrc.expiration = GNUNET_TIME_absolute_ntoh (srm->expiration); |
375 | hrc.type = type; | 361 | hrc.type = type; |
376 | hrc.found = GNUNET_NO; | 362 | hrc.found = GNUNET_NO; |
377 | GNUNET_CONTAINER_multihashmap_get_multiple (mh->waiting_map, | 363 | GNUNET_CONTAINER_multihashmap_get_multiple (mh->waiting_map, |
378 | &query, | 364 | &query, |
379 | &process_reply, | 365 | &process_reply, |
380 | &hrc); | 366 | &hrc); |
381 | if (GNUNET_NO == hrc.found) | 367 | if (GNUNET_NO == hrc.found) |
382 | { | 368 | { |
383 | GNUNET_STATISTICS_update (GSF_stats, | 369 | GNUNET_STATISTICS_update (GSF_stats, |
384 | gettext_noop ("# replies received via cadet dropped"), 1, | 370 | gettext_noop ( |
385 | GNUNET_NO); | 371 | "# replies received via cadet dropped"), |
372 | 1, | ||
373 | GNUNET_NO); | ||
386 | } | 374 | } |
387 | } | 375 | } |
388 | 376 | ||
@@ -395,8 +383,7 @@ handle_reply (void *cls, | |||
395 | * @param channel channel of the disconnecting client | 383 | * @param channel channel of the disconnecting client |
396 | */ | 384 | */ |
397 | static void | 385 | static void |
398 | disconnect_cb (void *cls, | 386 | disconnect_cb (void *cls, const struct GNUNET_CADET_Channel *channel) |
399 | const struct GNUNET_CADET_Channel *channel) | ||
400 | { | 387 | { |
401 | struct CadetHandle *mh = cls; | 388 | struct CadetHandle *mh = cls; |
402 | struct GSF_CadetRequest *sr; | 389 | struct GSF_CadetRequest *sr; |
@@ -411,19 +398,17 @@ disconnect_cb (void *cls, | |||
411 | callback from `free_waiting_entry()` happens to re-issue | 398 | callback from `free_waiting_entry()` happens to re-issue |
412 | the request, we don't immediately have it back in the | 399 | the request, we don't immediately have it back in the |
413 | `waiting_map`. */ | 400 | `waiting_map`. */ |
414 | GNUNET_assert (GNUNET_OK == | 401 | GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (cadet_map, |
415 | GNUNET_CONTAINER_multipeermap_remove (cadet_map, | 402 | &mh->target, |
416 | &mh->target, | 403 | mh)); |
417 | mh)); | ||
418 | GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map, | 404 | GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map, |
419 | &free_waiting_entry, | 405 | &free_waiting_entry, |
420 | mh); | 406 | mh); |
421 | if (NULL != mh->timeout_task) | 407 | if (NULL != mh->timeout_task) |
422 | GNUNET_SCHEDULER_cancel (mh->timeout_task); | 408 | GNUNET_SCHEDULER_cancel (mh->timeout_task); |
423 | if (NULL != mh->reset_task) | 409 | if (NULL != mh->reset_task) |
424 | GNUNET_SCHEDULER_cancel (mh->reset_task); | 410 | GNUNET_SCHEDULER_cancel (mh->reset_task); |
425 | GNUNET_assert (0 == | 411 | GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (mh->waiting_map)); |
426 | GNUNET_CONTAINER_multihashmap_size (mh->waiting_map)); | ||
427 | GNUNET_CONTAINER_multihashmap_destroy (mh->waiting_map); | 412 | GNUNET_CONTAINER_multihashmap_destroy (mh->waiting_map); |
428 | GNUNET_free (mh); | 413 | GNUNET_free (mh); |
429 | } | 414 | } |
@@ -467,24 +452,21 @@ static void | |||
467 | reset_cadet (struct CadetHandle *mh) | 452 | reset_cadet (struct CadetHandle *mh) |
468 | { | 453 | { |
469 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 454 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
470 | "Resetting cadet channel to %s\n", | 455 | "Resetting cadet channel to %s\n", |
471 | GNUNET_i2s (&mh->target)); | 456 | GNUNET_i2s (&mh->target)); |
472 | if (NULL != mh->channel) | 457 | if (NULL != mh->channel) |
473 | { | 458 | { |
474 | GNUNET_CADET_channel_destroy (mh->channel); | 459 | GNUNET_CADET_channel_destroy (mh->channel); |
475 | mh->channel = NULL; | 460 | mh->channel = NULL; |
476 | } | 461 | } |
477 | GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map, | 462 | GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map, &move_to_pending, mh); |
478 | &move_to_pending, | ||
479 | mh); | ||
480 | { | 463 | { |
481 | struct GNUNET_MQ_MessageHandler handlers[] = { | 464 | struct GNUNET_MQ_MessageHandler handlers[] = |
482 | GNUNET_MQ_hd_var_size (reply, | 465 | {GNUNET_MQ_hd_var_size (reply, |
483 | GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, | 466 | GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, |
484 | struct CadetReplyMessage, | 467 | struct CadetReplyMessage, |
485 | mh), | 468 | mh), |
486 | GNUNET_MQ_handler_end () | 469 | GNUNET_MQ_handler_end ()}; |
487 | }; | ||
488 | struct GNUNET_HashCode port; | 470 | struct GNUNET_HashCode port; |
489 | 471 | ||
490 | GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, | 472 | GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, |
@@ -514,8 +496,8 @@ cadet_timeout (void *cls) | |||
514 | struct GNUNET_CADET_Channel *tun; | 496 | struct GNUNET_CADET_Channel *tun; |
515 | 497 | ||
516 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 498 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
517 | "Timeout on cadet channel to %s\n", | 499 | "Timeout on cadet channel to %s\n", |
518 | GNUNET_i2s (&mh->target)); | 500 | GNUNET_i2s (&mh->target)); |
519 | mh->timeout_task = NULL; | 501 | mh->timeout_task = NULL; |
520 | tun = mh->channel; | 502 | tun = mh->channel; |
521 | mh->channel = NULL; | 503 | mh->channel = NULL; |
@@ -553,33 +535,28 @@ transmit_pending (void *cls) | |||
553 | struct GNUNET_MQ_Envelope *env; | 535 | struct GNUNET_MQ_Envelope *env; |
554 | struct CadetQueryMessage *sqm; | 536 | struct CadetQueryMessage *sqm; |
555 | 537 | ||
556 | if ( (0 != GNUNET_MQ_get_length (mq)) || | 538 | if ((0 != GNUNET_MQ_get_length (mq)) || (NULL == (sr = mh->pending_head))) |
557 | (NULL == (sr = mh->pending_head)) ) | ||
558 | return; | 539 | return; |
559 | GNUNET_CONTAINER_DLL_remove (mh->pending_head, | 540 | GNUNET_CONTAINER_DLL_remove (mh->pending_head, mh->pending_tail, sr); |
560 | mh->pending_tail, | 541 | GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put ( |
561 | sr); | 542 | mh->waiting_map, |
562 | GNUNET_assert (GNUNET_OK == | 543 | &sr->query, |
563 | GNUNET_CONTAINER_multihashmap_put (mh->waiting_map, | 544 | sr, |
564 | &sr->query, | 545 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); |
565 | sr, | ||
566 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)); | ||
567 | sr->was_transmitted = GNUNET_YES; | 546 | sr->was_transmitted = GNUNET_YES; |
568 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 547 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
569 | "Sending query for %s via cadet to %s\n", | 548 | "Sending query for %s via cadet to %s\n", |
570 | GNUNET_h2s (&sr->query), | 549 | GNUNET_h2s (&sr->query), |
571 | GNUNET_i2s (&mh->target)); | 550 | GNUNET_i2s (&mh->target)); |
572 | env = GNUNET_MQ_msg (sqm, | 551 | env = GNUNET_MQ_msg (sqm, GNUNET_MESSAGE_TYPE_FS_CADET_QUERY); |
573 | GNUNET_MESSAGE_TYPE_FS_CADET_QUERY); | 552 | GNUNET_MQ_env_set_options (env, |
574 | GNUNET_MQ_env_set_options(env, | 553 | GNUNET_MQ_PREF_GOODPUT | |
575 | GNUNET_MQ_PREF_RELIABLE); | 554 | GNUNET_MQ_PREF_CORK_ALLOWED | |
555 | GNUNET_MQ_PREF_OUT_OF_ORDER); | ||
576 | sqm->type = htonl (sr->type); | 556 | sqm->type = htonl (sr->type); |
577 | sqm->query = sr->query; | 557 | sqm->query = sr->query; |
578 | GNUNET_MQ_notify_sent (env, | 558 | GNUNET_MQ_notify_sent (env, &transmit_pending, mh); |
579 | &transmit_pending, | 559 | GNUNET_MQ_send (mq, env); |
580 | mh); | ||
581 | GNUNET_MQ_send (mq, | ||
582 | env); | ||
583 | } | 560 | } |
584 | 561 | ||
585 | 562 | ||
@@ -593,8 +570,7 @@ get_cadet (const struct GNUNET_PeerIdentity *target) | |||
593 | { | 570 | { |
594 | struct CadetHandle *mh; | 571 | struct CadetHandle *mh; |
595 | 572 | ||
596 | mh = GNUNET_CONTAINER_multipeermap_get (cadet_map, | 573 | mh = GNUNET_CONTAINER_multipeermap_get (cadet_map, target); |
597 | target); | ||
598 | if (NULL != mh) | 574 | if (NULL != mh) |
599 | { | 575 | { |
600 | if (NULL != mh->timeout_task) | 576 | if (NULL != mh->timeout_task) |
@@ -605,27 +581,26 @@ get_cadet (const struct GNUNET_PeerIdentity *target) | |||
605 | return mh; | 581 | return mh; |
606 | } | 582 | } |
607 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 583 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
608 | "Creating cadet channel to %s\n", | 584 | "Creating cadet channel to %s\n", |
609 | GNUNET_i2s (target)); | 585 | GNUNET_i2s (target)); |
610 | mh = GNUNET_new (struct CadetHandle); | 586 | mh = GNUNET_new (struct CadetHandle); |
611 | mh->reset_task = GNUNET_SCHEDULER_add_delayed (CLIENT_RETRY_TIMEOUT, | 587 | mh->reset_task = |
612 | &reset_cadet_task, | 588 | GNUNET_SCHEDULER_add_delayed (CLIENT_RETRY_TIMEOUT, &reset_cadet_task, mh); |
613 | mh); | ||
614 | mh->waiting_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_YES); | 589 | mh->waiting_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_YES); |
615 | mh->target = *target; | 590 | mh->target = *target; |
616 | GNUNET_assert (GNUNET_OK == | 591 | GNUNET_assert (GNUNET_OK == |
617 | GNUNET_CONTAINER_multipeermap_put (cadet_map, | 592 | GNUNET_CONTAINER_multipeermap_put ( |
618 | &mh->target, | 593 | cadet_map, |
619 | mh, | 594 | &mh->target, |
620 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | 595 | mh, |
596 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)); | ||
621 | { | 597 | { |
622 | struct GNUNET_MQ_MessageHandler handlers[] = { | 598 | struct GNUNET_MQ_MessageHandler handlers[] = |
623 | GNUNET_MQ_hd_var_size (reply, | 599 | {GNUNET_MQ_hd_var_size (reply, |
624 | GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, | 600 | GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, |
625 | struct CadetReplyMessage, | 601 | struct CadetReplyMessage, |
626 | mh), | 602 | mh), |
627 | GNUNET_MQ_handler_end () | 603 | GNUNET_MQ_handler_end ()}; |
628 | }; | ||
629 | struct GNUNET_HashCode port; | 604 | struct GNUNET_HashCode port; |
630 | 605 | ||
631 | GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, | 606 | GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, |
@@ -664,9 +639,9 @@ GSF_cadet_query (const struct GNUNET_PeerIdentity *target, | |||
664 | struct GSF_CadetRequest *sr; | 639 | struct GSF_CadetRequest *sr; |
665 | 640 | ||
666 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 641 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
667 | "Preparing to send query for %s via cadet to %s\n", | 642 | "Preparing to send query for %s via cadet to %s\n", |
668 | GNUNET_h2s (query), | 643 | GNUNET_h2s (query), |
669 | GNUNET_i2s (target)); | 644 | GNUNET_i2s (target)); |
670 | mh = get_cadet (target); | 645 | mh = get_cadet (target); |
671 | sr = GNUNET_new (struct GSF_CadetRequest); | 646 | sr = GNUNET_new (struct GSF_CadetRequest); |
672 | sr->mh = mh; | 647 | sr->mh = mh; |
@@ -674,9 +649,7 @@ GSF_cadet_query (const struct GNUNET_PeerIdentity *target, | |||
674 | sr->proc_cls = proc_cls; | 649 | sr->proc_cls = proc_cls; |
675 | sr->type = type; | 650 | sr->type = type; |
676 | sr->query = *query; | 651 | sr->query = *query; |
677 | GNUNET_CONTAINER_DLL_insert (mh->pending_head, | 652 | GNUNET_CONTAINER_DLL_insert (mh->pending_head, mh->pending_tail, sr); |
678 | mh->pending_tail, | ||
679 | sr); | ||
680 | transmit_pending (mh); | 653 | transmit_pending (mh); |
681 | return sr; | 654 | return sr; |
682 | } | 655 | } |
@@ -699,29 +672,24 @@ GSF_cadet_query_cancel (struct GSF_CadetRequest *sr) | |||
699 | if (NULL != p) | 672 | if (NULL != p) |
700 | { | 673 | { |
701 | /* signal failure / cancellation to callback */ | 674 | /* signal failure / cancellation to callback */ |
702 | p (sr->proc_cls, GNUNET_BLOCK_TYPE_ANY, | 675 | p (sr->proc_cls, GNUNET_BLOCK_TYPE_ANY, GNUNET_TIME_UNIT_ZERO_ABS, 0, NULL); |
703 | GNUNET_TIME_UNIT_ZERO_ABS, | ||
704 | 0, NULL); | ||
705 | } | 676 | } |
706 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 677 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
707 | "Cancelled query for %s via cadet to %s\n", | 678 | "Cancelled query for %s via cadet to %s\n", |
708 | GNUNET_h2s (&sr->query), | 679 | GNUNET_h2s (&sr->query), |
709 | GNUNET_i2s (&sr->mh->target)); | 680 | GNUNET_i2s (&sr->mh->target)); |
710 | if (GNUNET_YES == sr->was_transmitted) | 681 | if (GNUNET_YES == sr->was_transmitted) |
711 | GNUNET_assert (GNUNET_OK == | 682 | GNUNET_assert ( |
712 | GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map, | 683 | GNUNET_OK == |
713 | &sr->query, | 684 | GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map, &sr->query, sr)); |
714 | sr)); | ||
715 | else | 685 | else |
716 | GNUNET_CONTAINER_DLL_remove (mh->pending_head, | 686 | GNUNET_CONTAINER_DLL_remove (mh->pending_head, mh->pending_tail, sr); |
717 | mh->pending_tail, | ||
718 | sr); | ||
719 | GNUNET_free (sr); | 687 | GNUNET_free (sr); |
720 | if ( (0 == GNUNET_CONTAINER_multihashmap_size (mh->waiting_map)) && | 688 | if ((0 == GNUNET_CONTAINER_multihashmap_size (mh->waiting_map)) && |
721 | (NULL == mh->pending_head) ) | 689 | (NULL == mh->pending_head)) |
722 | mh->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, | 690 | mh->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, |
723 | &cadet_timeout, | 691 | &cadet_timeout, |
724 | mh); | 692 | mh); |
725 | } | 693 | } |
726 | 694 | ||
727 | 695 | ||
@@ -741,8 +709,8 @@ GSF_cadet_release_clients (void *cls, | |||
741 | struct CadetHandle *mh = value; | 709 | struct CadetHandle *mh = value; |
742 | 710 | ||
743 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 711 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
744 | "Timeout on cadet channel to %s\n", | 712 | "Timeout on cadet channel to %s\n", |
745 | GNUNET_i2s (&mh->target)); | 713 | GNUNET_i2s (&mh->target)); |
746 | if (NULL != mh->channel) | 714 | if (NULL != mh->channel) |
747 | { | 715 | { |
748 | struct GNUNET_CADET_Channel *channel = mh->channel; | 716 | struct GNUNET_CADET_Channel *channel = mh->channel; |
@@ -759,5 +727,4 @@ GSF_cadet_release_clients (void *cls, | |||
759 | } | 727 | } |
760 | 728 | ||
761 | 729 | ||
762 | |||
763 | /* end of gnunet-service-fs_cadet_client.c */ | 730 | /* end of gnunet-service-fs_cadet_client.c */ |