diff options
author | Christian Grothoff <christian@grothoff.org> | 2012-09-20 08:20:58 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2012-09-20 08:20:58 +0000 |
commit | f1be2c0c8410b0829171990f85ffb4d107216ffb (patch) | |
tree | b982737a5a6fefd40f43e412004ee3bf3101944e /src | |
parent | f7bddd17b9b5f2244b4b6f5c82059961f0fa37ed (diff) | |
download | gnunet-f1be2c0c8410b0829171990f85ffb4d107216ffb.tar.gz gnunet-f1be2c0c8410b0829171990f85ffb4d107216ffb.zip |
-code review
Diffstat (limited to 'src')
-rw-r--r-- | src/gns/gns_api.c | 316 |
1 files changed, 177 insertions, 139 deletions
diff --git a/src/gns/gns_api.c b/src/gns/gns_api.c index 427e3e375..9ef98b805 100644 --- a/src/gns/gns_api.c +++ b/src/gns/gns_api.c | |||
@@ -160,9 +160,11 @@ struct PendingMessage | |||
160 | size_t size; | 160 | size_t size; |
161 | 161 | ||
162 | /** | 162 | /** |
163 | * This message has been transmitted | 163 | * This message has been transmitted. GNUNET_NO if the message is |
164 | * in the "pending" DLL, GNUNET_YES if it has been transmitted to | ||
165 | * the service via the current client connection. | ||
164 | */ | 166 | */ |
165 | unsigned int transmitted; | 167 | int transmitted; |
166 | 168 | ||
167 | }; | 169 | }; |
168 | 170 | ||
@@ -292,9 +294,44 @@ reconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
292 | static void | 294 | static void |
293 | force_reconnect (struct GNUNET_GNS_Handle *h) | 295 | force_reconnect (struct GNUNET_GNS_Handle *h) |
294 | { | 296 | { |
297 | struct GNUNET_GNS_ShortenRequest *st; | ||
298 | struct GNUNET_GNS_LookupRequest *lh; | ||
299 | struct GNUNET_GNS_GetAuthRequest *ga; | ||
300 | struct PendingMessage *p; | ||
301 | |||
295 | GNUNET_CLIENT_disconnect (h->client); | 302 | GNUNET_CLIENT_disconnect (h->client); |
296 | h->client = NULL; | 303 | h->client = NULL; |
297 | h->in_receive = GNUNET_NO; | 304 | h->in_receive = GNUNET_NO; |
305 | for (st = h->shorten_head; NULL != st; st = st->next) | ||
306 | { | ||
307 | p = (struct PendingMessage*) &st[1]; | ||
308 | if (GNUNET_NO == p->transmitted) | ||
309 | continue; | ||
310 | p->transmitted = GNUNET_NO; | ||
311 | GNUNET_CONTAINER_DLL_insert (h->pending_head, | ||
312 | h->pending_tail, | ||
313 | p); | ||
314 | } | ||
315 | for (lh = h->lookup_head; NULL != lh; lh = lh->next) | ||
316 | { | ||
317 | p = (struct PendingMessage*) &lh[1]; | ||
318 | if (GNUNET_NO == p->transmitted) | ||
319 | continue; | ||
320 | p->transmitted = GNUNET_NO; | ||
321 | GNUNET_CONTAINER_DLL_insert (h->pending_head, | ||
322 | h->pending_tail, | ||
323 | p); | ||
324 | } | ||
325 | for (ga = h->get_auth_head; NULL != ga; ga = ga->next) | ||
326 | { | ||
327 | p = (struct PendingMessage*) &ga[1]; | ||
328 | if (GNUNET_NO == p->transmitted) | ||
329 | continue; | ||
330 | p->transmitted = GNUNET_NO; | ||
331 | GNUNET_CONTAINER_DLL_insert (h->pending_head, | ||
332 | h->pending_tail, | ||
333 | p); | ||
334 | } | ||
298 | /* FIXME: 1s too long, exponential-backoff, starting at 1ms! (max = 1s might be OK) */ | 335 | /* FIXME: 1s too long, exponential-backoff, starting at 1ms! (max = 1s might be OK) */ |
299 | h->reconnect_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, | 336 | h->reconnect_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, |
300 | &reconnect_task, | 337 | &reconnect_task, |
@@ -362,40 +399,43 @@ process_pending_messages (struct GNUNET_GNS_Handle *handle) | |||
362 | static size_t | 399 | static size_t |
363 | transmit_pending (void *cls, size_t size, void *buf) | 400 | transmit_pending (void *cls, size_t size, void *buf) |
364 | { | 401 | { |
365 | struct GNUNET_GNS_Handle *handle = cls; | 402 | struct GNUNET_GNS_Handle *h = cls; |
366 | char *cbuf = buf; | 403 | char *cbuf = buf; |
367 | struct PendingMessage *p; | 404 | struct PendingMessage *p; |
368 | size_t tsize; | 405 | size_t tsize; |
369 | 406 | ||
370 | handle->th = NULL; | 407 | h->th = NULL; |
371 | if ((0 == size) || (NULL == buf)) | 408 | if ((0 == size) || (NULL == buf)) |
372 | { | 409 | { |
373 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 410 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
374 | "Transmission to GNS service failed!\n"); | 411 | "Transmission to GNS service failed!\n"); |
375 | force_reconnect(handle); | 412 | force_reconnect (h); |
376 | return 0; | 413 | return 0; |
377 | } | 414 | } |
378 | if (NULL == (p = handle->pending_head)) | 415 | if (NULL == (p = h->pending_head)) |
379 | return 0; | 416 | return 0; |
380 | 417 | ||
381 | tsize = 0; | 418 | tsize = 0; |
382 | while ((NULL != (p = handle->pending_head)) && (p->size <= size)) | 419 | while ((NULL != (p = h->pending_head)) && (p->size <= size)) |
383 | { | 420 | { |
384 | memcpy (&cbuf[tsize], &p[1], p->size); | 421 | memcpy (&cbuf[tsize], &p[1], p->size); |
385 | tsize += p->size; | 422 | tsize += p->size; |
386 | size -= p->size; | 423 | size -= p->size; |
387 | p->transmitted = GNUNET_YES; | 424 | p->transmitted = GNUNET_YES; |
388 | if (GNUNET_YES != handle->in_receive) | 425 | GNUNET_CONTAINER_DLL_remove (h->pending_head, |
426 | h->pending_tail, | ||
427 | p); | ||
428 | if (GNUNET_YES != h->in_receive) | ||
389 | { | 429 | { |
390 | GNUNET_CLIENT_receive (handle->client, &process_message, handle, | 430 | GNUNET_CLIENT_receive (h->client, &process_message, h, |
391 | GNUNET_TIME_UNIT_FOREVER_REL); | 431 | GNUNET_TIME_UNIT_FOREVER_REL); |
392 | handle->in_receive = GNUNET_YES; | 432 | h->in_receive = GNUNET_YES; |
393 | } | 433 | } |
394 | } | 434 | } |
395 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 435 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
396 | "Sending %u bytes\n", | 436 | "Sending %u bytes\n", |
397 | (unsigned int) tsize); | 437 | (unsigned int) tsize); |
398 | process_pending_messages (handle); | 438 | process_pending_messages (h); |
399 | return tsize; | 439 | return tsize; |
400 | } | 440 | } |
401 | 441 | ||
@@ -415,30 +455,31 @@ process_shorten_reply (struct GNUNET_GNS_ShortenRequest *qe, | |||
415 | struct PendingMessage *p = (struct PendingMessage *)&qe[1]; | 455 | struct PendingMessage *p = (struct PendingMessage *)&qe[1]; |
416 | const char *short_name; | 456 | const char *short_name; |
417 | size_t mlen; | 457 | size_t mlen; |
418 | |||
419 | 458 | ||
459 | if (GNUNET_YES != p->transmitted) | ||
460 | { | ||
461 | /* service send reply to query we never managed to send!? */ | ||
462 | GNUNET_break (0); | ||
463 | force_reconnect (h); | ||
464 | return; | ||
465 | } | ||
420 | mlen = ntohs (msg->header.size); | 466 | mlen = ntohs (msg->header.size); |
421 | if (ntohs (msg->header.size) == sizeof (struct GNUNET_GNS_ClientShortenResultMessage)) | 467 | if (ntohs (msg->header.size) == sizeof (struct GNUNET_GNS_ClientShortenResultMessage)) |
422 | { | 468 | { |
423 | /* service reports resolution failed */ | 469 | /* service reports resolution failed */ |
424 | short_name = NULL; | 470 | short_name = NULL; |
425 | } | 471 | } |
426 | else | 472 | else |
473 | { | ||
474 | short_name = (const char *) &msg[1]; | ||
475 | if ('\0' != short_name[mlen - sizeof (struct GNUNET_GNS_ClientShortenResultMessage) - 1]) | ||
427 | { | 476 | { |
428 | short_name = (const char *) &msg[1]; | 477 | GNUNET_break (0); |
429 | if ('\0' != short_name[mlen - sizeof (struct GNUNET_GNS_ClientShortenResultMessage) - 1]) | 478 | force_reconnect (h); |
430 | { | 479 | return; |
431 | GNUNET_break (0); | 480 | } |
432 | // FIXME: reconnect and queue management logic is broken... | 481 | } |
433 | p->transmitted = GNUNET_NO; | ||
434 | force_reconnect (h); | ||
435 | return; | ||
436 | } | ||
437 | } | ||
438 | GNUNET_CONTAINER_DLL_remove (h->shorten_head, h->shorten_tail, qe); | 482 | GNUNET_CONTAINER_DLL_remove (h->shorten_head, h->shorten_tail, qe); |
439 | GNUNET_CONTAINER_DLL_remove (h->pending_head, | ||
440 | h->pending_tail, | ||
441 | p); | ||
442 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 483 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
443 | "Received shortened reply `%s' from GNS service\n", | 484 | "Received shortened reply `%s' from GNS service\n", |
444 | short_name); | 485 | short_name); |
@@ -463,6 +504,13 @@ process_get_auth_reply (struct GNUNET_GNS_GetAuthRequest *qe, | |||
463 | const char *auth_name; | 504 | const char *auth_name; |
464 | size_t mlen; | 505 | size_t mlen; |
465 | 506 | ||
507 | if (GNUNET_YES != p->transmitted) | ||
508 | { | ||
509 | /* service send reply to query we never managed to send!? */ | ||
510 | GNUNET_break (0); | ||
511 | force_reconnect (h); | ||
512 | return; | ||
513 | } | ||
466 | mlen = ntohs (msg->header.size); | 514 | mlen = ntohs (msg->header.size); |
467 | if (mlen == sizeof (struct GNUNET_GNS_ClientGetAuthResultMessage)) | 515 | if (mlen == sizeof (struct GNUNET_GNS_ClientGetAuthResultMessage)) |
468 | { | 516 | { |
@@ -470,20 +518,15 @@ process_get_auth_reply (struct GNUNET_GNS_GetAuthRequest *qe, | |||
470 | } | 518 | } |
471 | else | 519 | else |
472 | { | 520 | { |
473 | auth_name = (char*)&msg[1]; | 521 | auth_name = (const char*) &msg[1]; |
474 | if ('\0' != auth_name[mlen - sizeof (struct GNUNET_GNS_ClientGetAuthResultMessage) - 1]) | 522 | if ('\0' != auth_name[mlen - sizeof (struct GNUNET_GNS_ClientGetAuthResultMessage) - 1]) |
475 | { | 523 | { |
476 | GNUNET_break (0); | 524 | GNUNET_break (0); |
477 | p->transmitted = GNUNET_NO; | ||
478 | force_reconnect (h); | 525 | force_reconnect (h); |
479 | return; | 526 | return; |
480 | } | 527 | } |
481 | } | 528 | } |
482 | |||
483 | GNUNET_CONTAINER_DLL_remove (h->get_auth_head, h->get_auth_tail, qe); | 529 | GNUNET_CONTAINER_DLL_remove (h->get_auth_head, h->get_auth_tail, qe); |
484 | GNUNET_CONTAINER_DLL_remove (h->pending_head, | ||
485 | h->pending_tail, | ||
486 | p); | ||
487 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 530 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
488 | "Received GET_AUTH reply `%s' from GNS service\n", | 531 | "Received GET_AUTH reply `%s' from GNS service\n", |
489 | auth_name); | 532 | auth_name); |
@@ -503,15 +546,22 @@ process_lookup_reply (struct GNUNET_GNS_LookupRequest *qe, | |||
503 | const struct GNUNET_GNS_ClientLookupResultMessage *msg) | 546 | const struct GNUNET_GNS_ClientLookupResultMessage *msg) |
504 | { | 547 | { |
505 | struct GNUNET_GNS_Handle *h = qe->gns_handle; | 548 | struct GNUNET_GNS_Handle *h = qe->gns_handle; |
506 | struct PendingMessage *p = (struct PendingMessage *)&qe[1]; | 549 | struct PendingMessage *p = (struct PendingMessage *) &qe[1]; |
507 | int rd_count = ntohl(msg->rd_count); | 550 | uint32_t rd_count = ntohl (msg->rd_count); |
508 | struct GNUNET_NAMESTORE_RecordData rd[rd_count]; | 551 | struct GNUNET_NAMESTORE_RecordData rd[rd_count]; |
509 | size_t mlen; | 552 | size_t mlen; |
510 | 553 | ||
554 | if (GNUNET_YES != p->transmitted) | ||
555 | { | ||
556 | /* service send reply to query we never managed to send!? */ | ||
557 | GNUNET_break (0); | ||
558 | force_reconnect (h); | ||
559 | return; | ||
560 | } | ||
511 | mlen = ntohs (msg->header.size); | 561 | mlen = ntohs (msg->header.size); |
512 | mlen -= sizeof (struct GNUNET_GNS_ClientLookupResultMessage); | 562 | mlen -= sizeof (struct GNUNET_GNS_ClientLookupResultMessage); |
513 | if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (mlen, | 563 | if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (mlen, |
514 | (char*)&msg[1], | 564 | (const char*) &msg[1], |
515 | rd_count, | 565 | rd_count, |
516 | rd)) | 566 | rd)) |
517 | { | 567 | { |
@@ -520,20 +570,17 @@ process_lookup_reply (struct GNUNET_GNS_LookupRequest *qe, | |||
520 | qe->lookup_proc (qe->proc_cls, 0, NULL); | 570 | qe->lookup_proc (qe->proc_cls, 0, NULL); |
521 | } | 571 | } |
522 | else | 572 | else |
523 | { | 573 | { |
524 | |||
525 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 574 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
526 | "Received lookup reply from GNS service (count=%u)\n", | 575 | "Received lookup reply from GNS service (%u records)\n", |
527 | ntohl (msg->rd_count)); | 576 | (unsigned int) rd_count); |
528 | qe->lookup_proc (qe->proc_cls, rd_count, rd); | 577 | qe->lookup_proc (qe->proc_cls, rd_count, rd); |
529 | } | 578 | } |
530 | GNUNET_CONTAINER_DLL_remove (h->lookup_head, h->lookup_tail, qe); | 579 | GNUNET_CONTAINER_DLL_remove (h->lookup_head, h->lookup_tail, qe); |
531 | GNUNET_CONTAINER_DLL_remove (h->pending_head, | ||
532 | h->pending_tail, | ||
533 | p); | ||
534 | GNUNET_free (qe); | 580 | GNUNET_free (qe); |
535 | } | 581 | } |
536 | 582 | ||
583 | |||
537 | /** | 584 | /** |
538 | * Handler for messages received from the GNS service | 585 | * Handler for messages received from the GNS service |
539 | * | 586 | * |
@@ -563,55 +610,55 @@ process_message (void *cls, const struct GNUNET_MessageHeader *msg) | |||
563 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 610 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
564 | "Got LOOKUP_RESULT msg\n"); | 611 | "Got LOOKUP_RESULT msg\n"); |
565 | if (ntohs (msg->size) < sizeof (struct GNUNET_GNS_ClientLookupResultMessage)) | 612 | if (ntohs (msg->size) < sizeof (struct GNUNET_GNS_ClientLookupResultMessage)) |
566 | { | 613 | { |
567 | GNUNET_break (0); | 614 | GNUNET_break (0); |
568 | force_reconnect (handle); | 615 | force_reconnect (handle); |
569 | return; | 616 | return; |
570 | } | 617 | } |
571 | lookup_msg = (const struct GNUNET_GNS_ClientLookupResultMessage *) msg; | 618 | lookup_msg = (const struct GNUNET_GNS_ClientLookupResultMessage *) msg; |
572 | r_id = ntohl (lookup_msg->id); | 619 | r_id = ntohl (lookup_msg->id); |
573 | for (lr = handle->lookup_head; NULL != lr; lr = lr->next) | 620 | for (lr = handle->lookup_head; NULL != lr; lr = lr->next) |
574 | if (lr->r_id == r_id) | 621 | if (lr->r_id == r_id) |
575 | { | 622 | { |
576 | process_lookup_reply(lr, lookup_msg); | 623 | process_lookup_reply(lr, lookup_msg); |
577 | break; | 624 | break; |
578 | } | 625 | } |
579 | break; | 626 | break; |
580 | case GNUNET_MESSAGE_TYPE_GNS_SHORTEN_RESULT: | 627 | case GNUNET_MESSAGE_TYPE_GNS_SHORTEN_RESULT: |
581 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 628 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
582 | "Got SHORTEN_RESULT msg\n"); | 629 | "Got SHORTEN_RESULT msg\n"); |
583 | if (ntohs (msg->size) < sizeof (struct GNUNET_GNS_ClientShortenResultMessage)) | 630 | if (ntohs (msg->size) < sizeof (struct GNUNET_GNS_ClientShortenResultMessage)) |
584 | { | 631 | { |
585 | GNUNET_break (0); | 632 | GNUNET_break (0); |
586 | force_reconnect (handle); | 633 | force_reconnect (handle); |
587 | return; | 634 | return; |
588 | } | 635 | } |
589 | shorten_msg = (const struct GNUNET_GNS_ClientShortenResultMessage *) msg; | 636 | shorten_msg = (const struct GNUNET_GNS_ClientShortenResultMessage *) msg; |
590 | r_id = ntohl (shorten_msg->id); | 637 | r_id = ntohl (shorten_msg->id); |
591 | for (sr = handle->shorten_head; NULL != sr; sr = sr->next) | 638 | for (sr = handle->shorten_head; NULL != sr; sr = sr->next) |
592 | if (sr->r_id == r_id) | 639 | if (sr->r_id == r_id) |
593 | { | 640 | { |
594 | process_shorten_reply (sr, shorten_msg); | 641 | process_shorten_reply (sr, shorten_msg); |
595 | break; | 642 | break; |
596 | } | 643 | } |
597 | break; | 644 | break; |
598 | case GNUNET_MESSAGE_TYPE_GNS_GET_AUTH_RESULT: | 645 | case GNUNET_MESSAGE_TYPE_GNS_GET_AUTH_RESULT: |
599 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 646 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
600 | "Got GET_AUTH_RESULT msg\n"); | 647 | "Got GET_AUTH_RESULT msg\n"); |
601 | if (ntohs (msg->size) < sizeof (struct GNUNET_GNS_ClientGetAuthResultMessage)) | 648 | if (ntohs (msg->size) < sizeof (struct GNUNET_GNS_ClientGetAuthResultMessage)) |
602 | { | 649 | { |
603 | GNUNET_break (0); | 650 | GNUNET_break (0); |
604 | force_reconnect (handle); | 651 | force_reconnect (handle); |
605 | return; | 652 | return; |
606 | } | 653 | } |
607 | get_auth_msg = (const struct GNUNET_GNS_ClientGetAuthResultMessage *) msg; | 654 | get_auth_msg = (const struct GNUNET_GNS_ClientGetAuthResultMessage *) msg; |
608 | r_id = ntohl (get_auth_msg->id); | 655 | r_id = ntohl (get_auth_msg->id); |
609 | for (gar = handle->get_auth_head; NULL != gar; gar = gar->next) | 656 | for (gar = handle->get_auth_head; NULL != gar; gar = gar->next) |
610 | if (gar->r_id == r_id) | 657 | if (gar->r_id == r_id) |
611 | { | 658 | { |
612 | process_get_auth_reply (gar, get_auth_msg); | 659 | process_get_auth_reply (gar, get_auth_msg); |
613 | break; | 660 | break; |
614 | } | 661 | } |
615 | break; | 662 | break; |
616 | default: | 663 | default: |
617 | GNUNET_break (0); | 664 | GNUNET_break (0); |
@@ -655,12 +702,10 @@ GNUNET_GNS_disconnect (struct GNUNET_GNS_Handle *handle) | |||
655 | GNUNET_SCHEDULER_cancel (handle->reconnect_task); | 702 | GNUNET_SCHEDULER_cancel (handle->reconnect_task); |
656 | handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK; | 703 | handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK; |
657 | } | 704 | } |
658 | //FIXME sane? | 705 | GNUNET_assert (NULL == handle->lookup_head); |
659 | /*GNUNET_assert (NULL == handle->lookup_head); | ||
660 | GNUNET_assert (NULL == handle->shorten_head); | 706 | GNUNET_assert (NULL == handle->shorten_head); |
661 | GNUNET_assert (NULL == handle->get_auth_head);*/ | 707 | GNUNET_assert (NULL == handle->get_auth_head); |
662 | GNUNET_free(handle); | 708 | GNUNET_free (handle); |
663 | /* disco from GNS */ | ||
664 | } | 709 | } |
665 | 710 | ||
666 | 711 | ||
@@ -672,18 +717,16 @@ GNUNET_GNS_disconnect (struct GNUNET_GNS_Handle *handle) | |||
672 | void | 717 | void |
673 | GNUNET_GNS_cancel_lookup_request (struct GNUNET_GNS_LookupRequest *lr) | 718 | GNUNET_GNS_cancel_lookup_request (struct GNUNET_GNS_LookupRequest *lr) |
674 | { | 719 | { |
675 | struct PendingMessage *tmp = (struct PendingMessage*)&lr[1]; | 720 | struct PendingMessage *p = (struct PendingMessage*) &lr[1]; |
676 | 721 | ||
677 | GNUNET_assert (NULL != lr->gns_handle); | 722 | GNUNET_assert (NULL != lr->gns_handle); |
678 | if (NULL != tmp) | 723 | if (GNUNET_NO == p->transmitted) |
679 | GNUNET_CONTAINER_DLL_remove (lr->gns_handle->pending_head, | 724 | GNUNET_CONTAINER_DLL_remove (lr->gns_handle->pending_head, |
680 | lr->gns_handle->pending_tail, | 725 | lr->gns_handle->pending_tail, |
681 | tmp); | 726 | p); |
682 | |||
683 | GNUNET_CONTAINER_DLL_remove (lr->gns_handle->lookup_head, | 727 | GNUNET_CONTAINER_DLL_remove (lr->gns_handle->lookup_head, |
684 | lr->gns_handle->lookup_tail, | 728 | lr->gns_handle->lookup_tail, |
685 | lr); | 729 | lr); |
686 | |||
687 | GNUNET_free (lr); | 730 | GNUNET_free (lr); |
688 | } | 731 | } |
689 | 732 | ||
@@ -696,18 +739,16 @@ GNUNET_GNS_cancel_lookup_request (struct GNUNET_GNS_LookupRequest *lr) | |||
696 | void | 739 | void |
697 | GNUNET_GNS_cancel_shorten_request (struct GNUNET_GNS_ShortenRequest *sr) | 740 | GNUNET_GNS_cancel_shorten_request (struct GNUNET_GNS_ShortenRequest *sr) |
698 | { | 741 | { |
699 | struct PendingMessage *tmp = (struct PendingMessage*)&sr[1]; | 742 | struct PendingMessage *p = (struct PendingMessage*) &sr[1]; |
700 | 743 | ||
701 | GNUNET_assert (NULL != sr->gns_handle); | 744 | GNUNET_assert (NULL != sr->gns_handle); |
702 | if (NULL != tmp) | 745 | if (GNUNET_NO == p->transmitted) |
703 | GNUNET_CONTAINER_DLL_remove (sr->gns_handle->pending_head, | 746 | GNUNET_CONTAINER_DLL_remove (sr->gns_handle->pending_head, |
704 | sr->gns_handle->pending_tail, | 747 | sr->gns_handle->pending_tail, |
705 | tmp); | 748 | p); |
706 | |||
707 | GNUNET_CONTAINER_DLL_remove (sr->gns_handle->shorten_head, | 749 | GNUNET_CONTAINER_DLL_remove (sr->gns_handle->shorten_head, |
708 | sr->gns_handle->shorten_tail, | 750 | sr->gns_handle->shorten_tail, |
709 | sr); | 751 | sr); |
710 | |||
711 | GNUNET_free (sr); | 752 | GNUNET_free (sr); |
712 | } | 753 | } |
713 | 754 | ||
@@ -720,19 +761,16 @@ GNUNET_GNS_cancel_shorten_request (struct GNUNET_GNS_ShortenRequest *sr) | |||
720 | void | 761 | void |
721 | GNUNET_GNS_cancel_get_auth_request (struct GNUNET_GNS_GetAuthRequest *gar) | 762 | GNUNET_GNS_cancel_get_auth_request (struct GNUNET_GNS_GetAuthRequest *gar) |
722 | { | 763 | { |
723 | struct PendingMessage *tmp = (struct PendingMessage*)&gar[1]; | 764 | struct PendingMessage *p = (struct PendingMessage*) &gar[1]; |
724 | 765 | ||
725 | GNUNET_assert (NULL != gar->gns_handle); | 766 | GNUNET_assert (NULL != gar->gns_handle); |
726 | 767 | if (GNUNET_NO == p->transmitted) | |
727 | if (NULL != tmp) | ||
728 | GNUNET_CONTAINER_DLL_remove (gar->gns_handle->pending_head, | 768 | GNUNET_CONTAINER_DLL_remove (gar->gns_handle->pending_head, |
729 | gar->gns_handle->pending_tail, | 769 | gar->gns_handle->pending_tail, |
730 | tmp); | 770 | p); |
731 | |||
732 | GNUNET_CONTAINER_DLL_remove (gar->gns_handle->get_auth_head, | 771 | GNUNET_CONTAINER_DLL_remove (gar->gns_handle->get_auth_head, |
733 | gar->gns_handle->get_auth_tail, | 772 | gar->gns_handle->get_auth_tail, |
734 | gar); | 773 | gar); |
735 | |||
736 | GNUNET_free (gar); | 774 | GNUNET_free (gar); |
737 | } | 775 | } |
738 | 776 | ||
@@ -752,13 +790,13 @@ GNUNET_GNS_cancel_get_auth_request (struct GNUNET_GNS_GetAuthRequest *gar) | |||
752 | */ | 790 | */ |
753 | struct GNUNET_GNS_LookupRequest* | 791 | struct GNUNET_GNS_LookupRequest* |
754 | GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle, | 792 | GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle, |
755 | const char * name, | 793 | const char *name, |
756 | struct GNUNET_CRYPTO_ShortHashCode *zone, | 794 | struct GNUNET_CRYPTO_ShortHashCode *zone, |
757 | enum GNUNET_GNS_RecordType type, | 795 | enum GNUNET_GNS_RecordType type, |
758 | int only_cached, | 796 | int only_cached, |
759 | struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key, | 797 | struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key, |
760 | GNUNET_GNS_LookupResultProcessor proc, | 798 | GNUNET_GNS_LookupResultProcessor proc, |
761 | void *proc_cls) | 799 | void *proc_cls) |
762 | { | 800 | { |
763 | /* IPC to shorten gns names, return shorten_handle */ | 801 | /* IPC to shorten gns names, return shorten_handle */ |
764 | struct GNUNET_GNS_ClientLookupMessage *lookup_msg; | 802 | struct GNUNET_GNS_ClientLookupMessage *lookup_msg; |
@@ -768,14 +806,12 @@ GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle, | |||
768 | struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pkey_enc; | 806 | struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pkey_enc; |
769 | size_t key_len; | 807 | size_t key_len; |
770 | char* pkey_tmp; | 808 | char* pkey_tmp; |
771 | size_t request_size; | ||
772 | 809 | ||
773 | if (NULL == name) | 810 | if (NULL == name) |
774 | { | 811 | { |
775 | GNUNET_break (0); | 812 | GNUNET_break (0); |
776 | return NULL; | 813 | return NULL; |
777 | } | 814 | } |
778 | |||
779 | if (NULL != shorten_key) | 815 | if (NULL != shorten_key) |
780 | { | 816 | { |
781 | pkey_enc = GNUNET_CRYPTO_rsa_encode_key (shorten_key); | 817 | pkey_enc = GNUNET_CRYPTO_rsa_encode_key (shorten_key); |
@@ -787,14 +823,18 @@ GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle, | |||
787 | pkey_enc = NULL; | 823 | pkey_enc = NULL; |
788 | key_len = 0; | 824 | key_len = 0; |
789 | } | 825 | } |
790 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 826 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
791 | "Trying to lookup %s in GNS\n", | 827 | "Trying to lookup `%s' in GNS\n", |
792 | name); | 828 | name); |
793 | msize = sizeof (struct GNUNET_GNS_ClientLookupMessage) | 829 | msize = sizeof (struct GNUNET_GNS_ClientLookupMessage) |
794 | + key_len + strlen (name) + 1; | 830 | + key_len + strlen (name) + 1; |
795 | request_size = sizeof (struct GNUNET_GNS_LookupRequest) + | 831 | if (msize > UINT16_MAX) |
796 | sizeof (struct PendingMessage) + msize; | 832 | { |
797 | lr = GNUNET_malloc (request_size); | 833 | GNUNET_break (0); |
834 | return NULL; | ||
835 | } | ||
836 | lr = GNUNET_malloc (sizeof (struct GNUNET_GNS_LookupRequest) + | ||
837 | sizeof (struct PendingMessage) + msize); | ||
798 | lr->gns_handle = handle; | 838 | lr->gns_handle = handle; |
799 | lr->lookup_proc = proc; | 839 | lr->lookup_proc = proc; |
800 | lr->proc_cls = proc_cls; | 840 | lr->proc_cls = proc_cls; |
@@ -854,7 +894,7 @@ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | |||
854 | */ | 894 | */ |
855 | struct GNUNET_GNS_LookupRequest* | 895 | struct GNUNET_GNS_LookupRequest* |
856 | GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle, | 896 | GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle, |
857 | const char * name, | 897 | const char *name, |
858 | enum GNUNET_GNS_RecordType type, | 898 | enum GNUNET_GNS_RecordType type, |
859 | int only_cached, | 899 | int only_cached, |
860 | struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key, | 900 | struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key, |
@@ -883,7 +923,7 @@ GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle, | |||
883 | */ | 923 | */ |
884 | struct GNUNET_GNS_ShortenRequest* | 924 | struct GNUNET_GNS_ShortenRequest* |
885 | GNUNET_GNS_shorten_zone (struct GNUNET_GNS_Handle *handle, | 925 | GNUNET_GNS_shorten_zone (struct GNUNET_GNS_Handle *handle, |
886 | const char * name, | 926 | const char *name, |
887 | struct GNUNET_CRYPTO_ShortHashCode *private_zone, | 927 | struct GNUNET_CRYPTO_ShortHashCode *private_zone, |
888 | struct GNUNET_CRYPTO_ShortHashCode *shorten_zone, | 928 | struct GNUNET_CRYPTO_ShortHashCode *shorten_zone, |
889 | struct GNUNET_CRYPTO_ShortHashCode *zone, | 929 | struct GNUNET_CRYPTO_ShortHashCode *zone, |
@@ -894,7 +934,6 @@ GNUNET_GNS_shorten_zone (struct GNUNET_GNS_Handle *handle, | |||
894 | struct GNUNET_GNS_ClientShortenMessage *shorten_msg; | 934 | struct GNUNET_GNS_ClientShortenMessage *shorten_msg; |
895 | struct GNUNET_GNS_ShortenRequest *sr; | 935 | struct GNUNET_GNS_ShortenRequest *sr; |
896 | size_t msize; | 936 | size_t msize; |
897 | size_t request_size; | ||
898 | struct PendingMessage *pending; | 937 | struct PendingMessage *pending; |
899 | 938 | ||
900 | if (NULL == name) | 939 | if (NULL == name) |
@@ -902,30 +941,31 @@ GNUNET_GNS_shorten_zone (struct GNUNET_GNS_Handle *handle, | |||
902 | GNUNET_break (0); | 941 | GNUNET_break (0); |
903 | return NULL; | 942 | return NULL; |
904 | } | 943 | } |
905 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to shorten %s in GNS\n", name); | 944 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to shorten `%s' in GNS\n", name); |
906 | 945 | msize = sizeof (struct GNUNET_GNS_ClientShortenMessage) + strlen (name) + 1; | |
907 | msize = sizeof (struct GNUNET_GNS_ClientShortenMessage) + strlen(name) + 1; | 946 | if (msize > UINT16_MAX) |
908 | request_size = sizeof (struct GNUNET_GNS_ShortenRequest) + | 947 | { |
909 | sizeof (struct PendingMessage) + msize; | 948 | GNUNET_break (0); |
910 | sr = GNUNET_malloc (request_size); | 949 | return NULL; |
950 | } | ||
951 | sr = GNUNET_malloc (sizeof (struct GNUNET_GNS_ShortenRequest) + | ||
952 | sizeof (struct PendingMessage) + msize); | ||
911 | sr->gns_handle = handle; | 953 | sr->gns_handle = handle; |
912 | sr->shorten_proc = proc; | 954 | sr->shorten_proc = proc; |
913 | sr->proc_cls = proc_cls; | 955 | sr->proc_cls = proc_cls; |
914 | sr->r_id = handle->r_id++; | 956 | sr->r_id = handle->r_id++; |
915 | GNUNET_CONTAINER_DLL_insert_tail (handle->shorten_head, | 957 | GNUNET_CONTAINER_DLL_insert_tail (handle->shorten_head, |
916 | handle->shorten_tail, sr); | 958 | handle->shorten_tail, sr); |
917 | |||
918 | pending = (struct PendingMessage *)&sr[1]; | 959 | pending = (struct PendingMessage *)&sr[1]; |
919 | pending->size = msize; | 960 | pending->size = msize; |
920 | pending->r_id = sr->r_id; | 961 | pending->r_id = sr->r_id; |
921 | 962 | ||
922 | shorten_msg = (struct GNUNET_GNS_ClientShortenMessage *) &pending[1]; | 963 | shorten_msg = (struct GNUNET_GNS_ClientShortenMessage *) &pending[1]; |
923 | shorten_msg->header.type = htons (GNUNET_MESSAGE_TYPE_GNS_SHORTEN); | 964 | shorten_msg->header.type = htons (GNUNET_MESSAGE_TYPE_GNS_SHORTEN); |
924 | shorten_msg->header.size = htons (msize); | 965 | shorten_msg->header.size = htons ((uint16_t) msize); |
925 | shorten_msg->id = htonl (sr->r_id); | 966 | shorten_msg->id = htonl (sr->r_id); |
926 | shorten_msg->private_zone = *private_zone; | 967 | shorten_msg->private_zone = *private_zone; |
927 | shorten_msg->shorten_zone = *shorten_zone; | 968 | shorten_msg->shorten_zone = *shorten_zone; |
928 | |||
929 | if (NULL != zone) | 969 | if (NULL != zone) |
930 | { | 970 | { |
931 | shorten_msg->use_default_zone = htonl (GNUNET_NO); | 971 | shorten_msg->use_default_zone = htonl (GNUNET_NO); |
@@ -936,13 +976,10 @@ GNUNET_GNS_shorten_zone (struct GNUNET_GNS_Handle *handle, | |||
936 | { | 976 | { |
937 | shorten_msg->use_default_zone = htonl (GNUNET_YES); | 977 | shorten_msg->use_default_zone = htonl (GNUNET_YES); |
938 | memset (&shorten_msg->zone, 0, sizeof (struct GNUNET_CRYPTO_ShortHashCode)); | 978 | memset (&shorten_msg->zone, 0, sizeof (struct GNUNET_CRYPTO_ShortHashCode)); |
939 | } | 979 | } |
940 | |||
941 | memcpy (&shorten_msg[1], name, strlen (name) + 1); | 980 | memcpy (&shorten_msg[1], name, strlen (name) + 1); |
942 | |||
943 | GNUNET_CONTAINER_DLL_insert_tail (handle->pending_head, handle->pending_tail, | 981 | GNUNET_CONTAINER_DLL_insert_tail (handle->pending_head, handle->pending_tail, |
944 | pending); | 982 | pending); |
945 | |||
946 | process_pending_messages (handle); | 983 | process_pending_messages (handle); |
947 | return sr; | 984 | return sr; |
948 | } | 985 | } |
@@ -961,7 +998,7 @@ GNUNET_GNS_shorten_zone (struct GNUNET_GNS_Handle *handle, | |||
961 | */ | 998 | */ |
962 | struct GNUNET_GNS_ShortenRequest* | 999 | struct GNUNET_GNS_ShortenRequest* |
963 | GNUNET_GNS_shorten (struct GNUNET_GNS_Handle *handle, | 1000 | GNUNET_GNS_shorten (struct GNUNET_GNS_Handle *handle, |
964 | const char * name, | 1001 | const char *name, |
965 | struct GNUNET_CRYPTO_ShortHashCode *private_zone, | 1002 | struct GNUNET_CRYPTO_ShortHashCode *private_zone, |
966 | struct GNUNET_CRYPTO_ShortHashCode *shorten_zone, | 1003 | struct GNUNET_CRYPTO_ShortHashCode *shorten_zone, |
967 | GNUNET_GNS_ShortenResultProcessor proc, | 1004 | GNUNET_GNS_ShortenResultProcessor proc, |
@@ -984,14 +1021,13 @@ GNUNET_GNS_shorten (struct GNUNET_GNS_Handle *handle, | |||
984 | */ | 1021 | */ |
985 | struct GNUNET_GNS_GetAuthRequest* | 1022 | struct GNUNET_GNS_GetAuthRequest* |
986 | GNUNET_GNS_get_authority (struct GNUNET_GNS_Handle *handle, | 1023 | GNUNET_GNS_get_authority (struct GNUNET_GNS_Handle *handle, |
987 | const char * name, | 1024 | const char *name, |
988 | GNUNET_GNS_GetAuthResultProcessor proc, | 1025 | GNUNET_GNS_GetAuthResultProcessor proc, |
989 | void *proc_cls) | 1026 | void *proc_cls) |
990 | { | 1027 | { |
991 | struct GNUNET_GNS_ClientGetAuthMessage *get_auth_msg; | 1028 | struct GNUNET_GNS_ClientGetAuthMessage *get_auth_msg; |
992 | struct GNUNET_GNS_GetAuthRequest *gar; | 1029 | struct GNUNET_GNS_GetAuthRequest *gar; |
993 | size_t msize; | 1030 | size_t msize; |
994 | size_t request_size; | ||
995 | struct PendingMessage *pending; | 1031 | struct PendingMessage *pending; |
996 | 1032 | ||
997 | if (NULL == name) | 1033 | if (NULL == name) |
@@ -1001,11 +1037,14 @@ GNUNET_GNS_get_authority (struct GNUNET_GNS_Handle *handle, | |||
1001 | } | 1037 | } |
1002 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1038 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1003 | "Trying to look up authority for %s in GNS\n", name); | 1039 | "Trying to look up authority for %s in GNS\n", name); |
1004 | |||
1005 | msize = sizeof (struct GNUNET_GNS_ClientGetAuthMessage) + strlen (name) + 1; | 1040 | msize = sizeof (struct GNUNET_GNS_ClientGetAuthMessage) + strlen (name) + 1; |
1006 | request_size = sizeof (struct GNUNET_GNS_GetAuthRequest) + | 1041 | if (msize > UINT16_MAX) |
1007 | sizeof (struct PendingMessage) + msize; | 1042 | { |
1008 | gar = GNUNET_malloc (request_size); | 1043 | GNUNET_break (0); |
1044 | return NULL; | ||
1045 | } | ||
1046 | gar = GNUNET_malloc (sizeof (struct GNUNET_GNS_GetAuthRequest) + | ||
1047 | sizeof (struct PendingMessage) + msize); | ||
1009 | gar->gns_handle = handle; | 1048 | gar->gns_handle = handle; |
1010 | gar->auth_proc = proc; | 1049 | gar->auth_proc = proc; |
1011 | gar->proc_cls = proc_cls; | 1050 | gar->proc_cls = proc_cls; |
@@ -1013,15 +1052,14 @@ GNUNET_GNS_get_authority (struct GNUNET_GNS_Handle *handle, | |||
1013 | GNUNET_CONTAINER_DLL_insert_tail (handle->get_auth_head, | 1052 | GNUNET_CONTAINER_DLL_insert_tail (handle->get_auth_head, |
1014 | handle->get_auth_tail, gar); | 1053 | handle->get_auth_tail, gar); |
1015 | 1054 | ||
1016 | pending = (struct PendingMessage *)&gar[1]; | 1055 | pending = (struct PendingMessage *) &gar[1]; |
1017 | pending->size = msize; | 1056 | pending->size = msize; |
1018 | pending->r_id = gar->r_id; | 1057 | pending->r_id = gar->r_id; |
1019 | get_auth_msg = (struct GNUNET_GNS_ClientGetAuthMessage *) &pending[1]; | 1058 | get_auth_msg = (struct GNUNET_GNS_ClientGetAuthMessage *) &pending[1]; |
1020 | get_auth_msg->header.type = htons (GNUNET_MESSAGE_TYPE_GNS_GET_AUTH); | 1059 | get_auth_msg->header.type = htons (GNUNET_MESSAGE_TYPE_GNS_GET_AUTH); |
1021 | get_auth_msg->header.size = htons (msize); | 1060 | get_auth_msg->header.size = htons (msize); |
1022 | get_auth_msg->id = htonl (gar->r_id); | 1061 | get_auth_msg->id = htonl (gar->r_id); |
1023 | memcpy (&get_auth_msg[1], name, strlen(name) + 1); | 1062 | memcpy (&get_auth_msg[1], name, strlen (name) + 1); |
1024 | |||
1025 | GNUNET_CONTAINER_DLL_insert_tail (handle->pending_head, | 1063 | GNUNET_CONTAINER_DLL_insert_tail (handle->pending_head, |
1026 | handle->pending_tail, | 1064 | handle->pending_tail, |
1027 | pending); | 1065 | pending); |