diff options
Diffstat (limited to 'src/transport/gnunet-communicator-tcp.c')
-rw-r--r-- | src/transport/gnunet-communicator-tcp.c | 1840 |
1 files changed, 917 insertions, 923 deletions
diff --git a/src/transport/gnunet-communicator-tcp.c b/src/transport/gnunet-communicator-tcp.c index c883166c6..a8d692940 100644 --- a/src/transport/gnunet-communicator-tcp.c +++ b/src/transport/gnunet-communicator-tcp.c | |||
@@ -16,7 +16,7 @@ | |||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file transport/gnunet-communicator-tcp.c | 22 | * @file transport/gnunet-communicator-tcp.c |
@@ -47,7 +47,7 @@ | |||
47 | * the other peer should revalidate). | 47 | * the other peer should revalidate). |
48 | */ | 48 | */ |
49 | #define ADDRESS_VALIDITY_PERIOD \ | 49 | #define ADDRESS_VALIDITY_PERIOD \ |
50 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4) | 50 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 4) |
51 | 51 | ||
52 | /** | 52 | /** |
53 | * How many messages do we keep at most in the queue to the | 53 | * How many messages do we keep at most in the queue to the |
@@ -63,7 +63,7 @@ | |||
63 | * Size of our IO buffers for ciphertext data. Must be at | 63 | * Size of our IO buffers for ciphertext data. Must be at |
64 | * least UINT_MAX + sizeof (struct TCPBox). | 64 | * least UINT_MAX + sizeof (struct TCPBox). |
65 | */ | 65 | */ |
66 | #define BUF_SIZE (2 * 64 * 1024 + sizeof (struct TCPBox)) | 66 | #define BUF_SIZE (2 * 64 * 1024 + sizeof(struct TCPBox)) |
67 | 67 | ||
68 | /** | 68 | /** |
69 | * How often do we rekey based on time (at least) | 69 | * How often do we rekey based on time (at least) |
@@ -86,8 +86,8 @@ | |||
86 | * directions. | 86 | * directions. |
87 | */ | 87 | */ |
88 | #define INITIAL_KX_SIZE \ | 88 | #define INITIAL_KX_SIZE \ |
89 | (sizeof (struct GNUNET_CRYPTO_EcdhePublicKey) + \ | 89 | (sizeof(struct GNUNET_CRYPTO_EcdhePublicKey) + \ |
90 | sizeof (struct TCPConfirmation)) | 90 | sizeof(struct TCPConfirmation)) |
91 | 91 | ||
92 | 92 | ||
93 | /** | 93 | /** |
@@ -107,8 +107,7 @@ GNUNET_NETWORK_STRUCT_BEGIN | |||
107 | * Signature we use to verify that the ephemeral key was really chosen by | 107 | * Signature we use to verify that the ephemeral key was really chosen by |
108 | * the specified sender. | 108 | * the specified sender. |
109 | */ | 109 | */ |
110 | struct TcpHandshakeSignature | 110 | struct TcpHandshakeSignature { |
111 | { | ||
112 | /** | 111 | /** |
113 | * Purpose must be #GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE | 112 | * Purpose must be #GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE |
114 | */ | 113 | */ |
@@ -140,8 +139,7 @@ struct TcpHandshakeSignature | |||
140 | /** | 139 | /** |
141 | * Encrypted continuation of TCP initial handshake. | 140 | * Encrypted continuation of TCP initial handshake. |
142 | */ | 141 | */ |
143 | struct TCPConfirmation | 142 | struct TCPConfirmation { |
144 | { | ||
145 | /** | 143 | /** |
146 | * Sender's identity | 144 | * Sender's identity |
147 | */ | 145 | */ |
@@ -163,9 +161,7 @@ struct TCPConfirmation | |||
163 | /** | 161 | /** |
164 | * TCP message box. Always sent encrypted! | 162 | * TCP message box. Always sent encrypted! |
165 | */ | 163 | */ |
166 | struct TCPBox | 164 | struct TCPBox { |
167 | { | ||
168 | |||
169 | /** | 165 | /** |
170 | * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX. Warning: the | 166 | * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX. Warning: the |
171 | * header size EXCLUDES the size of the `struct TCPBox`. We usually | 167 | * header size EXCLUDES the size of the `struct TCPBox`. We usually |
@@ -193,9 +189,7 @@ struct TCPBox | |||
193 | * TCP rekey message box. Always sent encrypted! Data after | 189 | * TCP rekey message box. Always sent encrypted! Data after |
194 | * this message will use the new key. | 190 | * this message will use the new key. |
195 | */ | 191 | */ |
196 | struct TCPRekey | 192 | struct TCPRekey { |
197 | { | ||
198 | |||
199 | /** | 193 | /** |
200 | * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY. | 194 | * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY. |
201 | */ | 195 | */ |
@@ -234,9 +228,7 @@ struct TCPRekey | |||
234 | * Needed/useful in case we drop RST/FIN packets on the GNUnet | 228 | * Needed/useful in case we drop RST/FIN packets on the GNUnet |
235 | * port due to the possibility of malicious RST/FIN injection. | 229 | * port due to the possibility of malicious RST/FIN injection. |
236 | */ | 230 | */ |
237 | struct TCPFinish | 231 | struct TCPFinish { |
238 | { | ||
239 | |||
240 | /** | 232 | /** |
241 | * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH. | 233 | * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH. |
242 | */ | 234 | */ |
@@ -260,9 +252,7 @@ GNUNET_NETWORK_STRUCT_END | |||
260 | /** | 252 | /** |
261 | * Handle for a queue. | 253 | * Handle for a queue. |
262 | */ | 254 | */ |
263 | struct Queue | 255 | struct Queue { |
264 | { | ||
265 | |||
266 | /** | 256 | /** |
267 | * To whom are we talking to. | 257 | * To whom are we talking to. |
268 | */ | 258 | */ |
@@ -360,12 +350,12 @@ struct Queue | |||
360 | /** | 350 | /** |
361 | * Plaintext buffer for decrypted plaintext. | 351 | * Plaintext buffer for decrypted plaintext. |
362 | */ | 352 | */ |
363 | char pread_buf[UINT16_MAX + 1 + sizeof (struct TCPBox)]; | 353 | char pread_buf[UINT16_MAX + 1 + sizeof(struct TCPBox)]; |
364 | 354 | ||
365 | /** | 355 | /** |
366 | * Plaintext buffer for messages to be encrypted. | 356 | * Plaintext buffer for messages to be encrypted. |
367 | */ | 357 | */ |
368 | char pwrite_buf[UINT16_MAX + 1 + sizeof (struct TCPBox)]; | 358 | char pwrite_buf[UINT16_MAX + 1 + sizeof(struct TCPBox)]; |
369 | 359 | ||
370 | /** | 360 | /** |
371 | * At which offset in the ciphertext read buffer should we | 361 | * At which offset in the ciphertext read buffer should we |
@@ -440,9 +430,7 @@ struct Queue | |||
440 | * Handle for an incoming connection where we do not yet have enough | 430 | * Handle for an incoming connection where we do not yet have enough |
441 | * information to setup a full queue. | 431 | * information to setup a full queue. |
442 | */ | 432 | */ |
443 | struct ProtoQueue | 433 | struct ProtoQueue { |
444 | { | ||
445 | |||
446 | /** | 434 | /** |
447 | * Kept in a DLL. | 435 | * Kept in a DLL. |
448 | */ | 436 | */ |
@@ -565,7 +553,7 @@ static struct ProtoQueue *proto_tail; | |||
565 | * @param cls NULL | 553 | * @param cls NULL |
566 | */ | 554 | */ |
567 | static void | 555 | static void |
568 | listen_cb (void *cls); | 556 | listen_cb(void *cls); |
569 | 557 | ||
570 | 558 | ||
571 | /** | 559 | /** |
@@ -576,53 +564,53 @@ listen_cb (void *cls); | |||
576 | * @param queue queue to close down | 564 | * @param queue queue to close down |
577 | */ | 565 | */ |
578 | static void | 566 | static void |
579 | queue_destroy (struct Queue *queue) | 567 | queue_destroy(struct Queue *queue) |
580 | { | 568 | { |
581 | struct GNUNET_MQ_Handle *mq; | 569 | struct GNUNET_MQ_Handle *mq; |
582 | 570 | ||
583 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 571 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
584 | "Disconnecting queue for peer `%s'\n", | 572 | "Disconnecting queue for peer `%s'\n", |
585 | GNUNET_i2s (&queue->target)); | 573 | GNUNET_i2s(&queue->target)); |
586 | if (NULL != (mq = queue->mq)) | 574 | if (NULL != (mq = queue->mq)) |
587 | { | 575 | { |
588 | queue->mq = NULL; | 576 | queue->mq = NULL; |
589 | GNUNET_MQ_destroy (mq); | 577 | GNUNET_MQ_destroy(mq); |
590 | } | 578 | } |
591 | if (NULL != queue->qh) | 579 | if (NULL != queue->qh) |
592 | { | 580 | { |
593 | GNUNET_TRANSPORT_communicator_mq_del (queue->qh); | 581 | GNUNET_TRANSPORT_communicator_mq_del(queue->qh); |
594 | queue->qh = NULL; | 582 | queue->qh = NULL; |
595 | } | 583 | } |
596 | GNUNET_assert ( | 584 | GNUNET_assert( |
597 | GNUNET_YES == | 585 | GNUNET_YES == |
598 | GNUNET_CONTAINER_multipeermap_remove (queue_map, &queue->target, queue)); | 586 | GNUNET_CONTAINER_multipeermap_remove(queue_map, &queue->target, queue)); |
599 | GNUNET_STATISTICS_set (stats, | 587 | GNUNET_STATISTICS_set(stats, |
600 | "# queues active", | 588 | "# queues active", |
601 | GNUNET_CONTAINER_multipeermap_size (queue_map), | 589 | GNUNET_CONTAINER_multipeermap_size(queue_map), |
602 | GNUNET_NO); | 590 | GNUNET_NO); |
603 | if (NULL != queue->read_task) | 591 | if (NULL != queue->read_task) |
604 | { | 592 | { |
605 | GNUNET_SCHEDULER_cancel (queue->read_task); | 593 | GNUNET_SCHEDULER_cancel(queue->read_task); |
606 | queue->read_task = NULL; | 594 | queue->read_task = NULL; |
607 | } | 595 | } |
608 | if (NULL != queue->write_task) | 596 | if (NULL != queue->write_task) |
609 | { | 597 | { |
610 | GNUNET_SCHEDULER_cancel (queue->write_task); | 598 | GNUNET_SCHEDULER_cancel(queue->write_task); |
611 | queue->write_task = NULL; | 599 | queue->write_task = NULL; |
612 | } | 600 | } |
613 | GNUNET_NETWORK_socket_close (queue->sock); | 601 | GNUNET_NETWORK_socket_close(queue->sock); |
614 | gcry_cipher_close (queue->in_cipher); | 602 | gcry_cipher_close(queue->in_cipher); |
615 | gcry_cipher_close (queue->out_cipher); | 603 | gcry_cipher_close(queue->out_cipher); |
616 | GNUNET_free (queue->address); | 604 | GNUNET_free(queue->address); |
617 | if (0 != queue->backpressure) | 605 | if (0 != queue->backpressure) |
618 | queue->destroyed = GNUNET_YES; | 606 | queue->destroyed = GNUNET_YES; |
619 | else | 607 | else |
620 | GNUNET_free (queue); | 608 | GNUNET_free(queue); |
621 | if (NULL == listen_task) | 609 | if (NULL == listen_task) |
622 | listen_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 610 | listen_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
623 | listen_sock, | 611 | listen_sock, |
624 | &listen_cb, | 612 | &listen_cb, |
625 | NULL); | 613 | NULL); |
626 | } | 614 | } |
627 | 615 | ||
628 | 616 | ||
@@ -635,24 +623,24 @@ queue_destroy (struct Queue *queue) | |||
635 | * @param smac[out] where to write the HMAC | 623 | * @param smac[out] where to write the HMAC |
636 | */ | 624 | */ |
637 | static void | 625 | static void |
638 | calculate_hmac (struct GNUNET_HashCode *hmac_secret, | 626 | calculate_hmac(struct GNUNET_HashCode *hmac_secret, |
639 | const void *buf, | 627 | const void *buf, |
640 | size_t buf_size, | 628 | size_t buf_size, |
641 | struct GNUNET_ShortHashCode *smac) | 629 | struct GNUNET_ShortHashCode *smac) |
642 | { | 630 | { |
643 | struct GNUNET_HashCode mac; | 631 | struct GNUNET_HashCode mac; |
644 | 632 | ||
645 | GNUNET_CRYPTO_hmac_raw (hmac_secret, | 633 | GNUNET_CRYPTO_hmac_raw(hmac_secret, |
646 | sizeof (struct GNUNET_HashCode), | 634 | sizeof(struct GNUNET_HashCode), |
647 | buf, | 635 | buf, |
648 | buf_size, | 636 | buf_size, |
649 | &mac); | 637 | &mac); |
650 | /* truncate to `struct GNUNET_ShortHashCode` */ | 638 | /* truncate to `struct GNUNET_ShortHashCode` */ |
651 | memcpy (smac, &mac, sizeof (struct GNUNET_ShortHashCode)); | 639 | memcpy(smac, &mac, sizeof(struct GNUNET_ShortHashCode)); |
652 | /* ratchet hmac key */ | 640 | /* ratchet hmac key */ |
653 | GNUNET_CRYPTO_hash (hmac_secret, | 641 | GNUNET_CRYPTO_hash(hmac_secret, |
654 | sizeof (struct GNUNET_HashCode), | 642 | sizeof(struct GNUNET_HashCode), |
655 | hmac_secret); | 643 | hmac_secret); |
656 | } | 644 | } |
657 | 645 | ||
658 | 646 | ||
@@ -663,23 +651,23 @@ calculate_hmac (struct GNUNET_HashCode *hmac_secret, | |||
663 | * @param queue queue to shut down nicely | 651 | * @param queue queue to shut down nicely |
664 | */ | 652 | */ |
665 | static void | 653 | static void |
666 | queue_finish (struct Queue *queue) | 654 | queue_finish(struct Queue *queue) |
667 | { | 655 | { |
668 | struct TCPFinish fin; | 656 | struct TCPFinish fin; |
669 | 657 | ||
670 | memset (&fin, 0, sizeof (fin)); | 658 | memset(&fin, 0, sizeof(fin)); |
671 | fin.header.size = htons (sizeof (fin)); | 659 | fin.header.size = htons(sizeof(fin)); |
672 | fin.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH); | 660 | fin.header.type = htons(GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH); |
673 | calculate_hmac (&queue->out_hmac, &fin, sizeof (fin), &fin.hmac); | 661 | calculate_hmac(&queue->out_hmac, &fin, sizeof(fin), &fin.hmac); |
674 | /* if there is any message left in pwrite_buf, we | 662 | /* if there is any message left in pwrite_buf, we |
675 | overwrite it (possibly dropping the last message | 663 | overwrite it (possibly dropping the last message |
676 | from CORE hard here) */ | 664 | from CORE hard here) */ |
677 | memcpy (queue->pwrite_buf, &fin, sizeof (fin)); | 665 | memcpy(queue->pwrite_buf, &fin, sizeof(fin)); |
678 | queue->pwrite_off = sizeof (fin); | 666 | queue->pwrite_off = sizeof(fin); |
679 | /* This flag will ensure that #queue_write() no longer | 667 | /* This flag will ensure that #queue_write() no longer |
680 | notifies CORE about the possibility of sending | 668 | notifies CORE about the possibility of sending |
681 | more data, and that #queue_write() will call | 669 | more data, and that #queue_write() will call |
682 | #queue_destroy() once the @c fin was fully written. */ | 670 | #queue_destroy() once the @c fin was fully written. */ |
683 | queue->finishing = GNUNET_YES; | 671 | queue->finishing = GNUNET_YES; |
684 | } | 672 | } |
685 | 673 | ||
@@ -692,10 +680,10 @@ queue_finish (struct Queue *queue) | |||
692 | * @param queue queue for which the timeout should be rescheduled | 680 | * @param queue queue for which the timeout should be rescheduled |
693 | */ | 681 | */ |
694 | static void | 682 | static void |
695 | reschedule_queue_timeout (struct Queue *queue) | 683 | reschedule_queue_timeout(struct Queue *queue) |
696 | { | 684 | { |
697 | queue->timeout = | 685 | queue->timeout = |
698 | GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); | 686 | GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); |
699 | } | 687 | } |
700 | 688 | ||
701 | 689 | ||
@@ -705,7 +693,7 @@ reschedule_queue_timeout (struct Queue *queue) | |||
705 | * @param cls the `struct Queue *` to disconnect | 693 | * @param cls the `struct Queue *` to disconnect |
706 | */ | 694 | */ |
707 | static void | 695 | static void |
708 | queue_read (void *cls); | 696 | queue_read(void *cls); |
709 | 697 | ||
710 | 698 | ||
711 | /** | 699 | /** |
@@ -716,31 +704,31 @@ queue_read (void *cls); | |||
716 | * @param success #GNUNET_OK on success | 704 | * @param success #GNUNET_OK on success |
717 | */ | 705 | */ |
718 | static void | 706 | static void |
719 | core_read_finished_cb (void *cls, int success) | 707 | core_read_finished_cb(void *cls, int success) |
720 | { | 708 | { |
721 | struct Queue *queue = cls; | 709 | struct Queue *queue = cls; |
722 | 710 | ||
723 | if (GNUNET_OK != success) | 711 | if (GNUNET_OK != success) |
724 | GNUNET_STATISTICS_update (stats, | 712 | GNUNET_STATISTICS_update(stats, |
725 | "# messages lost in communicator API towards CORE", | 713 | "# messages lost in communicator API towards CORE", |
726 | 1, | 714 | 1, |
727 | GNUNET_NO); | 715 | GNUNET_NO); |
728 | queue->backpressure--; | 716 | queue->backpressure--; |
729 | /* handle deferred queue destruction */ | 717 | /* handle deferred queue destruction */ |
730 | if ((queue->destroyed) && (0 == queue->backpressure)) | 718 | if ((queue->destroyed) && (0 == queue->backpressure)) |
731 | { | 719 | { |
732 | GNUNET_free (queue); | 720 | GNUNET_free(queue); |
733 | return; | 721 | return; |
734 | } | 722 | } |
735 | reschedule_queue_timeout (queue); | 723 | reschedule_queue_timeout(queue); |
736 | /* possibly unchoke reading, now that CORE made progress */ | 724 | /* possibly unchoke reading, now that CORE made progress */ |
737 | if (NULL == queue->read_task) | 725 | if (NULL == queue->read_task) |
738 | queue->read_task = | 726 | queue->read_task = |
739 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining ( | 727 | GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_absolute_get_remaining( |
740 | queue->timeout), | 728 | queue->timeout), |
741 | queue->sock, | 729 | queue->sock, |
742 | &queue_read, | 730 | &queue_read, |
743 | queue); | 731 | queue); |
744 | } | 732 | } |
745 | 733 | ||
746 | 734 | ||
@@ -754,34 +742,34 @@ core_read_finished_cb (void *cls, int success) | |||
754 | * @param plaintext_len number of bytes of plaintext received | 742 | * @param plaintext_len number of bytes of plaintext received |
755 | */ | 743 | */ |
756 | static void | 744 | static void |
757 | pass_plaintext_to_core (struct Queue *queue, | 745 | pass_plaintext_to_core(struct Queue *queue, |
758 | const void *plaintext, | 746 | const void *plaintext, |
759 | size_t plaintext_len) | 747 | size_t plaintext_len) |
760 | { | 748 | { |
761 | const struct GNUNET_MessageHeader *hdr = plaintext; | 749 | const struct GNUNET_MessageHeader *hdr = plaintext; |
762 | int ret; | 750 | int ret; |
763 | 751 | ||
764 | if (ntohs (hdr->size) != plaintext_len) | 752 | if (ntohs(hdr->size) != plaintext_len) |
765 | { | 753 | { |
766 | /* NOTE: If we ever allow multiple CORE messages in one | 754 | /* NOTE: If we ever allow multiple CORE messages in one |
767 | BOX, this will have to change! */ | 755 | BOX, this will have to change! */ |
768 | GNUNET_break (0); | 756 | GNUNET_break(0); |
769 | return; | 757 | return; |
770 | } | 758 | } |
771 | ret = GNUNET_TRANSPORT_communicator_receive (ch, | 759 | ret = GNUNET_TRANSPORT_communicator_receive(ch, |
772 | &queue->target, | 760 | &queue->target, |
773 | hdr, | 761 | hdr, |
774 | ADDRESS_VALIDITY_PERIOD, | 762 | ADDRESS_VALIDITY_PERIOD, |
775 | &core_read_finished_cb, | 763 | &core_read_finished_cb, |
776 | queue); | 764 | queue); |
777 | if (GNUNET_OK == ret) | 765 | if (GNUNET_OK == ret) |
778 | queue->backpressure++; | 766 | queue->backpressure++; |
779 | GNUNET_break (GNUNET_NO != ret); /* backpressure not working!? */ | 767 | GNUNET_break(GNUNET_NO != ret); /* backpressure not working!? */ |
780 | if (GNUNET_SYSERR == ret) | 768 | if (GNUNET_SYSERR == ret) |
781 | GNUNET_STATISTICS_update (stats, | 769 | GNUNET_STATISTICS_update(stats, |
782 | "# bytes lost due to CORE not running", | 770 | "# bytes lost due to CORE not running", |
783 | plaintext_len, | 771 | plaintext_len, |
784 | GNUNET_NO); | 772 | GNUNET_NO); |
785 | } | 773 | } |
786 | 774 | ||
787 | 775 | ||
@@ -795,51 +783,51 @@ pass_plaintext_to_core (struct Queue *queue, | |||
795 | * @param hmac_key[out] HMAC key to initialize | 783 | * @param hmac_key[out] HMAC key to initialize |
796 | */ | 784 | */ |
797 | static void | 785 | static void |
798 | setup_cipher (const struct GNUNET_HashCode *dh, | 786 | setup_cipher(const struct GNUNET_HashCode *dh, |
799 | const struct GNUNET_PeerIdentity *pid, | 787 | const struct GNUNET_PeerIdentity *pid, |
800 | gcry_cipher_hd_t *cipher, | 788 | gcry_cipher_hd_t *cipher, |
801 | struct GNUNET_HashCode *hmac_key) | 789 | struct GNUNET_HashCode *hmac_key) |
802 | { | 790 | { |
803 | char key[256 / 8]; | 791 | char key[256 / 8]; |
804 | char ctr[128 / 8]; | 792 | char ctr[128 / 8]; |
805 | 793 | ||
806 | gcry_cipher_open (cipher, | 794 | gcry_cipher_open(cipher, |
807 | GCRY_CIPHER_AES256 /* low level: go for speed */, | 795 | GCRY_CIPHER_AES256 /* low level: go for speed */, |
808 | GCRY_CIPHER_MODE_CTR, | 796 | GCRY_CIPHER_MODE_CTR, |
809 | 0 /* flags */); | 797 | 0 /* flags */); |
810 | GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_kdf (key, | 798 | GNUNET_assert(GNUNET_YES == GNUNET_CRYPTO_kdf(key, |
811 | sizeof (key), | 799 | sizeof(key), |
812 | "TCP-key", | 800 | "TCP-key", |
813 | strlen ("TCP-key"), | 801 | strlen("TCP-key"), |
814 | dh, | 802 | dh, |
815 | sizeof (*dh), | 803 | sizeof(*dh), |
816 | pid, | 804 | pid, |
817 | sizeof (*pid), | 805 | sizeof(*pid), |
818 | NULL, | 806 | NULL, |
819 | 0)); | 807 | 0)); |
820 | gcry_cipher_setkey (*cipher, key, sizeof (key)); | 808 | gcry_cipher_setkey(*cipher, key, sizeof(key)); |
821 | GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_kdf (ctr, | 809 | GNUNET_assert(GNUNET_YES == GNUNET_CRYPTO_kdf(ctr, |
822 | sizeof (ctr), | 810 | sizeof(ctr), |
823 | "TCP-ctr", | 811 | "TCP-ctr", |
824 | strlen ("TCP-ctr"), | 812 | strlen("TCP-ctr"), |
825 | dh, | 813 | dh, |
826 | sizeof (*dh), | 814 | sizeof(*dh), |
827 | pid, | 815 | pid, |
828 | sizeof (*pid), | 816 | sizeof(*pid), |
829 | NULL, | 817 | NULL, |
830 | 0)); | 818 | 0)); |
831 | gcry_cipher_setctr (*cipher, ctr, sizeof (ctr)); | 819 | gcry_cipher_setctr(*cipher, ctr, sizeof(ctr)); |
832 | GNUNET_assert (GNUNET_YES == | 820 | GNUNET_assert(GNUNET_YES == |
833 | GNUNET_CRYPTO_kdf (hmac_key, | 821 | GNUNET_CRYPTO_kdf(hmac_key, |
834 | sizeof (struct GNUNET_HashCode), | 822 | sizeof(struct GNUNET_HashCode), |
835 | "TCP-hmac", | 823 | "TCP-hmac", |
836 | strlen ("TCP-hmac"), | 824 | strlen("TCP-hmac"), |
837 | dh, | 825 | dh, |
838 | sizeof (*dh), | 826 | sizeof(*dh), |
839 | pid, | 827 | pid, |
840 | sizeof (*pid), | 828 | sizeof(*pid), |
841 | NULL, | 829 | NULL, |
842 | 0)); | 830 | 0)); |
843 | } | 831 | } |
844 | 832 | ||
845 | 833 | ||
@@ -850,13 +838,13 @@ setup_cipher (const struct GNUNET_HashCode *dh, | |||
850 | * @param queue[in,out] queue to initialize decryption cipher for | 838 | * @param queue[in,out] queue to initialize decryption cipher for |
851 | */ | 839 | */ |
852 | static void | 840 | static void |
853 | setup_in_cipher (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, | 841 | setup_in_cipher(const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, |
854 | struct Queue *queue) | 842 | struct Queue *queue) |
855 | { | 843 | { |
856 | struct GNUNET_HashCode dh; | 844 | struct GNUNET_HashCode dh; |
857 | 845 | ||
858 | GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &dh); | 846 | GNUNET_CRYPTO_eddsa_ecdh(my_private_key, ephemeral, &dh); |
859 | setup_cipher (&dh, &my_identity, &queue->in_cipher, &queue->in_hmac); | 847 | setup_cipher(&dh, &my_identity, &queue->in_cipher, &queue->in_hmac); |
860 | } | 848 | } |
861 | 849 | ||
862 | 850 | ||
@@ -869,30 +857,30 @@ setup_in_cipher (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, | |||
869 | * @param rekey the rekey message | 857 | * @param rekey the rekey message |
870 | */ | 858 | */ |
871 | static void | 859 | static void |
872 | do_rekey (struct Queue *queue, const struct TCPRekey *rekey) | 860 | do_rekey(struct Queue *queue, const struct TCPRekey *rekey) |
873 | { | 861 | { |
874 | struct TcpHandshakeSignature thp; | 862 | struct TcpHandshakeSignature thp; |
875 | 863 | ||
876 | thp.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY); | 864 | thp.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY); |
877 | thp.purpose.size = htonl (sizeof (thp)); | 865 | thp.purpose.size = htonl(sizeof(thp)); |
878 | thp.sender = queue->target; | 866 | thp.sender = queue->target; |
879 | thp.receiver = my_identity; | 867 | thp.receiver = my_identity; |
880 | thp.ephemeral = rekey->ephemeral; | 868 | thp.ephemeral = rekey->ephemeral; |
881 | thp.monotonic_time = rekey->monotonic_time; | 869 | thp.monotonic_time = rekey->monotonic_time; |
882 | /* FIXME: check monotonic time is monotonic... */ | 870 | /* FIXME: check monotonic time is monotonic... */ |
883 | if (GNUNET_OK != | 871 | if (GNUNET_OK != |
884 | GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY, | 872 | GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY, |
885 | &thp.purpose, | 873 | &thp.purpose, |
886 | &rekey->sender_sig, | 874 | &rekey->sender_sig, |
887 | &queue->target.public_key)) | 875 | &queue->target.public_key)) |
888 | { | 876 | { |
889 | GNUNET_break (0); | 877 | GNUNET_break(0); |
890 | queue_finish (queue); | 878 | queue_finish(queue); |
891 | return; | 879 | return; |
892 | } | 880 | } |
893 | gcry_cipher_close (queue->in_cipher); | 881 | gcry_cipher_close(queue->in_cipher); |
894 | queue->rekeyed = GNUNET_YES; | 882 | queue->rekeyed = GNUNET_YES; |
895 | setup_in_cipher (&rekey->ephemeral, queue); | 883 | setup_in_cipher(&rekey->ephemeral, queue); |
896 | } | 884 | } |
897 | 885 | ||
898 | 886 | ||
@@ -904,86 +892,89 @@ do_rekey (struct Queue *queue, const struct TCPRekey *rekey) | |||
904 | * @return number of bytes of plaintext handled, 0 for none | 892 | * @return number of bytes of plaintext handled, 0 for none |
905 | */ | 893 | */ |
906 | static size_t | 894 | static size_t |
907 | try_handle_plaintext (struct Queue *queue) | 895 | try_handle_plaintext(struct Queue *queue) |
908 | { | 896 | { |
909 | const struct GNUNET_MessageHeader *hdr = | 897 | const struct GNUNET_MessageHeader *hdr = |
910 | (const struct GNUNET_MessageHeader *) queue->pread_buf; | 898 | (const struct GNUNET_MessageHeader *)queue->pread_buf; |
911 | const struct TCPBox *box = (const struct TCPBox *) queue->pread_buf; | 899 | const struct TCPBox *box = (const struct TCPBox *)queue->pread_buf; |
912 | const struct TCPRekey *rekey = (const struct TCPRekey *) queue->pread_buf; | 900 | const struct TCPRekey *rekey = (const struct TCPRekey *)queue->pread_buf; |
913 | const struct TCPFinish *fin = (const struct TCPFinish *) queue->pread_buf; | 901 | const struct TCPFinish *fin = (const struct TCPFinish *)queue->pread_buf; |
914 | struct TCPRekey rekeyz; | 902 | struct TCPRekey rekeyz; |
915 | struct TCPFinish finz; | 903 | struct TCPFinish finz; |
916 | struct GNUNET_ShortHashCode tmac; | 904 | struct GNUNET_ShortHashCode tmac; |
917 | uint16_t type; | 905 | uint16_t type; |
918 | size_t size = 0; /* make compiler happy */ | 906 | size_t size = 0; /* make compiler happy */ |
919 | 907 | ||
920 | if (sizeof (*hdr) > queue->pread_off) | 908 | if (sizeof(*hdr) > queue->pread_off) |
921 | return 0; /* not even a header */ | 909 | return 0; /* not even a header */ |
922 | type = ntohs (hdr->type); | 910 | type = ntohs(hdr->type); |
923 | switch (type) | 911 | switch (type) |
924 | { | ||
925 | case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX: | ||
926 | /* Special case: header size excludes box itself! */ | ||
927 | if (ntohs (hdr->size) + sizeof (struct TCPBox) > queue->pread_off) | ||
928 | return 0; | ||
929 | calculate_hmac (&queue->in_hmac, &box[1], ntohs (hdr->size), &tmac); | ||
930 | if (0 != memcmp (&tmac, &box->hmac, sizeof (tmac))) | ||
931 | { | ||
932 | GNUNET_break_op (0); | ||
933 | queue_finish (queue); | ||
934 | return 0; | ||
935 | } | ||
936 | pass_plaintext_to_core (queue, (const void *) &box[1], ntohs (hdr->size)); | ||
937 | size = ntohs (hdr->size) + sizeof (*box); | ||
938 | break; | ||
939 | case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY: | ||
940 | if (sizeof (*rekey) > queue->pread_off) | ||
941 | return 0; | ||
942 | if (ntohs (hdr->size) != sizeof (*rekey)) | ||
943 | { | 912 | { |
944 | GNUNET_break_op (0); | 913 | case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX: |
945 | queue_finish (queue); | 914 | /* Special case: header size excludes box itself! */ |
946 | return 0; | 915 | if (ntohs(hdr->size) + sizeof(struct TCPBox) > queue->pread_off) |
947 | } | 916 | return 0; |
948 | rekeyz = *rekey; | 917 | calculate_hmac(&queue->in_hmac, &box[1], ntohs(hdr->size), &tmac); |
949 | memset (&rekeyz.hmac, 0, sizeof (rekeyz.hmac)); | 918 | if (0 != memcmp(&tmac, &box->hmac, sizeof(tmac))) |
950 | calculate_hmac (&queue->in_hmac, &rekeyz, sizeof (rekeyz), &tmac); | 919 | { |
951 | if (0 != memcmp (&tmac, &box->hmac, sizeof (tmac))) | 920 | GNUNET_break_op(0); |
952 | { | 921 | queue_finish(queue); |
953 | GNUNET_break_op (0); | 922 | return 0; |
954 | queue_finish (queue); | 923 | } |
955 | return 0; | 924 | pass_plaintext_to_core(queue, (const void *)&box[1], ntohs(hdr->size)); |
956 | } | 925 | size = ntohs(hdr->size) + sizeof(*box); |
957 | do_rekey (queue, rekey); | 926 | break; |
958 | size = ntohs (hdr->size); | 927 | |
959 | break; | 928 | case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY: |
960 | case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH: | 929 | if (sizeof(*rekey) > queue->pread_off) |
961 | if (sizeof (*fin) > queue->pread_off) | 930 | return 0; |
962 | return 0; | 931 | if (ntohs(hdr->size) != sizeof(*rekey)) |
963 | if (ntohs (hdr->size) != sizeof (*fin)) | 932 | { |
964 | { | 933 | GNUNET_break_op(0); |
965 | GNUNET_break_op (0); | 934 | queue_finish(queue); |
966 | queue_finish (queue); | 935 | return 0; |
967 | return 0; | 936 | } |
968 | } | 937 | rekeyz = *rekey; |
969 | finz = *fin; | 938 | memset(&rekeyz.hmac, 0, sizeof(rekeyz.hmac)); |
970 | memset (&finz.hmac, 0, sizeof (finz.hmac)); | 939 | calculate_hmac(&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac); |
971 | calculate_hmac (&queue->in_hmac, &rekeyz, sizeof (rekeyz), &tmac); | 940 | if (0 != memcmp(&tmac, &box->hmac, sizeof(tmac))) |
972 | if (0 != memcmp (&tmac, &fin->hmac, sizeof (tmac))) | 941 | { |
973 | { | 942 | GNUNET_break_op(0); |
974 | GNUNET_break_op (0); | 943 | queue_finish(queue); |
975 | queue_finish (queue); | 944 | return 0; |
945 | } | ||
946 | do_rekey(queue, rekey); | ||
947 | size = ntohs(hdr->size); | ||
948 | break; | ||
949 | |||
950 | case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH: | ||
951 | if (sizeof(*fin) > queue->pread_off) | ||
952 | return 0; | ||
953 | if (ntohs(hdr->size) != sizeof(*fin)) | ||
954 | { | ||
955 | GNUNET_break_op(0); | ||
956 | queue_finish(queue); | ||
957 | return 0; | ||
958 | } | ||
959 | finz = *fin; | ||
960 | memset(&finz.hmac, 0, sizeof(finz.hmac)); | ||
961 | calculate_hmac(&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac); | ||
962 | if (0 != memcmp(&tmac, &fin->hmac, sizeof(tmac))) | ||
963 | { | ||
964 | GNUNET_break_op(0); | ||
965 | queue_finish(queue); | ||
966 | return 0; | ||
967 | } | ||
968 | /* handle FINISH by destroying queue */ | ||
969 | queue_destroy(queue); | ||
970 | break; | ||
971 | |||
972 | default: | ||
973 | GNUNET_break_op(0); | ||
974 | queue_finish(queue); | ||
976 | return 0; | 975 | return 0; |
977 | } | 976 | } |
978 | /* handle FINISH by destroying queue */ | 977 | GNUNET_assert(0 != size); |
979 | queue_destroy (queue); | ||
980 | break; | ||
981 | default: | ||
982 | GNUNET_break_op (0); | ||
983 | queue_finish (queue); | ||
984 | return 0; | ||
985 | } | ||
986 | GNUNET_assert (0 != size); | ||
987 | return size; | 978 | return size; |
988 | } | 979 | } |
989 | 980 | ||
@@ -994,96 +985,96 @@ try_handle_plaintext (struct Queue *queue) | |||
994 | * @param cls the `struct Queue *` to disconnect | 985 | * @param cls the `struct Queue *` to disconnect |
995 | */ | 986 | */ |
996 | static void | 987 | static void |
997 | queue_read (void *cls) | 988 | queue_read(void *cls) |
998 | { | 989 | { |
999 | struct Queue *queue = cls; | 990 | struct Queue *queue = cls; |
1000 | struct GNUNET_TIME_Relative left; | 991 | struct GNUNET_TIME_Relative left; |
1001 | ssize_t rcvd; | 992 | ssize_t rcvd; |
1002 | 993 | ||
1003 | queue->read_task = NULL; | 994 | queue->read_task = NULL; |
1004 | rcvd = GNUNET_NETWORK_socket_recv (queue->sock, | 995 | rcvd = GNUNET_NETWORK_socket_recv(queue->sock, |
1005 | &queue->cread_buf[queue->cread_off], | 996 | &queue->cread_buf[queue->cread_off], |
1006 | BUF_SIZE - queue->cread_off); | 997 | BUF_SIZE - queue->cread_off); |
1007 | if (-1 == rcvd) | 998 | if (-1 == rcvd) |
1008 | { | ||
1009 | if ((EAGAIN != errno) && (EINTR != errno)) | ||
1010 | { | 999 | { |
1011 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv"); | 1000 | if ((EAGAIN != errno) && (EINTR != errno)) |
1012 | queue_finish (queue); | 1001 | { |
1002 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "recv"); | ||
1003 | queue_finish(queue); | ||
1004 | return; | ||
1005 | } | ||
1006 | /* try again */ | ||
1007 | queue->read_task = | ||
1008 | GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read, queue); | ||
1013 | return; | 1009 | return; |
1014 | } | 1010 | } |
1015 | /* try again */ | ||
1016 | queue->read_task = | ||
1017 | GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read, queue); | ||
1018 | return; | ||
1019 | } | ||
1020 | if (0 != rcvd) | 1011 | if (0 != rcvd) |
1021 | reschedule_queue_timeout (queue); | 1012 | reschedule_queue_timeout(queue); |
1022 | queue->cread_off += rcvd; | 1013 | queue->cread_off += rcvd; |
1023 | while ((queue->pread_off < sizeof (queue->pread_buf)) && | 1014 | while ((queue->pread_off < sizeof(queue->pread_buf)) && |
1024 | (queue->cread_off > 0)) | 1015 | (queue->cread_off > 0)) |
1025 | { | 1016 | { |
1026 | size_t max = GNUNET_MIN (sizeof (queue->pread_buf) - queue->pread_off, | 1017 | size_t max = GNUNET_MIN(sizeof(queue->pread_buf) - queue->pread_off, |
1027 | queue->cread_off); | 1018 | queue->cread_off); |
1028 | size_t done; | 1019 | size_t done; |
1029 | size_t total; | 1020 | size_t total; |
1030 | 1021 | ||
1031 | GNUNET_assert (0 == | 1022 | GNUNET_assert(0 == |
1032 | gcry_cipher_decrypt (queue->in_cipher, | 1023 | gcry_cipher_decrypt(queue->in_cipher, |
1033 | &queue->pread_buf[queue->pread_off], | 1024 | &queue->pread_buf[queue->pread_off], |
1034 | max, | 1025 | max, |
1035 | queue->cread_buf, | 1026 | queue->cread_buf, |
1036 | max)); | 1027 | max)); |
1037 | queue->pread_off += max; | 1028 | queue->pread_off += max; |
1038 | total = 0; | 1029 | total = 0; |
1039 | while ((GNUNET_NO == queue->rekeyed) && | 1030 | while ((GNUNET_NO == queue->rekeyed) && |
1040 | (0 != (done = try_handle_plaintext (queue)))) | 1031 | (0 != (done = try_handle_plaintext(queue)))) |
1041 | { | 1032 | { |
1042 | /* 'done' bytes of plaintext were used, shift buffer */ | 1033 | /* 'done' bytes of plaintext were used, shift buffer */ |
1043 | GNUNET_assert (done <= queue->pread_off); | 1034 | GNUNET_assert(done <= queue->pread_off); |
1044 | /* NOTE: this memmove() could possibly sometimes be | 1035 | /* NOTE: this memmove() could possibly sometimes be |
1045 | avoided if we pass 'total' into try_handle_plaintext() | 1036 | avoided if we pass 'total' into try_handle_plaintext() |
1046 | and use it at an offset into the buffer there! */ | 1037 | and use it at an offset into the buffer there! */ |
1047 | memmove (queue->pread_buf, | 1038 | memmove(queue->pread_buf, |
1048 | &queue->pread_buf[done], | 1039 | &queue->pread_buf[done], |
1049 | queue->pread_off - done); | 1040 | queue->pread_off - done); |
1050 | queue->pread_off -= done; | 1041 | queue->pread_off -= done; |
1051 | total += done; | 1042 | total += done; |
1052 | } | 1043 | } |
1053 | /* when we encounter a rekey message, the decryption above uses the | 1044 | /* when we encounter a rekey message, the decryption above uses the |
1054 | wrong key for everything after the rekey; in that case, we have | 1045 | wrong key for everything after the rekey; in that case, we have |
1055 | to re-do the decryption at 'total' instead of at 'max'. If there | 1046 | to re-do the decryption at 'total' instead of at 'max'. If there |
1056 | is no rekey and the last message is incomplete (max > total), | 1047 | is no rekey and the last message is incomplete (max > total), |
1057 | it is safe to keep the decryption so we shift by 'max' */ | 1048 | it is safe to keep the decryption so we shift by 'max' */ |
1058 | if (GNUNET_YES == queue->rekeyed) | 1049 | if (GNUNET_YES == queue->rekeyed) |
1059 | { | 1050 | { |
1060 | max = total; | 1051 | max = total; |
1061 | queue->rekeyed = GNUNET_NO; | 1052 | queue->rekeyed = GNUNET_NO; |
1053 | } | ||
1054 | memmove(queue->cread_buf, &queue->cread_buf[max], queue->cread_off - max); | ||
1055 | queue->cread_off -= max; | ||
1062 | } | 1056 | } |
1063 | memmove (queue->cread_buf, &queue->cread_buf[max], queue->cread_off - max); | ||
1064 | queue->cread_off -= max; | ||
1065 | } | ||
1066 | 1057 | ||
1067 | if (BUF_SIZE == queue->cread_off) | 1058 | if (BUF_SIZE == queue->cread_off) |
1068 | return; /* buffer full, suspend reading */ | 1059 | return; /* buffer full, suspend reading */ |
1069 | left = GNUNET_TIME_absolute_get_remaining (queue->timeout); | 1060 | left = GNUNET_TIME_absolute_get_remaining(queue->timeout); |
1070 | if (0 != left.rel_value_us) | 1061 | if (0 != left.rel_value_us) |
1071 | { | ||
1072 | if (max_queue_length < queue->backpressure) | ||
1073 | { | 1062 | { |
1074 | /* continue reading */ | 1063 | if (max_queue_length < queue->backpressure) |
1075 | queue->read_task = | 1064 | { |
1076 | GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read, queue); | 1065 | /* continue reading */ |
1066 | queue->read_task = | ||
1067 | GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read, queue); | ||
1068 | } | ||
1069 | return; | ||
1077 | } | 1070 | } |
1078 | return; | 1071 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
1079 | } | 1072 | "Queue %p was idle for %s, disconnecting\n", |
1080 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1073 | queue, |
1081 | "Queue %p was idle for %s, disconnecting\n", | 1074 | GNUNET_STRINGS_relative_time_to_string( |
1082 | queue, | 1075 | GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, |
1083 | GNUNET_STRINGS_relative_time_to_string ( | 1076 | GNUNET_YES)); |
1084 | GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, | 1077 | queue_finish(queue); |
1085 | GNUNET_YES)); | ||
1086 | queue_finish (queue); | ||
1087 | } | 1078 | } |
1088 | 1079 | ||
1089 | 1080 | ||
@@ -1095,7 +1086,7 @@ queue_read (void *cls) | |||
1095 | * @return converted bindto specification | 1086 | * @return converted bindto specification |
1096 | */ | 1087 | */ |
1097 | static struct sockaddr * | 1088 | static struct sockaddr * |
1098 | tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len) | 1089 | tcp_address_to_sockaddr(const char *bindto, socklen_t *sock_len) |
1099 | { | 1090 | { |
1100 | struct sockaddr *in; | 1091 | struct sockaddr *in; |
1101 | unsigned int port; | 1092 | unsigned int port; |
@@ -1103,88 +1094,88 @@ tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len) | |||
1103 | char *colon; | 1094 | char *colon; |
1104 | char *cp; | 1095 | char *cp; |
1105 | 1096 | ||
1106 | if (1 == sscanf (bindto, "%u%1s", &port, dummy)) | 1097 | if (1 == sscanf(bindto, "%u%1s", &port, dummy)) |
1107 | { | ||
1108 | /* interpreting value as just a PORT number */ | ||
1109 | if (port > UINT16_MAX) | ||
1110 | { | ||
1111 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1112 | "BINDTO specification `%s' invalid: value too large for port\n", | ||
1113 | bindto); | ||
1114 | return NULL; | ||
1115 | } | ||
1116 | if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) || | ||
1117 | (GNUNET_YES == | ||
1118 | GNUNET_CONFIGURATION_get_value_yesno (cfg, | ||
1119 | COMMUNICATOR_CONFIG_SECTION, | ||
1120 | "DISABLE_V6"))) | ||
1121 | { | ||
1122 | struct sockaddr_in *i4; | ||
1123 | |||
1124 | i4 = GNUNET_malloc (sizeof (struct sockaddr_in)); | ||
1125 | i4->sin_family = AF_INET; | ||
1126 | i4->sin_port = htons ((uint16_t) port); | ||
1127 | *sock_len = sizeof (struct sockaddr_in); | ||
1128 | in = (struct sockaddr *) i4; | ||
1129 | } | ||
1130 | else | ||
1131 | { | ||
1132 | struct sockaddr_in6 *i6; | ||
1133 | |||
1134 | i6 = GNUNET_malloc (sizeof (struct sockaddr_in6)); | ||
1135 | i6->sin6_family = AF_INET6; | ||
1136 | i6->sin6_port = htons ((uint16_t) port); | ||
1137 | *sock_len = sizeof (struct sockaddr_in6); | ||
1138 | in = (struct sockaddr *) i6; | ||
1139 | } | ||
1140 | return in; | ||
1141 | } | ||
1142 | cp = GNUNET_strdup (bindto); | ||
1143 | colon = strrchr (cp, ':'); | ||
1144 | if (NULL != colon) | ||
1145 | { | ||
1146 | /* interpet value after colon as port */ | ||
1147 | *colon = '\0'; | ||
1148 | colon++; | ||
1149 | if (1 == sscanf (colon, "%u%1s", &port, dummy)) | ||
1150 | { | 1098 | { |
1151 | /* interpreting value as just a PORT number */ | 1099 | /* interpreting value as just a PORT number */ |
1152 | if (port > UINT16_MAX) | 1100 | if (port > UINT16_MAX) |
1153 | { | 1101 | { |
1154 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1102 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
1155 | "BINDTO specification `%s' invalid: value too large for port\n", | 1103 | "BINDTO specification `%s' invalid: value too large for port\n", |
1156 | bindto); | 1104 | bindto); |
1157 | GNUNET_free (cp); | 1105 | return NULL; |
1158 | return NULL; | 1106 | } |
1159 | } | 1107 | if ((GNUNET_NO == GNUNET_NETWORK_test_pf(PF_INET6)) || |
1108 | (GNUNET_YES == | ||
1109 | GNUNET_CONFIGURATION_get_value_yesno(cfg, | ||
1110 | COMMUNICATOR_CONFIG_SECTION, | ||
1111 | "DISABLE_V6"))) | ||
1112 | { | ||
1113 | struct sockaddr_in *i4; | ||
1114 | |||
1115 | i4 = GNUNET_malloc(sizeof(struct sockaddr_in)); | ||
1116 | i4->sin_family = AF_INET; | ||
1117 | i4->sin_port = htons((uint16_t)port); | ||
1118 | *sock_len = sizeof(struct sockaddr_in); | ||
1119 | in = (struct sockaddr *)i4; | ||
1120 | } | ||
1121 | else | ||
1122 | { | ||
1123 | struct sockaddr_in6 *i6; | ||
1124 | |||
1125 | i6 = GNUNET_malloc(sizeof(struct sockaddr_in6)); | ||
1126 | i6->sin6_family = AF_INET6; | ||
1127 | i6->sin6_port = htons((uint16_t)port); | ||
1128 | *sock_len = sizeof(struct sockaddr_in6); | ||
1129 | in = (struct sockaddr *)i6; | ||
1130 | } | ||
1131 | return in; | ||
1160 | } | 1132 | } |
1161 | else | 1133 | cp = GNUNET_strdup(bindto); |
1134 | colon = strrchr(cp, ':'); | ||
1135 | if (NULL != colon) | ||
1162 | { | 1136 | { |
1163 | GNUNET_log ( | 1137 | /* interpet value after colon as port */ |
1164 | GNUNET_ERROR_TYPE_ERROR, | 1138 | *colon = '\0'; |
1165 | "BINDTO specification `%s' invalid: last ':' not followed by number\n", | 1139 | colon++; |
1166 | bindto); | 1140 | if (1 == sscanf(colon, "%u%1s", &port, dummy)) |
1167 | GNUNET_free (cp); | 1141 | { |
1168 | return NULL; | 1142 | /* interpreting value as just a PORT number */ |
1143 | if (port > UINT16_MAX) | ||
1144 | { | ||
1145 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
1146 | "BINDTO specification `%s' invalid: value too large for port\n", | ||
1147 | bindto); | ||
1148 | GNUNET_free(cp); | ||
1149 | return NULL; | ||
1150 | } | ||
1151 | } | ||
1152 | else | ||
1153 | { | ||
1154 | GNUNET_log( | ||
1155 | GNUNET_ERROR_TYPE_ERROR, | ||
1156 | "BINDTO specification `%s' invalid: last ':' not followed by number\n", | ||
1157 | bindto); | ||
1158 | GNUNET_free(cp); | ||
1159 | return NULL; | ||
1160 | } | ||
1169 | } | 1161 | } |
1170 | } | ||
1171 | else | 1162 | else |
1172 | { | 1163 | { |
1173 | /* interpret missing port as 0, aka pick any free one */ | 1164 | /* interpret missing port as 0, aka pick any free one */ |
1174 | port = 0; | 1165 | port = 0; |
1175 | } | 1166 | } |
1176 | { | 1167 | { |
1177 | /* try IPv4 */ | 1168 | /* try IPv4 */ |
1178 | struct sockaddr_in v4; | 1169 | struct sockaddr_in v4; |
1179 | 1170 | ||
1180 | if (1 == inet_pton (AF_INET, cp, &v4)) | 1171 | if (1 == inet_pton(AF_INET, cp, &v4)) |
1181 | { | 1172 | { |
1182 | v4.sin_port = htons ((uint16_t) port); | 1173 | v4.sin_port = htons((uint16_t)port); |
1183 | in = GNUNET_memdup (&v4, sizeof (v4)); | 1174 | in = GNUNET_memdup(&v4, sizeof(v4)); |
1184 | *sock_len = sizeof (v4); | 1175 | *sock_len = sizeof(v4); |
1185 | GNUNET_free (cp); | 1176 | GNUNET_free(cp); |
1186 | return in; | 1177 | return in; |
1187 | } | 1178 | } |
1188 | } | 1179 | } |
1189 | { | 1180 | { |
1190 | /* try IPv6 */ | 1181 | /* try IPv6 */ |
@@ -1192,22 +1183,22 @@ tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len) | |||
1192 | const char *start; | 1183 | const char *start; |
1193 | 1184 | ||
1194 | start = cp; | 1185 | start = cp; |
1195 | if (('[' == *cp) && (']' == cp[strlen (cp) - 1])) | 1186 | if (('[' == *cp) && (']' == cp[strlen(cp) - 1])) |
1196 | { | 1187 | { |
1197 | start++; /* skip over '[' */ | 1188 | start++; /* skip over '[' */ |
1198 | cp[strlen (cp) - 1] = '\0'; /* eat ']' */ | 1189 | cp[strlen(cp) - 1] = '\0'; /* eat ']' */ |
1199 | } | 1190 | } |
1200 | if (1 == inet_pton (AF_INET6, start, &v6)) | 1191 | if (1 == inet_pton(AF_INET6, start, &v6)) |
1201 | { | 1192 | { |
1202 | v6.sin6_port = htons ((uint16_t) port); | 1193 | v6.sin6_port = htons((uint16_t)port); |
1203 | in = GNUNET_memdup (&v6, sizeof (v6)); | 1194 | in = GNUNET_memdup(&v6, sizeof(v6)); |
1204 | *sock_len = sizeof (v6); | 1195 | *sock_len = sizeof(v6); |
1205 | GNUNET_free (cp); | 1196 | GNUNET_free(cp); |
1206 | return in; | 1197 | return in; |
1207 | } | 1198 | } |
1208 | } | 1199 | } |
1209 | /* #5528 FIXME (feature!): maybe also try getnameinfo()? */ | 1200 | /* #5528 FIXME (feature!): maybe also try getnameinfo()? */ |
1210 | GNUNET_free (cp); | 1201 | GNUNET_free(cp); |
1211 | return NULL; | 1202 | return NULL; |
1212 | } | 1203 | } |
1213 | 1204 | ||
@@ -1219,17 +1210,17 @@ tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len) | |||
1219 | * @param queue queue to setup outgoing (encryption) cipher for | 1210 | * @param queue queue to setup outgoing (encryption) cipher for |
1220 | */ | 1211 | */ |
1221 | static void | 1212 | static void |
1222 | setup_out_cipher (struct Queue *queue) | 1213 | setup_out_cipher(struct Queue *queue) |
1223 | { | 1214 | { |
1224 | struct GNUNET_HashCode dh; | 1215 | struct GNUNET_HashCode dh; |
1225 | 1216 | ||
1226 | GNUNET_CRYPTO_ecdh_eddsa (&queue->ephemeral, &queue->target.public_key, &dh); | 1217 | GNUNET_CRYPTO_ecdh_eddsa(&queue->ephemeral, &queue->target.public_key, &dh); |
1227 | /* we don't need the private key anymore, drop it! */ | 1218 | /* we don't need the private key anymore, drop it! */ |
1228 | memset (&queue->ephemeral, 0, sizeof (queue->ephemeral)); | 1219 | memset(&queue->ephemeral, 0, sizeof(queue->ephemeral)); |
1229 | setup_cipher (&dh, &queue->target, &queue->out_cipher, &queue->out_hmac); | 1220 | setup_cipher(&dh, &queue->target, &queue->out_cipher, &queue->out_hmac); |
1230 | queue->rekey_time = GNUNET_TIME_relative_to_absolute (REKEY_TIME_INTERVAL); | 1221 | queue->rekey_time = GNUNET_TIME_relative_to_absolute(REKEY_TIME_INTERVAL); |
1231 | queue->rekey_left_bytes = | 1222 | queue->rekey_left_bytes = |
1232 | GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, REKEY_MAX_BYTES); | 1223 | GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK, REKEY_MAX_BYTES); |
1233 | } | 1224 | } |
1234 | 1225 | ||
1235 | 1226 | ||
@@ -1240,32 +1231,32 @@ setup_out_cipher (struct Queue *queue) | |||
1240 | * @param queue queue to perform rekeying on | 1231 | * @param queue queue to perform rekeying on |
1241 | */ | 1232 | */ |
1242 | static void | 1233 | static void |
1243 | inject_rekey (struct Queue *queue) | 1234 | inject_rekey(struct Queue *queue) |
1244 | { | 1235 | { |
1245 | struct TCPRekey rekey; | 1236 | struct TCPRekey rekey; |
1246 | struct TcpHandshakeSignature thp; | 1237 | struct TcpHandshakeSignature thp; |
1247 | 1238 | ||
1248 | GNUNET_assert (0 == queue->pwrite_off); | 1239 | GNUNET_assert(0 == queue->pwrite_off); |
1249 | memset (&rekey, 0, sizeof (rekey)); | 1240 | memset(&rekey, 0, sizeof(rekey)); |
1250 | GNUNET_assert (GNUNET_OK == | 1241 | GNUNET_assert(GNUNET_OK == |
1251 | GNUNET_CRYPTO_ecdhe_key_create2 (&queue->ephemeral)); | 1242 | GNUNET_CRYPTO_ecdhe_key_create2(&queue->ephemeral)); |
1252 | rekey.header.type = ntohs (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY); | 1243 | rekey.header.type = ntohs(GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY); |
1253 | rekey.header.size = ntohs (sizeof (rekey)); | 1244 | rekey.header.size = ntohs(sizeof(rekey)); |
1254 | GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &rekey.ephemeral); | 1245 | GNUNET_CRYPTO_ecdhe_key_get_public(&queue->ephemeral, &rekey.ephemeral); |
1255 | rekey.monotonic_time = | 1246 | rekey.monotonic_time = |
1256 | GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg)); | 1247 | GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get_monotonic(cfg)); |
1257 | thp.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY); | 1248 | thp.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY); |
1258 | thp.purpose.size = htonl (sizeof (thp)); | 1249 | thp.purpose.size = htonl(sizeof(thp)); |
1259 | thp.sender = my_identity; | 1250 | thp.sender = my_identity; |
1260 | thp.receiver = queue->target; | 1251 | thp.receiver = queue->target; |
1261 | thp.ephemeral = rekey.ephemeral; | 1252 | thp.ephemeral = rekey.ephemeral; |
1262 | thp.monotonic_time = rekey.monotonic_time; | 1253 | thp.monotonic_time = rekey.monotonic_time; |
1263 | GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key, | 1254 | GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key, |
1264 | &thp.purpose, | 1255 | &thp.purpose, |
1265 | &rekey.sender_sig)); | 1256 | &rekey.sender_sig)); |
1266 | calculate_hmac (&queue->out_hmac, &rekey, sizeof (rekey), &rekey.hmac); | 1257 | calculate_hmac(&queue->out_hmac, &rekey, sizeof(rekey), &rekey.hmac); |
1267 | memcpy (queue->pwrite_buf, &rekey, sizeof (rekey)); | 1258 | memcpy(queue->pwrite_buf, &rekey, sizeof(rekey)); |
1268 | queue->pwrite_off = sizeof (rekey); | 1259 | queue->pwrite_off = sizeof(rekey); |
1269 | } | 1260 | } |
1270 | 1261 | ||
1271 | 1262 | ||
@@ -1276,79 +1267,79 @@ inject_rekey (struct Queue *queue) | |||
1276 | * @param cls a `struct Queue` | 1267 | * @param cls a `struct Queue` |
1277 | */ | 1268 | */ |
1278 | static void | 1269 | static void |
1279 | queue_write (void *cls) | 1270 | queue_write(void *cls) |
1280 | { | 1271 | { |
1281 | struct Queue *queue = cls; | 1272 | struct Queue *queue = cls; |
1282 | ssize_t sent; | 1273 | ssize_t sent; |
1283 | 1274 | ||
1284 | queue->write_task = NULL; | 1275 | queue->write_task = NULL; |
1285 | if (0 != queue->cwrite_off) | 1276 | if (0 != queue->cwrite_off) |
1286 | { | ||
1287 | sent = GNUNET_NETWORK_socket_send (queue->sock, | ||
1288 | queue->cwrite_buf, | ||
1289 | queue->cwrite_off); | ||
1290 | if ((-1 == sent) && (EAGAIN != errno) && (EINTR != errno)) | ||
1291 | { | 1277 | { |
1292 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); | 1278 | sent = GNUNET_NETWORK_socket_send(queue->sock, |
1293 | queue_destroy (queue); | 1279 | queue->cwrite_buf, |
1294 | return; | 1280 | queue->cwrite_off); |
1281 | if ((-1 == sent) && (EAGAIN != errno) && (EINTR != errno)) | ||
1282 | { | ||
1283 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "send"); | ||
1284 | queue_destroy(queue); | ||
1285 | return; | ||
1286 | } | ||
1287 | if (sent > 0) | ||
1288 | { | ||
1289 | size_t usent = (size_t)sent; | ||
1290 | |||
1291 | memmove(queue->cwrite_buf, | ||
1292 | &queue->cwrite_buf[usent], | ||
1293 | queue->cwrite_off - usent); | ||
1294 | reschedule_queue_timeout(queue); | ||
1295 | } | ||
1295 | } | 1296 | } |
1296 | if (sent > 0) | ||
1297 | { | ||
1298 | size_t usent = (size_t) sent; | ||
1299 | |||
1300 | memmove (queue->cwrite_buf, | ||
1301 | &queue->cwrite_buf[usent], | ||
1302 | queue->cwrite_off - usent); | ||
1303 | reschedule_queue_timeout (queue); | ||
1304 | } | ||
1305 | } | ||
1306 | /* can we encrypt more? (always encrypt full messages, needed | 1297 | /* can we encrypt more? (always encrypt full messages, needed |
1307 | such that #mq_cancel() can work!) */ | 1298 | such that #mq_cancel() can work!) */ |
1308 | if ((0 < queue->rekey_left_bytes) && | 1299 | if ((0 < queue->rekey_left_bytes) && |
1309 | (queue->cwrite_off + queue->pwrite_off <= BUF_SIZE)) | 1300 | (queue->cwrite_off + queue->pwrite_off <= BUF_SIZE)) |
1310 | { | 1301 | { |
1311 | GNUNET_assert (0 == | 1302 | GNUNET_assert(0 == |
1312 | gcry_cipher_encrypt (queue->out_cipher, | 1303 | gcry_cipher_encrypt(queue->out_cipher, |
1313 | &queue->cwrite_buf[queue->cwrite_off], | 1304 | &queue->cwrite_buf[queue->cwrite_off], |
1314 | queue->pwrite_off, | 1305 | queue->pwrite_off, |
1315 | queue->pwrite_buf, | 1306 | queue->pwrite_buf, |
1316 | queue->pwrite_off)); | 1307 | queue->pwrite_off)); |
1317 | if (queue->rekey_left_bytes > queue->pwrite_off) | 1308 | if (queue->rekey_left_bytes > queue->pwrite_off) |
1318 | queue->rekey_left_bytes -= queue->pwrite_off; | 1309 | queue->rekey_left_bytes -= queue->pwrite_off; |
1319 | else | 1310 | else |
1320 | queue->rekey_left_bytes = 0; | 1311 | queue->rekey_left_bytes = 0; |
1321 | queue->cwrite_off += queue->pwrite_off; | 1312 | queue->cwrite_off += queue->pwrite_off; |
1322 | queue->pwrite_off = 0; | 1313 | queue->pwrite_off = 0; |
1323 | } | 1314 | } |
1324 | if ((0 == queue->pwrite_off) && | 1315 | if ((0 == queue->pwrite_off) && |
1325 | ((0 == queue->rekey_left_bytes) || | 1316 | ((0 == queue->rekey_left_bytes) || |
1326 | (0 == | 1317 | (0 == |
1327 | GNUNET_TIME_absolute_get_remaining (queue->rekey_time).rel_value_us))) | 1318 | GNUNET_TIME_absolute_get_remaining(queue->rekey_time).rel_value_us))) |
1328 | { | 1319 | { |
1329 | gcry_cipher_close (queue->out_cipher); | 1320 | gcry_cipher_close(queue->out_cipher); |
1330 | setup_out_cipher (queue); | 1321 | setup_out_cipher(queue); |
1331 | inject_rekey (queue); | 1322 | inject_rekey(queue); |
1332 | } | 1323 | } |
1333 | if ((0 == queue->pwrite_off) && (! queue->finishing) && | 1324 | if ((0 == queue->pwrite_off) && (!queue->finishing) && |
1334 | (queue->mq_awaits_continue)) | 1325 | (queue->mq_awaits_continue)) |
1335 | { | 1326 | { |
1336 | queue->mq_awaits_continue = GNUNET_NO; | 1327 | queue->mq_awaits_continue = GNUNET_NO; |
1337 | GNUNET_MQ_impl_send_continue (queue->mq); | 1328 | GNUNET_MQ_impl_send_continue(queue->mq); |
1338 | } | 1329 | } |
1339 | /* did we just finish writing 'finish'? */ | 1330 | /* did we just finish writing 'finish'? */ |
1340 | if ((0 == queue->cwrite_off) && (GNUNET_YES == queue->finishing)) | 1331 | if ((0 == queue->cwrite_off) && (GNUNET_YES == queue->finishing)) |
1341 | { | 1332 | { |
1342 | queue_destroy (queue); | 1333 | queue_destroy(queue); |
1343 | return; | 1334 | return; |
1344 | } | 1335 | } |
1345 | /* do we care to write more? */ | 1336 | /* do we care to write more? */ |
1346 | if ((0 < queue->cwrite_off) || (0 < queue->pwrite_off)) | 1337 | if ((0 < queue->cwrite_off) || (0 < queue->pwrite_off)) |
1347 | queue->write_task = | 1338 | queue->write_task = |
1348 | GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, | 1339 | GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, |
1349 | queue->sock, | 1340 | queue->sock, |
1350 | &queue_write, | 1341 | &queue_write, |
1351 | queue); | 1342 | queue); |
1352 | } | 1343 | } |
1353 | 1344 | ||
1354 | 1345 | ||
@@ -1361,32 +1352,32 @@ queue_write (void *cls) | |||
1361 | * @param impl_state our `struct Queue` | 1352 | * @param impl_state our `struct Queue` |
1362 | */ | 1353 | */ |
1363 | static void | 1354 | static void |
1364 | mq_send (struct GNUNET_MQ_Handle *mq, | 1355 | mq_send(struct GNUNET_MQ_Handle *mq, |
1365 | const struct GNUNET_MessageHeader *msg, | 1356 | const struct GNUNET_MessageHeader *msg, |
1366 | void *impl_state) | 1357 | void *impl_state) |
1367 | { | 1358 | { |
1368 | struct Queue *queue = impl_state; | 1359 | struct Queue *queue = impl_state; |
1369 | uint16_t msize = ntohs (msg->size); | 1360 | uint16_t msize = ntohs(msg->size); |
1370 | struct TCPBox box; | 1361 | struct TCPBox box; |
1371 | 1362 | ||
1372 | GNUNET_assert (mq == queue->mq); | 1363 | GNUNET_assert(mq == queue->mq); |
1373 | if (GNUNET_YES == queue->finishing) | 1364 | if (GNUNET_YES == queue->finishing) |
1374 | return; /* this queue is dying, drop msg */ | 1365 | return; /* this queue is dying, drop msg */ |
1375 | GNUNET_assert (0 == queue->pread_off); | 1366 | GNUNET_assert(0 == queue->pread_off); |
1376 | box.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX); | 1367 | box.header.type = htons(GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX); |
1377 | box.header.size = htons (msize); | 1368 | box.header.size = htons(msize); |
1378 | calculate_hmac (&queue->out_hmac, msg, msize, &box.hmac); | 1369 | calculate_hmac(&queue->out_hmac, msg, msize, &box.hmac); |
1379 | memcpy (&queue->pread_buf[queue->pread_off], &box, sizeof (box)); | 1370 | memcpy(&queue->pread_buf[queue->pread_off], &box, sizeof(box)); |
1380 | queue->pread_off += sizeof (box); | 1371 | queue->pread_off += sizeof(box); |
1381 | memcpy (&queue->pread_buf[queue->pread_off], msg, msize); | 1372 | memcpy(&queue->pread_buf[queue->pread_off], msg, msize); |
1382 | queue->pread_off += msize; | 1373 | queue->pread_off += msize; |
1383 | GNUNET_assert (NULL != queue->sock); | 1374 | GNUNET_assert(NULL != queue->sock); |
1384 | if (NULL == queue->write_task) | 1375 | if (NULL == queue->write_task) |
1385 | queue->write_task = | 1376 | queue->write_task = |
1386 | GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, | 1377 | GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, |
1387 | queue->sock, | 1378 | queue->sock, |
1388 | &queue_write, | 1379 | &queue_write, |
1389 | queue); | 1380 | queue); |
1390 | } | 1381 | } |
1391 | 1382 | ||
1392 | 1383 | ||
@@ -1399,15 +1390,15 @@ mq_send (struct GNUNET_MQ_Handle *mq, | |||
1399 | * @param impl_state our `struct Queue` | 1390 | * @param impl_state our `struct Queue` |
1400 | */ | 1391 | */ |
1401 | static void | 1392 | static void |
1402 | mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state) | 1393 | mq_destroy(struct GNUNET_MQ_Handle *mq, void *impl_state) |
1403 | { | 1394 | { |
1404 | struct Queue *queue = impl_state; | 1395 | struct Queue *queue = impl_state; |
1405 | 1396 | ||
1406 | if (mq == queue->mq) | 1397 | if (mq == queue->mq) |
1407 | { | 1398 | { |
1408 | queue->mq = NULL; | 1399 | queue->mq = NULL; |
1409 | queue_finish (queue); | 1400 | queue_finish(queue); |
1410 | } | 1401 | } |
1411 | } | 1402 | } |
1412 | 1403 | ||
1413 | 1404 | ||
@@ -1418,11 +1409,11 @@ mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state) | |||
1418 | * @param impl_state our `struct Queue` | 1409 | * @param impl_state our `struct Queue` |
1419 | */ | 1410 | */ |
1420 | static void | 1411 | static void |
1421 | mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state) | 1412 | mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state) |
1422 | { | 1413 | { |
1423 | struct Queue *queue = impl_state; | 1414 | struct Queue *queue = impl_state; |
1424 | 1415 | ||
1425 | GNUNET_assert (0 != queue->pwrite_off); | 1416 | GNUNET_assert(0 != queue->pwrite_off); |
1426 | queue->pwrite_off = 0; | 1417 | queue->pwrite_off = 0; |
1427 | } | 1418 | } |
1428 | 1419 | ||
@@ -1437,15 +1428,15 @@ mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state) | |||
1437 | * @param error error code | 1428 | * @param error error code |
1438 | */ | 1429 | */ |
1439 | static void | 1430 | static void |
1440 | mq_error (void *cls, enum GNUNET_MQ_Error error) | 1431 | mq_error(void *cls, enum GNUNET_MQ_Error error) |
1441 | { | 1432 | { |
1442 | struct Queue *queue = cls; | 1433 | struct Queue *queue = cls; |
1443 | 1434 | ||
1444 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1435 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
1445 | "MQ error in queue to %s: %d\n", | 1436 | "MQ error in queue to %s: %d\n", |
1446 | GNUNET_i2s (&queue->target), | 1437 | GNUNET_i2s(&queue->target), |
1447 | (int) error); | 1438 | (int)error); |
1448 | queue_finish (queue); | 1439 | queue_finish(queue); |
1449 | } | 1440 | } |
1450 | 1441 | ||
1451 | 1442 | ||
@@ -1457,56 +1448,58 @@ mq_error (void *cls, enum GNUNET_MQ_Error error) | |||
1457 | * @param queue queue to boot | 1448 | * @param queue queue to boot |
1458 | */ | 1449 | */ |
1459 | static void | 1450 | static void |
1460 | boot_queue (struct Queue *queue, enum GNUNET_TRANSPORT_ConnectionStatus cs) | 1451 | boot_queue(struct Queue *queue, enum GNUNET_TRANSPORT_ConnectionStatus cs) |
1461 | { | 1452 | { |
1462 | queue->nt = | 1453 | queue->nt = |
1463 | GNUNET_NT_scanner_get_type (is, queue->address, queue->address_len); | 1454 | GNUNET_NT_scanner_get_type(is, queue->address, queue->address_len); |
1464 | (void) GNUNET_CONTAINER_multipeermap_put ( | 1455 | (void)GNUNET_CONTAINER_multipeermap_put( |
1465 | queue_map, | 1456 | queue_map, |
1466 | &queue->target, | 1457 | &queue->target, |
1467 | queue, | 1458 | queue, |
1468 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); | 1459 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); |
1469 | GNUNET_STATISTICS_set (stats, | 1460 | GNUNET_STATISTICS_set(stats, |
1470 | "# queues active", | 1461 | "# queues active", |
1471 | GNUNET_CONTAINER_multipeermap_size (queue_map), | 1462 | GNUNET_CONTAINER_multipeermap_size(queue_map), |
1472 | GNUNET_NO); | 1463 | GNUNET_NO); |
1473 | queue->timeout = | 1464 | queue->timeout = |
1474 | GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); | 1465 | GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); |
1475 | queue->mq = GNUNET_MQ_queue_for_callbacks (&mq_send, | 1466 | queue->mq = GNUNET_MQ_queue_for_callbacks(&mq_send, |
1476 | &mq_destroy, | 1467 | &mq_destroy, |
1477 | &mq_cancel, | 1468 | &mq_cancel, |
1478 | queue, | 1469 | queue, |
1479 | NULL, | 1470 | NULL, |
1480 | &mq_error, | 1471 | &mq_error, |
1481 | queue); | 1472 | queue); |
1482 | { | 1473 | { |
1483 | char *foreign_addr; | 1474 | char *foreign_addr; |
1484 | 1475 | ||
1485 | switch (queue->address->sa_family) | 1476 | switch (queue->address->sa_family) |
1486 | { | 1477 | { |
1487 | case AF_INET: | 1478 | case AF_INET: |
1488 | GNUNET_asprintf (&foreign_addr, | 1479 | GNUNET_asprintf(&foreign_addr, |
1489 | "%s-%s", | 1480 | "%s-%s", |
1490 | COMMUNICATOR_ADDRESS_PREFIX, | 1481 | COMMUNICATOR_ADDRESS_PREFIX, |
1491 | GNUNET_a2s (queue->address, queue->address_len)); | 1482 | GNUNET_a2s(queue->address, queue->address_len)); |
1492 | break; | 1483 | break; |
1493 | case AF_INET6: | 1484 | |
1494 | GNUNET_asprintf (&foreign_addr, | 1485 | case AF_INET6: |
1495 | "%s-%s", | 1486 | GNUNET_asprintf(&foreign_addr, |
1496 | COMMUNICATOR_ADDRESS_PREFIX, | 1487 | "%s-%s", |
1497 | GNUNET_a2s (queue->address, queue->address_len)); | 1488 | COMMUNICATOR_ADDRESS_PREFIX, |
1498 | break; | 1489 | GNUNET_a2s(queue->address, queue->address_len)); |
1499 | default: | 1490 | break; |
1500 | GNUNET_assert (0); | 1491 | |
1501 | } | 1492 | default: |
1502 | queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch, | 1493 | GNUNET_assert(0); |
1503 | &queue->target, | 1494 | } |
1504 | foreign_addr, | 1495 | queue->qh = GNUNET_TRANSPORT_communicator_mq_add(ch, |
1505 | 0 /* no MTU */, | 1496 | &queue->target, |
1506 | queue->nt, | 1497 | foreign_addr, |
1507 | cs, | 1498 | 0 /* no MTU */, |
1508 | queue->mq); | 1499 | queue->nt, |
1509 | GNUNET_free (foreign_addr); | 1500 | cs, |
1501 | queue->mq); | ||
1502 | GNUNET_free(foreign_addr); | ||
1510 | } | 1503 | } |
1511 | } | 1504 | } |
1512 | 1505 | ||
@@ -1522,34 +1515,34 @@ boot_queue (struct Queue *queue, enum GNUNET_TRANSPORT_ConnectionStatus cs) | |||
1522 | * @param epub our public key for the KX | 1515 | * @param epub our public key for the KX |
1523 | */ | 1516 | */ |
1524 | static void | 1517 | static void |
1525 | transmit_kx (struct Queue *queue, | 1518 | transmit_kx(struct Queue *queue, |
1526 | const struct GNUNET_CRYPTO_EcdhePublicKey *epub) | 1519 | const struct GNUNET_CRYPTO_EcdhePublicKey *epub) |
1527 | { | 1520 | { |
1528 | struct TcpHandshakeSignature ths; | 1521 | struct TcpHandshakeSignature ths; |
1529 | struct TCPConfirmation tc; | 1522 | struct TCPConfirmation tc; |
1530 | 1523 | ||
1531 | memcpy (queue->cwrite_buf, epub, sizeof (*epub)); | 1524 | memcpy(queue->cwrite_buf, epub, sizeof(*epub)); |
1532 | queue->cwrite_off = sizeof (epub); | 1525 | queue->cwrite_off = sizeof(epub); |
1533 | /* compute 'tc' and append in encrypted format to cwrite_buf */ | 1526 | /* compute 'tc' and append in encrypted format to cwrite_buf */ |
1534 | tc.sender = my_identity; | 1527 | tc.sender = my_identity; |
1535 | tc.monotonic_time = | 1528 | tc.monotonic_time = |
1536 | GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg)); | 1529 | GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get_monotonic(cfg)); |
1537 | ths.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE); | 1530 | ths.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE); |
1538 | ths.purpose.size = htonl (sizeof (ths)); | 1531 | ths.purpose.size = htonl(sizeof(ths)); |
1539 | ths.sender = my_identity; | 1532 | ths.sender = my_identity; |
1540 | ths.receiver = queue->target; | 1533 | ths.receiver = queue->target; |
1541 | ths.ephemeral = *epub; | 1534 | ths.ephemeral = *epub; |
1542 | ths.monotonic_time = tc.monotonic_time; | 1535 | ths.monotonic_time = tc.monotonic_time; |
1543 | GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key, | 1536 | GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key, |
1544 | &ths.purpose, | 1537 | &ths.purpose, |
1545 | &tc.sender_sig)); | 1538 | &tc.sender_sig)); |
1546 | GNUNET_assert (0 == | 1539 | GNUNET_assert(0 == |
1547 | gcry_cipher_encrypt (queue->out_cipher, | 1540 | gcry_cipher_encrypt(queue->out_cipher, |
1548 | &queue->cwrite_buf[queue->cwrite_off], | 1541 | &queue->cwrite_buf[queue->cwrite_off], |
1549 | sizeof (tc), | 1542 | sizeof(tc), |
1550 | &tc, | 1543 | &tc, |
1551 | sizeof (tc))); | 1544 | sizeof(tc))); |
1552 | queue->cwrite_off += sizeof (tc); | 1545 | queue->cwrite_off += sizeof(tc); |
1553 | } | 1546 | } |
1554 | 1547 | ||
1555 | 1548 | ||
@@ -1561,15 +1554,15 @@ transmit_kx (struct Queue *queue, | |||
1561 | * @param queue the queue to setup | 1554 | * @param queue the queue to setup |
1562 | */ | 1555 | */ |
1563 | static void | 1556 | static void |
1564 | start_initial_kx_out (struct Queue *queue) | 1557 | start_initial_kx_out(struct Queue *queue) |
1565 | { | 1558 | { |
1566 | struct GNUNET_CRYPTO_EcdhePublicKey epub; | 1559 | struct GNUNET_CRYPTO_EcdhePublicKey epub; |
1567 | 1560 | ||
1568 | GNUNET_assert (GNUNET_OK == | 1561 | GNUNET_assert(GNUNET_OK == |
1569 | GNUNET_CRYPTO_ecdhe_key_create2 (&queue->ephemeral)); | 1562 | GNUNET_CRYPTO_ecdhe_key_create2(&queue->ephemeral)); |
1570 | GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &epub); | 1563 | GNUNET_CRYPTO_ecdhe_key_get_public(&queue->ephemeral, &epub); |
1571 | setup_out_cipher (queue); | 1564 | setup_out_cipher(queue); |
1572 | transmit_kx (queue, &epub); | 1565 | transmit_kx(queue, &epub); |
1573 | } | 1566 | } |
1574 | 1567 | ||
1575 | 1568 | ||
@@ -1585,31 +1578,31 @@ start_initial_kx_out (struct Queue *queue) | |||
1585 | * @return #GNUNET_OK if the signature was OK, #GNUNET_SYSERR if not | 1578 | * @return #GNUNET_OK if the signature was OK, #GNUNET_SYSERR if not |
1586 | */ | 1579 | */ |
1587 | static int | 1580 | static int |
1588 | decrypt_and_check_tc (struct Queue *queue, | 1581 | decrypt_and_check_tc(struct Queue *queue, |
1589 | struct TCPConfirmation *tc, | 1582 | struct TCPConfirmation *tc, |
1590 | char *ibuf) | 1583 | char *ibuf) |
1591 | { | 1584 | { |
1592 | struct TcpHandshakeSignature ths; | 1585 | struct TcpHandshakeSignature ths; |
1593 | 1586 | ||
1594 | GNUNET_assert ( | 1587 | GNUNET_assert( |
1595 | 0 == | 1588 | 0 == |
1596 | gcry_cipher_decrypt (queue->in_cipher, | 1589 | gcry_cipher_decrypt(queue->in_cipher, |
1597 | tc, | 1590 | tc, |
1598 | sizeof (*tc), | 1591 | sizeof(*tc), |
1599 | &ibuf[sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)], | 1592 | &ibuf[sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)], |
1600 | sizeof (tc))); | 1593 | sizeof(tc))); |
1601 | ths.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE); | 1594 | ths.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE); |
1602 | ths.purpose.size = htonl (sizeof (ths)); | 1595 | ths.purpose.size = htonl(sizeof(ths)); |
1603 | ths.sender = tc->sender; | 1596 | ths.sender = tc->sender; |
1604 | ths.receiver = my_identity; | 1597 | ths.receiver = my_identity; |
1605 | memcpy (&ths.ephemeral, ibuf, sizeof (struct GNUNET_CRYPTO_EcdhePublicKey)); | 1598 | memcpy(&ths.ephemeral, ibuf, sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)); |
1606 | ths.monotonic_time = tc->monotonic_time; | 1599 | ths.monotonic_time = tc->monotonic_time; |
1607 | /* FIXME: check monotonic time against previous mono times | 1600 | /* FIXME: check monotonic time against previous mono times |
1608 | from this sender! */ | 1601 | from this sender! */ |
1609 | return GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE, | 1602 | return GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE, |
1610 | &ths.purpose, | 1603 | &ths.purpose, |
1611 | &tc->sender_sig, | 1604 | &tc->sender_sig, |
1612 | &tc->sender.public_key); | 1605 | &tc->sender.public_key); |
1613 | } | 1606 | } |
1614 | 1607 | ||
1615 | 1608 | ||
@@ -1619,12 +1612,12 @@ decrypt_and_check_tc (struct Queue *queue, | |||
1619 | * @param pq proto queue to free | 1612 | * @param pq proto queue to free |
1620 | */ | 1613 | */ |
1621 | static void | 1614 | static void |
1622 | free_proto_queue (struct ProtoQueue *pq) | 1615 | free_proto_queue(struct ProtoQueue *pq) |
1623 | { | 1616 | { |
1624 | GNUNET_NETWORK_socket_close (pq->sock); | 1617 | GNUNET_NETWORK_socket_close(pq->sock); |
1625 | GNUNET_free (pq->address); | 1618 | GNUNET_free(pq->address); |
1626 | GNUNET_CONTAINER_DLL_remove (proto_head, proto_tail, pq); | 1619 | GNUNET_CONTAINER_DLL_remove(proto_head, proto_tail, pq); |
1627 | GNUNET_free (pq); | 1620 | GNUNET_free(pq); |
1628 | } | 1621 | } |
1629 | 1622 | ||
1630 | 1623 | ||
@@ -1635,7 +1628,7 @@ free_proto_queue (struct ProtoQueue *pq) | |||
1635 | * @param cls a `struct ProtoQueue` | 1628 | * @param cls a `struct ProtoQueue` |
1636 | */ | 1629 | */ |
1637 | static void | 1630 | static void |
1638 | proto_read_kx (void *cls) | 1631 | proto_read_kx(void *cls) |
1639 | { | 1632 | { |
1640 | struct ProtoQueue *pq = cls; | 1633 | struct ProtoQueue *pq = cls; |
1641 | ssize_t rcvd; | 1634 | ssize_t rcvd; |
@@ -1644,67 +1637,67 @@ proto_read_kx (void *cls) | |||
1644 | struct TCPConfirmation tc; | 1637 | struct TCPConfirmation tc; |
1645 | 1638 | ||
1646 | pq->read_task = NULL; | 1639 | pq->read_task = NULL; |
1647 | left = GNUNET_TIME_absolute_get_remaining (pq->timeout); | 1640 | left = GNUNET_TIME_absolute_get_remaining(pq->timeout); |
1648 | if (0 == left.rel_value_us) | 1641 | if (0 == left.rel_value_us) |
1649 | { | 1642 | { |
1650 | free_proto_queue (pq); | 1643 | free_proto_queue(pq); |
1651 | return; | 1644 | return; |
1652 | } | 1645 | } |
1653 | rcvd = GNUNET_NETWORK_socket_recv (pq->sock, | 1646 | rcvd = GNUNET_NETWORK_socket_recv(pq->sock, |
1654 | &pq->ibuf[pq->ibuf_off], | 1647 | &pq->ibuf[pq->ibuf_off], |
1655 | sizeof (pq->ibuf) - pq->ibuf_off); | 1648 | sizeof(pq->ibuf) - pq->ibuf_off); |
1656 | if (-1 == rcvd) | 1649 | if (-1 == rcvd) |
1657 | { | ||
1658 | if ((EAGAIN != errno) && (EINTR != errno)) | ||
1659 | { | 1650 | { |
1660 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv"); | 1651 | if ((EAGAIN != errno) && (EINTR != errno)) |
1661 | free_proto_queue (pq); | 1652 | { |
1653 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "recv"); | ||
1654 | free_proto_queue(pq); | ||
1655 | return; | ||
1656 | } | ||
1657 | /* try again */ | ||
1658 | pq->read_task = | ||
1659 | GNUNET_SCHEDULER_add_read_net(left, pq->sock, &proto_read_kx, pq); | ||
1662 | return; | 1660 | return; |
1663 | } | 1661 | } |
1664 | /* try again */ | ||
1665 | pq->read_task = | ||
1666 | GNUNET_SCHEDULER_add_read_net (left, pq->sock, &proto_read_kx, pq); | ||
1667 | return; | ||
1668 | } | ||
1669 | pq->ibuf_off += rcvd; | 1662 | pq->ibuf_off += rcvd; |
1670 | if (pq->ibuf_off > sizeof (pq->ibuf)) | 1663 | if (pq->ibuf_off > sizeof(pq->ibuf)) |
1671 | { | 1664 | { |
1672 | /* read more */ | 1665 | /* read more */ |
1673 | pq->read_task = | 1666 | pq->read_task = |
1674 | GNUNET_SCHEDULER_add_read_net (left, pq->sock, &proto_read_kx, pq); | 1667 | GNUNET_SCHEDULER_add_read_net(left, pq->sock, &proto_read_kx, pq); |
1675 | return; | 1668 | return; |
1676 | } | 1669 | } |
1677 | /* we got all the data, let's find out who we are talking to! */ | 1670 | /* we got all the data, let's find out who we are talking to! */ |
1678 | queue = GNUNET_new (struct Queue); | 1671 | queue = GNUNET_new(struct Queue); |
1679 | setup_in_cipher ((const struct GNUNET_CRYPTO_EcdhePublicKey *) pq->ibuf, | 1672 | setup_in_cipher((const struct GNUNET_CRYPTO_EcdhePublicKey *)pq->ibuf, |
1680 | queue); | 1673 | queue); |
1681 | if (GNUNET_OK != decrypt_and_check_tc (queue, &tc, pq->ibuf)) | 1674 | if (GNUNET_OK != decrypt_and_check_tc(queue, &tc, pq->ibuf)) |
1682 | { | 1675 | { |
1683 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1676 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
1684 | "Invalid TCP KX received from %s\n", | 1677 | "Invalid TCP KX received from %s\n", |
1685 | GNUNET_a2s (queue->address, queue->address_len)); | 1678 | GNUNET_a2s(queue->address, queue->address_len)); |
1686 | gcry_cipher_close (queue->in_cipher); | 1679 | gcry_cipher_close(queue->in_cipher); |
1687 | GNUNET_free (queue); | 1680 | GNUNET_free(queue); |
1688 | free_proto_queue (pq); | 1681 | free_proto_queue(pq); |
1689 | return; | 1682 | return; |
1690 | } | 1683 | } |
1691 | queue->address = pq->address; /* steals reference */ | 1684 | queue->address = pq->address; /* steals reference */ |
1692 | queue->address_len = pq->address_len; | 1685 | queue->address_len = pq->address_len; |
1693 | queue->target = tc.sender; | 1686 | queue->target = tc.sender; |
1694 | start_initial_kx_out (queue); | 1687 | start_initial_kx_out(queue); |
1695 | boot_queue (queue, GNUNET_TRANSPORT_CS_INBOUND); | 1688 | boot_queue(queue, GNUNET_TRANSPORT_CS_INBOUND); |
1696 | queue->read_task = | 1689 | queue->read_task = |
1697 | GNUNET_SCHEDULER_add_read_net (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, | 1690 | GNUNET_SCHEDULER_add_read_net(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, |
1691 | queue->sock, | ||
1692 | &queue_read, | ||
1693 | queue); | ||
1694 | queue->write_task = | ||
1695 | GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
1698 | queue->sock, | 1696 | queue->sock, |
1699 | &queue_read, | 1697 | &queue_write, |
1700 | queue); | 1698 | queue); |
1701 | queue->write_task = | 1699 | GNUNET_CONTAINER_DLL_remove(proto_head, proto_tail, pq); |
1702 | GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, | 1700 | GNUNET_free(pq); |
1703 | queue->sock, | ||
1704 | &queue_write, | ||
1705 | queue); | ||
1706 | GNUNET_CONTAINER_DLL_remove (proto_head, proto_tail, pq); | ||
1707 | GNUNET_free (pq); | ||
1708 | } | 1701 | } |
1709 | 1702 | ||
1710 | 1703 | ||
@@ -1716,7 +1709,7 @@ proto_read_kx (void *cls) | |||
1716 | * @param cls NULL | 1709 | * @param cls NULL |
1717 | */ | 1710 | */ |
1718 | static void | 1711 | static void |
1719 | listen_cb (void *cls) | 1712 | listen_cb(void *cls) |
1720 | { | 1713 | { |
1721 | struct sockaddr_storage in; | 1714 | struct sockaddr_storage in; |
1722 | socklen_t addrlen; | 1715 | socklen_t addrlen; |
@@ -1724,35 +1717,35 @@ listen_cb (void *cls) | |||
1724 | struct ProtoQueue *pq; | 1717 | struct ProtoQueue *pq; |
1725 | 1718 | ||
1726 | listen_task = NULL; | 1719 | listen_task = NULL; |
1727 | GNUNET_assert (NULL != listen_sock); | 1720 | GNUNET_assert(NULL != listen_sock); |
1728 | addrlen = sizeof (in); | 1721 | addrlen = sizeof(in); |
1729 | memset (&in, 0, sizeof (in)); | 1722 | memset(&in, 0, sizeof(in)); |
1730 | sock = GNUNET_NETWORK_socket_accept (listen_sock, | 1723 | sock = GNUNET_NETWORK_socket_accept(listen_sock, |
1731 | (struct sockaddr *) &in, | 1724 | (struct sockaddr *)&in, |
1732 | &addrlen); | 1725 | &addrlen); |
1733 | if ((NULL == sock) && ((EMFILE == errno) || (ENFILE == errno))) | 1726 | if ((NULL == sock) && ((EMFILE == errno) || (ENFILE == errno))) |
1734 | return; /* system limit reached, wait until connection goes down */ | 1727 | return; /* system limit reached, wait until connection goes down */ |
1735 | listen_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 1728 | listen_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
1736 | listen_sock, | 1729 | listen_sock, |
1737 | &listen_cb, | 1730 | &listen_cb, |
1738 | NULL); | 1731 | NULL); |
1739 | if ((NULL == sock) && ((EAGAIN == errno) || (ENOBUFS == errno))) | 1732 | if ((NULL == sock) && ((EAGAIN == errno) || (ENOBUFS == errno))) |
1740 | return; | 1733 | return; |
1741 | if (NULL == sock) | 1734 | if (NULL == sock) |
1742 | { | 1735 | { |
1743 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "accept"); | 1736 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "accept"); |
1744 | return; | 1737 | return; |
1745 | } | 1738 | } |
1746 | pq = GNUNET_new (struct ProtoQueue); | 1739 | pq = GNUNET_new(struct ProtoQueue); |
1747 | pq->address_len = addrlen; | 1740 | pq->address_len = addrlen; |
1748 | pq->address = GNUNET_memdup (&in, addrlen); | 1741 | pq->address = GNUNET_memdup(&in, addrlen); |
1749 | pq->timeout = GNUNET_TIME_relative_to_absolute (PROTO_QUEUE_TIMEOUT); | 1742 | pq->timeout = GNUNET_TIME_relative_to_absolute(PROTO_QUEUE_TIMEOUT); |
1750 | pq->sock = sock; | 1743 | pq->sock = sock; |
1751 | pq->read_task = GNUNET_SCHEDULER_add_read_net (PROTO_QUEUE_TIMEOUT, | 1744 | pq->read_task = GNUNET_SCHEDULER_add_read_net(PROTO_QUEUE_TIMEOUT, |
1752 | pq->sock, | 1745 | pq->sock, |
1753 | &proto_read_kx, | 1746 | &proto_read_kx, |
1754 | pq); | 1747 | pq); |
1755 | GNUNET_CONTAINER_DLL_insert (proto_head, proto_tail, pq); | 1748 | GNUNET_CONTAINER_DLL_insert(proto_head, proto_tail, pq); |
1756 | } | 1749 | } |
1757 | 1750 | ||
1758 | 1751 | ||
@@ -1764,7 +1757,7 @@ listen_cb (void *cls) | |||
1764 | * @param cls a `struct Queue` | 1757 | * @param cls a `struct Queue` |
1765 | */ | 1758 | */ |
1766 | static void | 1759 | static void |
1767 | queue_read_kx (void *cls) | 1760 | queue_read_kx(void *cls) |
1768 | { | 1761 | { |
1769 | struct Queue *queue = cls; | 1762 | struct Queue *queue = cls; |
1770 | ssize_t rcvd; | 1763 | ssize_t rcvd; |
@@ -1772,65 +1765,65 @@ queue_read_kx (void *cls) | |||
1772 | struct TCPConfirmation tc; | 1765 | struct TCPConfirmation tc; |
1773 | 1766 | ||
1774 | queue->read_task = NULL; | 1767 | queue->read_task = NULL; |
1775 | left = GNUNET_TIME_absolute_get_remaining (queue->timeout); | 1768 | left = GNUNET_TIME_absolute_get_remaining(queue->timeout); |
1776 | if (0 == left.rel_value_us) | 1769 | if (0 == left.rel_value_us) |
1777 | { | 1770 | { |
1778 | queue_destroy (queue); | 1771 | queue_destroy(queue); |
1779 | return; | 1772 | return; |
1780 | } | 1773 | } |
1781 | rcvd = GNUNET_NETWORK_socket_recv (queue->sock, | 1774 | rcvd = GNUNET_NETWORK_socket_recv(queue->sock, |
1782 | &queue->cread_buf[queue->cread_off], | 1775 | &queue->cread_buf[queue->cread_off], |
1783 | BUF_SIZE - queue->cread_off); | 1776 | BUF_SIZE - queue->cread_off); |
1784 | if (-1 == rcvd) | 1777 | if (-1 == rcvd) |
1785 | { | ||
1786 | if ((EAGAIN != errno) && (EINTR != errno)) | ||
1787 | { | 1778 | { |
1788 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv"); | 1779 | if ((EAGAIN != errno) && (EINTR != errno)) |
1789 | queue_destroy (queue); | 1780 | { |
1781 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "recv"); | ||
1782 | queue_destroy(queue); | ||
1783 | return; | ||
1784 | } | ||
1785 | queue->read_task = | ||
1786 | GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read_kx, queue); | ||
1790 | return; | 1787 | return; |
1791 | } | 1788 | } |
1792 | queue->read_task = | ||
1793 | GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read_kx, queue); | ||
1794 | return; | ||
1795 | } | ||
1796 | queue->cread_off += rcvd; | 1789 | queue->cread_off += rcvd; |
1797 | if (queue->cread_off < INITIAL_KX_SIZE) | 1790 | if (queue->cread_off < INITIAL_KX_SIZE) |
1798 | { | 1791 | { |
1799 | /* read more */ | 1792 | /* read more */ |
1800 | queue->read_task = | 1793 | queue->read_task = |
1801 | GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read_kx, queue); | 1794 | GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read_kx, queue); |
1802 | return; | 1795 | return; |
1803 | } | 1796 | } |
1804 | /* we got all the data, let's find out who we are talking to! */ | 1797 | /* we got all the data, let's find out who we are talking to! */ |
1805 | setup_in_cipher ((const struct GNUNET_CRYPTO_EcdhePublicKey *) | 1798 | setup_in_cipher((const struct GNUNET_CRYPTO_EcdhePublicKey *) |
1806 | queue->cread_buf, | 1799 | queue->cread_buf, |
1807 | queue); | 1800 | queue); |
1808 | if (GNUNET_OK != decrypt_and_check_tc (queue, &tc, queue->cread_buf)) | 1801 | if (GNUNET_OK != decrypt_and_check_tc(queue, &tc, queue->cread_buf)) |
1809 | { | 1802 | { |
1810 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1803 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
1811 | "Invalid TCP KX received from %s\n", | 1804 | "Invalid TCP KX received from %s\n", |
1812 | GNUNET_a2s (queue->address, queue->address_len)); | 1805 | GNUNET_a2s(queue->address, queue->address_len)); |
1813 | queue_destroy (queue); | 1806 | queue_destroy(queue); |
1814 | return; | 1807 | return; |
1815 | } | 1808 | } |
1816 | if (0 != | 1809 | if (0 != |
1817 | memcmp (&tc.sender, &queue->target, sizeof (struct GNUNET_PeerIdentity))) | 1810 | memcmp(&tc.sender, &queue->target, sizeof(struct GNUNET_PeerIdentity))) |
1818 | { | 1811 | { |
1819 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 1812 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
1820 | "Invalid sender in TCP KX received from %s\n", | 1813 | "Invalid sender in TCP KX received from %s\n", |
1821 | GNUNET_a2s (queue->address, queue->address_len)); | 1814 | GNUNET_a2s(queue->address, queue->address_len)); |
1822 | queue_destroy (queue); | 1815 | queue_destroy(queue); |
1823 | return; | 1816 | return; |
1824 | } | 1817 | } |
1825 | 1818 | ||
1826 | /* update queue timeout */ | 1819 | /* update queue timeout */ |
1827 | reschedule_queue_timeout (queue); | 1820 | reschedule_queue_timeout(queue); |
1828 | /* prepare to continue with regular read task immediately */ | 1821 | /* prepare to continue with regular read task immediately */ |
1829 | memmove (queue->cread_buf, | 1822 | memmove(queue->cread_buf, |
1830 | &queue->cread_buf[INITIAL_KX_SIZE], | 1823 | &queue->cread_buf[INITIAL_KX_SIZE], |
1831 | queue->cread_off - (INITIAL_KX_SIZE)); | 1824 | queue->cread_off - (INITIAL_KX_SIZE)); |
1832 | queue->cread_off -= INITIAL_KX_SIZE; | 1825 | queue->cread_off -= INITIAL_KX_SIZE; |
1833 | queue->read_task = GNUNET_SCHEDULER_add_now (&queue_read, queue); | 1826 | queue->read_task = GNUNET_SCHEDULER_add_now(&queue_read, queue); |
1834 | } | 1827 | } |
1835 | 1828 | ||
1836 | 1829 | ||
@@ -1853,7 +1846,7 @@ queue_read_kx (void *cls) | |||
1853 | * invalid | 1846 | * invalid |
1854 | */ | 1847 | */ |
1855 | static int | 1848 | static int |
1856 | mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) | 1849 | mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) |
1857 | { | 1850 | { |
1858 | struct Queue *queue; | 1851 | struct Queue *queue; |
1859 | const char *path; | 1852 | const char *path; |
@@ -1861,54 +1854,54 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) | |||
1861 | socklen_t in_len; | 1854 | socklen_t in_len; |
1862 | struct GNUNET_NETWORK_Handle *sock; | 1855 | struct GNUNET_NETWORK_Handle *sock; |
1863 | 1856 | ||
1864 | if (0 != strncmp (address, | 1857 | if (0 != strncmp(address, |
1865 | COMMUNICATOR_ADDRESS_PREFIX "-", | 1858 | COMMUNICATOR_ADDRESS_PREFIX "-", |
1866 | strlen (COMMUNICATOR_ADDRESS_PREFIX "-"))) | 1859 | strlen(COMMUNICATOR_ADDRESS_PREFIX "-"))) |
1867 | { | 1860 | { |
1868 | GNUNET_break_op (0); | 1861 | GNUNET_break_op(0); |
1869 | return GNUNET_SYSERR; | 1862 | return GNUNET_SYSERR; |
1870 | } | 1863 | } |
1871 | path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")]; | 1864 | path = &address[strlen(COMMUNICATOR_ADDRESS_PREFIX "-")]; |
1872 | in = tcp_address_to_sockaddr (path, &in_len); | 1865 | in = tcp_address_to_sockaddr(path, &in_len); |
1873 | 1866 | ||
1874 | sock = GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM, IPPROTO_TCP); | 1867 | sock = GNUNET_NETWORK_socket_create(in->sa_family, SOCK_STREAM, IPPROTO_TCP); |
1875 | if (NULL == sock) | 1868 | if (NULL == sock) |
1876 | { | 1869 | { |
1877 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 1870 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
1878 | "socket(%d) failed: %s", | 1871 | "socket(%d) failed: %s", |
1879 | in->sa_family, | 1872 | in->sa_family, |
1880 | strerror (errno)); | 1873 | strerror(errno)); |
1881 | GNUNET_free (in); | 1874 | GNUNET_free(in); |
1882 | return GNUNET_SYSERR; | 1875 | return GNUNET_SYSERR; |
1883 | } | 1876 | } |
1884 | if (GNUNET_OK != GNUNET_NETWORK_socket_connect (sock, in, in_len)) | 1877 | if (GNUNET_OK != GNUNET_NETWORK_socket_connect(sock, in, in_len)) |
1885 | { | 1878 | { |
1886 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 1879 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
1887 | "connect to `%s' failed: %s", | 1880 | "connect to `%s' failed: %s", |
1888 | address, | 1881 | address, |
1889 | strerror (errno)); | 1882 | strerror(errno)); |
1890 | GNUNET_NETWORK_socket_close (sock); | 1883 | GNUNET_NETWORK_socket_close(sock); |
1891 | GNUNET_free (in); | 1884 | GNUNET_free(in); |
1892 | return GNUNET_SYSERR; | 1885 | return GNUNET_SYSERR; |
1893 | } | 1886 | } |
1894 | 1887 | ||
1895 | queue = GNUNET_new (struct Queue); | 1888 | queue = GNUNET_new(struct Queue); |
1896 | queue->target = *peer; | 1889 | queue->target = *peer; |
1897 | queue->address = in; | 1890 | queue->address = in; |
1898 | queue->address_len = in_len; | 1891 | queue->address_len = in_len; |
1899 | queue->sock = sock; | 1892 | queue->sock = sock; |
1900 | boot_queue (queue, GNUNET_TRANSPORT_CS_OUTBOUND); | 1893 | boot_queue(queue, GNUNET_TRANSPORT_CS_OUTBOUND); |
1901 | queue->read_task = | 1894 | queue->read_task = |
1902 | GNUNET_SCHEDULER_add_read_net (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, | 1895 | GNUNET_SCHEDULER_add_read_net(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, |
1896 | queue->sock, | ||
1897 | &queue_read_kx, | ||
1898 | queue); | ||
1899 | start_initial_kx_out(queue); | ||
1900 | queue->write_task = | ||
1901 | GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
1903 | queue->sock, | 1902 | queue->sock, |
1904 | &queue_read_kx, | 1903 | &queue_write, |
1905 | queue); | 1904 | queue); |
1906 | start_initial_kx_out (queue); | ||
1907 | queue->write_task = | ||
1908 | GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL, | ||
1909 | queue->sock, | ||
1910 | &queue_write, | ||
1911 | queue); | ||
1912 | return GNUNET_OK; | 1905 | return GNUNET_OK; |
1913 | } | 1906 | } |
1914 | 1907 | ||
@@ -1922,15 +1915,15 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) | |||
1922 | * @return #GNUNET_OK to continue to iterate | 1915 | * @return #GNUNET_OK to continue to iterate |
1923 | */ | 1916 | */ |
1924 | static int | 1917 | static int |
1925 | get_queue_delete_it (void *cls, | 1918 | get_queue_delete_it(void *cls, |
1926 | const struct GNUNET_PeerIdentity *target, | 1919 | const struct GNUNET_PeerIdentity *target, |
1927 | void *value) | 1920 | void *value) |
1928 | { | 1921 | { |
1929 | struct Queue *queue = value; | 1922 | struct Queue *queue = value; |
1930 | 1923 | ||
1931 | (void) cls; | 1924 | (void)cls; |
1932 | (void) target; | 1925 | (void)target; |
1933 | queue_destroy (queue); | 1926 | queue_destroy(queue); |
1934 | return GNUNET_OK; | 1927 | return GNUNET_OK; |
1935 | } | 1928 | } |
1936 | 1929 | ||
@@ -1941,47 +1934,47 @@ get_queue_delete_it (void *cls, | |||
1941 | * @param cls NULL (always) | 1934 | * @param cls NULL (always) |
1942 | */ | 1935 | */ |
1943 | static void | 1936 | static void |
1944 | do_shutdown (void *cls) | 1937 | do_shutdown(void *cls) |
1945 | { | 1938 | { |
1946 | while (NULL != proto_head) | 1939 | while (NULL != proto_head) |
1947 | free_proto_queue (proto_head); | 1940 | free_proto_queue(proto_head); |
1948 | if (NULL != nat) | 1941 | if (NULL != nat) |
1949 | { | 1942 | { |
1950 | GNUNET_NAT_unregister (nat); | 1943 | GNUNET_NAT_unregister(nat); |
1951 | nat = NULL; | 1944 | nat = NULL; |
1952 | } | 1945 | } |
1953 | if (NULL != listen_task) | 1946 | if (NULL != listen_task) |
1954 | { | 1947 | { |
1955 | GNUNET_SCHEDULER_cancel (listen_task); | 1948 | GNUNET_SCHEDULER_cancel(listen_task); |
1956 | listen_task = NULL; | 1949 | listen_task = NULL; |
1957 | } | 1950 | } |
1958 | if (NULL != listen_sock) | 1951 | if (NULL != listen_sock) |
1959 | { | 1952 | { |
1960 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (listen_sock)); | 1953 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(listen_sock)); |
1961 | listen_sock = NULL; | 1954 | listen_sock = NULL; |
1962 | } | 1955 | } |
1963 | GNUNET_CONTAINER_multipeermap_iterate (queue_map, &get_queue_delete_it, NULL); | 1956 | GNUNET_CONTAINER_multipeermap_iterate(queue_map, &get_queue_delete_it, NULL); |
1964 | GNUNET_CONTAINER_multipeermap_destroy (queue_map); | 1957 | GNUNET_CONTAINER_multipeermap_destroy(queue_map); |
1965 | if (NULL != ch) | 1958 | if (NULL != ch) |
1966 | { | 1959 | { |
1967 | GNUNET_TRANSPORT_communicator_disconnect (ch); | 1960 | GNUNET_TRANSPORT_communicator_disconnect(ch); |
1968 | ch = NULL; | 1961 | ch = NULL; |
1969 | } | 1962 | } |
1970 | if (NULL != stats) | 1963 | if (NULL != stats) |
1971 | { | 1964 | { |
1972 | GNUNET_STATISTICS_destroy (stats, GNUNET_NO); | 1965 | GNUNET_STATISTICS_destroy(stats, GNUNET_NO); |
1973 | stats = NULL; | 1966 | stats = NULL; |
1974 | } | 1967 | } |
1975 | if (NULL != my_private_key) | 1968 | if (NULL != my_private_key) |
1976 | { | 1969 | { |
1977 | GNUNET_free (my_private_key); | 1970 | GNUNET_free(my_private_key); |
1978 | my_private_key = NULL; | 1971 | my_private_key = NULL; |
1979 | } | 1972 | } |
1980 | if (NULL != is) | 1973 | if (NULL != is) |
1981 | { | 1974 | { |
1982 | GNUNET_NT_scanner_done (is); | 1975 | GNUNET_NT_scanner_done(is); |
1983 | is = NULL; | 1976 | is = NULL; |
1984 | } | 1977 | } |
1985 | } | 1978 | } |
1986 | 1979 | ||
1987 | 1980 | ||
@@ -1997,14 +1990,14 @@ do_shutdown (void *cls) | |||
1997 | * @param msg payload | 1990 | * @param msg payload |
1998 | */ | 1991 | */ |
1999 | static void | 1992 | static void |
2000 | enc_notify_cb (void *cls, | 1993 | enc_notify_cb(void *cls, |
2001 | const struct GNUNET_PeerIdentity *sender, | 1994 | const struct GNUNET_PeerIdentity *sender, |
2002 | const struct GNUNET_MessageHeader *msg) | 1995 | const struct GNUNET_MessageHeader *msg) |
2003 | { | 1996 | { |
2004 | (void) cls; | 1997 | (void)cls; |
2005 | (void) sender; | 1998 | (void)sender; |
2006 | (void) msg; | 1999 | (void)msg; |
2007 | GNUNET_break_op (0); | 2000 | GNUNET_break_op(0); |
2008 | } | 2001 | } |
2009 | 2002 | ||
2010 | 2003 | ||
@@ -2022,39 +2015,39 @@ enc_notify_cb (void *cls, | |||
2022 | * @param addrlen actual length of the @a addr | 2015 | * @param addrlen actual length of the @a addr |
2023 | */ | 2016 | */ |
2024 | static void | 2017 | static void |
2025 | nat_address_cb (void *cls, | 2018 | nat_address_cb(void *cls, |
2026 | void **app_ctx, | 2019 | void **app_ctx, |
2027 | int add_remove, | 2020 | int add_remove, |
2028 | enum GNUNET_NAT_AddressClass ac, | 2021 | enum GNUNET_NAT_AddressClass ac, |
2029 | const struct sockaddr *addr, | 2022 | const struct sockaddr *addr, |
2030 | socklen_t addrlen) | 2023 | socklen_t addrlen) |
2031 | { | 2024 | { |
2032 | char *my_addr; | 2025 | char *my_addr; |
2033 | struct GNUNET_TRANSPORT_AddressIdentifier *ai; | 2026 | struct GNUNET_TRANSPORT_AddressIdentifier *ai; |
2034 | 2027 | ||
2035 | if (GNUNET_YES == add_remove) | 2028 | if (GNUNET_YES == add_remove) |
2036 | { | 2029 | { |
2037 | enum GNUNET_NetworkType nt; | 2030 | enum GNUNET_NetworkType nt; |
2038 | 2031 | ||
2039 | GNUNET_asprintf (&my_addr, | 2032 | GNUNET_asprintf(&my_addr, |
2040 | "%s-%s", | 2033 | "%s-%s", |
2041 | COMMUNICATOR_ADDRESS_PREFIX, | 2034 | COMMUNICATOR_ADDRESS_PREFIX, |
2042 | GNUNET_a2s (addr, addrlen)); | 2035 | GNUNET_a2s(addr, addrlen)); |
2043 | nt = GNUNET_NT_scanner_get_type (is, addr, addrlen); | 2036 | nt = GNUNET_NT_scanner_get_type(is, addr, addrlen); |
2044 | ai = | 2037 | ai = |
2045 | GNUNET_TRANSPORT_communicator_address_add (ch, | 2038 | GNUNET_TRANSPORT_communicator_address_add(ch, |
2046 | my_addr, | 2039 | my_addr, |
2047 | nt, | 2040 | nt, |
2048 | GNUNET_TIME_UNIT_FOREVER_REL); | 2041 | GNUNET_TIME_UNIT_FOREVER_REL); |
2049 | GNUNET_free (my_addr); | 2042 | GNUNET_free(my_addr); |
2050 | *app_ctx = ai; | 2043 | *app_ctx = ai; |
2051 | } | 2044 | } |
2052 | else | 2045 | else |
2053 | { | 2046 | { |
2054 | ai = *app_ctx; | 2047 | ai = *app_ctx; |
2055 | GNUNET_TRANSPORT_communicator_address_remove (ai); | 2048 | GNUNET_TRANSPORT_communicator_address_remove(ai); |
2056 | *app_ctx = NULL; | 2049 | *app_ctx = NULL; |
2057 | } | 2050 | } |
2058 | } | 2051 | } |
2059 | 2052 | ||
2060 | 2053 | ||
@@ -2067,10 +2060,10 @@ nat_address_cb (void *cls, | |||
2067 | * @param c configuration | 2060 | * @param c configuration |
2068 | */ | 2061 | */ |
2069 | static void | 2062 | static void |
2070 | run (void *cls, | 2063 | run(void *cls, |
2071 | char *const *args, | 2064 | char *const *args, |
2072 | const char *cfgfile, | 2065 | const char *cfgfile, |
2073 | const struct GNUNET_CONFIGURATION_Handle *c) | 2066 | const struct GNUNET_CONFIGURATION_Handle *c) |
2074 | { | 2067 | { |
2075 | char *bindto; | 2068 | char *bindto; |
2076 | struct sockaddr *in; | 2069 | struct sockaddr *in; |
@@ -2078,113 +2071,113 @@ run (void *cls, | |||
2078 | struct sockaddr_storage in_sto; | 2071 | struct sockaddr_storage in_sto; |
2079 | socklen_t sto_len; | 2072 | socklen_t sto_len; |
2080 | 2073 | ||
2081 | (void) cls; | 2074 | (void)cls; |
2082 | cfg = c; | 2075 | cfg = c; |
2083 | if (GNUNET_OK != | 2076 | if (GNUNET_OK != |
2084 | GNUNET_CONFIGURATION_get_value_filename (cfg, | 2077 | GNUNET_CONFIGURATION_get_value_filename(cfg, |
2085 | COMMUNICATOR_CONFIG_SECTION, | 2078 | COMMUNICATOR_CONFIG_SECTION, |
2086 | "BINDTO", | 2079 | "BINDTO", |
2087 | &bindto)) | 2080 | &bindto)) |
2088 | { | 2081 | { |
2089 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, | 2082 | GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, |
2090 | COMMUNICATOR_CONFIG_SECTION, | 2083 | COMMUNICATOR_CONFIG_SECTION, |
2091 | "BINDTO"); | 2084 | "BINDTO"); |
2092 | return; | 2085 | return; |
2093 | } | 2086 | } |
2094 | if (GNUNET_OK != | 2087 | if (GNUNET_OK != |
2095 | GNUNET_CONFIGURATION_get_value_number (cfg, | 2088 | GNUNET_CONFIGURATION_get_value_number(cfg, |
2096 | COMMUNICATOR_CONFIG_SECTION, | 2089 | COMMUNICATOR_CONFIG_SECTION, |
2097 | "MAX_QUEUE_LENGTH", | 2090 | "MAX_QUEUE_LENGTH", |
2098 | &max_queue_length)) | 2091 | &max_queue_length)) |
2099 | max_queue_length = DEFAULT_MAX_QUEUE_LENGTH; | 2092 | max_queue_length = DEFAULT_MAX_QUEUE_LENGTH; |
2100 | 2093 | ||
2101 | in = tcp_address_to_sockaddr (bindto, &in_len); | 2094 | in = tcp_address_to_sockaddr(bindto, &in_len); |
2102 | if (NULL == in) | 2095 | if (NULL == in) |
2103 | { | 2096 | { |
2104 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 2097 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
2105 | "Failed to setup TCP socket address with path `%s'\n", | 2098 | "Failed to setup TCP socket address with path `%s'\n", |
2106 | bindto); | 2099 | bindto); |
2107 | GNUNET_free (bindto); | 2100 | GNUNET_free(bindto); |
2108 | return; | 2101 | return; |
2109 | } | 2102 | } |
2110 | listen_sock = | 2103 | listen_sock = |
2111 | GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM, IPPROTO_TCP); | 2104 | GNUNET_NETWORK_socket_create(in->sa_family, SOCK_STREAM, IPPROTO_TCP); |
2112 | if (NULL == listen_sock) | 2105 | if (NULL == listen_sock) |
2113 | { | 2106 | { |
2114 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket"); | 2107 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "socket"); |
2115 | GNUNET_free (in); | 2108 | GNUNET_free(in); |
2116 | GNUNET_free (bindto); | 2109 | GNUNET_free(bindto); |
2117 | return; | 2110 | return; |
2118 | } | 2111 | } |
2119 | if (GNUNET_OK != GNUNET_NETWORK_socket_bind (listen_sock, in, in_len)) | 2112 | if (GNUNET_OK != GNUNET_NETWORK_socket_bind(listen_sock, in, in_len)) |
2120 | { | 2113 | { |
2121 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "bind", bindto); | 2114 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "bind", bindto); |
2122 | GNUNET_NETWORK_socket_close (listen_sock); | 2115 | GNUNET_NETWORK_socket_close(listen_sock); |
2123 | listen_sock = NULL; | 2116 | listen_sock = NULL; |
2124 | GNUNET_free (in); | 2117 | GNUNET_free(in); |
2125 | GNUNET_free (bindto); | 2118 | GNUNET_free(bindto); |
2126 | return; | 2119 | return; |
2127 | } | 2120 | } |
2128 | /* We might have bound to port 0, allowing the OS to figure it out; | 2121 | /* We might have bound to port 0, allowing the OS to figure it out; |
2129 | thus, get the real IN-address from the socket */ | 2122 | thus, get the real IN-address from the socket */ |
2130 | sto_len = sizeof (in_sto); | 2123 | sto_len = sizeof(in_sto); |
2131 | if (0 != getsockname (GNUNET_NETWORK_get_fd (listen_sock), | 2124 | if (0 != getsockname(GNUNET_NETWORK_get_fd(listen_sock), |
2132 | (struct sockaddr *) &in_sto, | 2125 | (struct sockaddr *)&in_sto, |
2133 | &sto_len)) | 2126 | &sto_len)) |
2134 | { | 2127 | { |
2135 | memcpy (&in_sto, in, in_len); | 2128 | memcpy(&in_sto, in, in_len); |
2136 | sto_len = in_len; | 2129 | sto_len = in_len; |
2137 | } | 2130 | } |
2138 | GNUNET_free (in); | 2131 | GNUNET_free(in); |
2139 | GNUNET_free (bindto); | 2132 | GNUNET_free(bindto); |
2140 | in = (struct sockaddr *) &in_sto; | 2133 | in = (struct sockaddr *)&in_sto; |
2141 | in_len = sto_len; | 2134 | in_len = sto_len; |
2142 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2135 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
2143 | "Bound to `%s'\n", | 2136 | "Bound to `%s'\n", |
2144 | GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len)); | 2137 | GNUNET_a2s((const struct sockaddr *)&in_sto, sto_len)); |
2145 | stats = GNUNET_STATISTICS_create ("C-TCP", cfg); | 2138 | stats = GNUNET_STATISTICS_create("C-TCP", cfg); |
2146 | GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL); | 2139 | GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL); |
2147 | is = GNUNET_NT_scanner_init (); | 2140 | is = GNUNET_NT_scanner_init(); |
2148 | my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg); | 2141 | my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg); |
2149 | if (NULL == my_private_key) | 2142 | if (NULL == my_private_key) |
2150 | { | 2143 | { |
2151 | GNUNET_log ( | 2144 | GNUNET_log( |
2152 | GNUNET_ERROR_TYPE_ERROR, | 2145 | GNUNET_ERROR_TYPE_ERROR, |
2153 | _ ( | 2146 | _( |
2154 | "Transport service is lacking key configuration settings. Exiting.\n")); | 2147 | "Transport service is lacking key configuration settings. Exiting.\n")); |
2155 | GNUNET_SCHEDULER_shutdown (); | 2148 | GNUNET_SCHEDULER_shutdown(); |
2156 | return; | 2149 | return; |
2157 | } | 2150 | } |
2158 | GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key); | 2151 | GNUNET_CRYPTO_eddsa_key_get_public(my_private_key, &my_identity.public_key); |
2159 | /* start listening */ | 2152 | /* start listening */ |
2160 | listen_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 2153 | listen_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
2161 | listen_sock, | 2154 | listen_sock, |
2162 | &listen_cb, | 2155 | &listen_cb, |
2163 | NULL); | ||
2164 | queue_map = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO); | ||
2165 | ch = GNUNET_TRANSPORT_communicator_connect (cfg, | ||
2166 | COMMUNICATOR_CONFIG_SECTION, | ||
2167 | COMMUNICATOR_ADDRESS_PREFIX, | ||
2168 | GNUNET_TRANSPORT_CC_RELIABLE, | ||
2169 | &mq_init, | ||
2170 | NULL, | ||
2171 | &enc_notify_cb, | ||
2172 | NULL); | 2156 | NULL); |
2157 | queue_map = GNUNET_CONTAINER_multipeermap_create(10, GNUNET_NO); | ||
2158 | ch = GNUNET_TRANSPORT_communicator_connect(cfg, | ||
2159 | COMMUNICATOR_CONFIG_SECTION, | ||
2160 | COMMUNICATOR_ADDRESS_PREFIX, | ||
2161 | GNUNET_TRANSPORT_CC_RELIABLE, | ||
2162 | &mq_init, | ||
2163 | NULL, | ||
2164 | &enc_notify_cb, | ||
2165 | NULL); | ||
2173 | if (NULL == ch) | 2166 | if (NULL == ch) |
2174 | { | 2167 | { |
2175 | GNUNET_break (0); | 2168 | GNUNET_break(0); |
2176 | GNUNET_SCHEDULER_shutdown (); | 2169 | GNUNET_SCHEDULER_shutdown(); |
2177 | return; | 2170 | return; |
2178 | } | 2171 | } |
2179 | nat = GNUNET_NAT_register (cfg, | 2172 | nat = GNUNET_NAT_register(cfg, |
2180 | COMMUNICATOR_CONFIG_SECTION, | 2173 | COMMUNICATOR_CONFIG_SECTION, |
2181 | IPPROTO_TCP, | 2174 | IPPROTO_TCP, |
2182 | 1 /* one address */, | 2175 | 1 /* one address */, |
2183 | (const struct sockaddr **) &in, | 2176 | (const struct sockaddr **)&in, |
2184 | &in_len, | 2177 | &in_len, |
2185 | &nat_address_cb, | 2178 | &nat_address_cb, |
2186 | NULL /* FIXME: support reversal: #5529 */, | 2179 | NULL /* FIXME: support reversal: #5529 */, |
2187 | NULL /* closure */); | 2180 | NULL /* closure */); |
2188 | } | 2181 | } |
2189 | 2182 | ||
2190 | 2183 | ||
@@ -2196,25 +2189,26 @@ run (void *cls, | |||
2196 | * @return 0 ok, 1 on error | 2189 | * @return 0 ok, 1 on error |
2197 | */ | 2190 | */ |
2198 | int | 2191 | int |
2199 | main (int argc, char *const *argv) | 2192 | main(int argc, char *const *argv) |
2200 | { | 2193 | { |
2201 | static const struct GNUNET_GETOPT_CommandLineOption options[] = { | 2194 | static const struct GNUNET_GETOPT_CommandLineOption options[] = { |
2202 | GNUNET_GETOPT_OPTION_END}; | 2195 | GNUNET_GETOPT_OPTION_END |
2196 | }; | ||
2203 | int ret; | 2197 | int ret; |
2204 | 2198 | ||
2205 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) | 2199 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) |
2206 | return 2; | 2200 | return 2; |
2207 | 2201 | ||
2208 | ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc, | 2202 | ret = (GNUNET_OK == GNUNET_PROGRAM_run(argc, |
2209 | argv, | 2203 | argv, |
2210 | "gnunet-communicator-tcp", | 2204 | "gnunet-communicator-tcp", |
2211 | _ ("GNUnet TCP communicator"), | 2205 | _("GNUnet TCP communicator"), |
2212 | options, | 2206 | options, |
2213 | &run, | 2207 | &run, |
2214 | NULL)) | 2208 | NULL)) |
2215 | ? 0 | 2209 | ? 0 |
2216 | : 1; | 2210 | : 1; |
2217 | GNUNET_free ((void *) argv); | 2211 | GNUNET_free((void *)argv); |
2218 | return ret; | 2212 | return ret; |
2219 | } | 2213 | } |
2220 | 2214 | ||