aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2012-09-20 08:20:58 +0000
committerChristian Grothoff <christian@grothoff.org>2012-09-20 08:20:58 +0000
commitf1be2c0c8410b0829171990f85ffb4d107216ffb (patch)
treeb982737a5a6fefd40f43e412004ee3bf3101944e /src
parentf7bddd17b9b5f2244b4b6f5c82059961f0fa37ed (diff)
downloadgnunet-f1be2c0c8410b0829171990f85ffb4d107216ffb.tar.gz
gnunet-f1be2c0c8410b0829171990f85ffb4d107216ffb.zip
-code review
Diffstat (limited to 'src')
-rw-r--r--src/gns/gns_api.c316
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)
292static void 294static void
293force_reconnect (struct GNUNET_GNS_Handle *h) 295force_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)
362static size_t 399static size_t
363transmit_pending (void *cls, size_t size, void *buf) 400transmit_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)
672void 717void
673GNUNET_GNS_cancel_lookup_request (struct GNUNET_GNS_LookupRequest *lr) 718GNUNET_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)
696void 739void
697GNUNET_GNS_cancel_shorten_request (struct GNUNET_GNS_ShortenRequest *sr) 740GNUNET_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)
720void 761void
721GNUNET_GNS_cancel_get_auth_request (struct GNUNET_GNS_GetAuthRequest *gar) 762GNUNET_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 */
753struct GNUNET_GNS_LookupRequest* 791struct GNUNET_GNS_LookupRequest*
754GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle, 792GNUNET_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 }
790GNUNET_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 */
855struct GNUNET_GNS_LookupRequest* 895struct GNUNET_GNS_LookupRequest*
856GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle, 896GNUNET_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 */
884struct GNUNET_GNS_ShortenRequest* 924struct GNUNET_GNS_ShortenRequest*
885GNUNET_GNS_shorten_zone (struct GNUNET_GNS_Handle *handle, 925GNUNET_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 */
962struct GNUNET_GNS_ShortenRequest* 999struct GNUNET_GNS_ShortenRequest*
963GNUNET_GNS_shorten (struct GNUNET_GNS_Handle *handle, 1000GNUNET_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 */
985struct GNUNET_GNS_GetAuthRequest* 1022struct GNUNET_GNS_GetAuthRequest*
986GNUNET_GNS_get_authority (struct GNUNET_GNS_Handle *handle, 1023GNUNET_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);