aboutsummaryrefslogtreecommitdiff
path: root/src/fs/gnunet-service-fs_cadet_client.c
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2019-07-17 10:50:45 +0200
committerChristian Grothoff <christian@grothoff.org>2019-07-17 10:50:45 +0200
commita7ccf828ae4f7e306ffe3e7efebc0e678615f6c5 (patch)
tree71489a2649bb3c9100fccc19d135d832d3cbea05 /src/fs/gnunet-service-fs_cadet_client.c
parent963c4fe2e94208a251b269e3a6918a71e8de1939 (diff)
downloadgnunet-a7ccf828ae4f7e306ffe3e7efebc0e678615f6c5.tar.gz
gnunet-a7ccf828ae4f7e306ffe3e7efebc0e678615f6c5.zip
remove duplication MQ options, make conversation build
Diffstat (limited to 'src/fs/gnunet-service-fs_cadet_client.c')
-rw-r--r--src/fs/gnunet-service-fs_cadet_client.c243
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 */
183static int 183static int
184move_to_pending (void *cls, 184move_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 */
211static int 206static int
212check_reply (void *cls, 207check_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 */
287static int 280static int
288process_reply (void *cls, 281process_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 */
317static int 308static int
318free_waiting_entry (void *cls, 309free_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 */
336static void 325static void
337handle_reply (void *cls, 326handle_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 */
397static void 385static void
398disconnect_cb (void *cls, 386disconnect_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
467reset_cadet (struct CadetHandle *mh) 452reset_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 */