src/transport/gnunet-communicator-udp.c

   1 /*
   2      This file is part of GNUnet
   3      Copyright (C) 2010-2014, 2018, 2019 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20
  21 /**
  22  * @file transport/gnunet-communicator-udp.c
  23  * @brief Transport plugin using UDP.
  24  * @author Christian Grothoff
  25  *
  26  * TODO:
  27  * - consider imposing transmission limits in the absence
  28  *   of ACKs; or: maybe this should be done at TNG service level?
  29  *   (at least the receiver might want to enforce limits on
  30  *    KX/DH operations per sender in here) (#5552)
  31  * - overall, we should look more into flow control support
  32  *   (either in backchannel, or general solution in TNG service)
  33  * - handle addresses discovered from broadcasts (#5551)
  34  *   (think: what was the story again on address validation?
  35  *    where is the API for that!?!)
  36  * - support DNS names in BINDTO option (#5528)
  37  * - support NAT connection reversal method (#5529)
  38  * - support other UDP-specific NAT traversal methods (#)
  39  */
  40 #include "platform.h"
  41 #include "gnunet_util_lib.h"
  42 #include "gnunet_protocols.h"
  43 #include "gnunet_signatures.h"
  44 #include "gnunet_constants.h"
  45 #include "gnunet_nt_lib.h"
  46 #include "gnunet_nat_service.h"
  47 #include "gnunet_statistics_service.h"
  48 #include "gnunet_transport_application_service.h"
  49 #include "gnunet_transport_communication_service.h"
  50
  51 /**
  52  * How often do we rekey based on time (at least)
  53  */
  54 #define REKEY_TIME_INTERVAL GNUNET_TIME_UNIT_DAYS
  55
  56 /**
  57  * How long do we wait until we must have received the initial KX?
  58  */
  59 #define PROTO_QUEUE_TIMEOUT GNUNET_TIME_UNIT_MINUTES
  60
  61 /**
  62  * How often do we broadcast our presence on the LAN?
  63  */
  64 #define BROADCAST_FREQUENCY GNUNET_TIME_UNIT_MINUTES
  65
  66 /**
  67  * How often do we scan for changes to our network interfaces?
  68  */
  69 #define INTERFACE_SCAN_FREQUENCY \
  70   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
  71
  72 /**
  73  * How long do we believe our addresses to remain up (before
  74  * the other peer should revalidate).
  75  */
  76 #define ADDRESS_VALIDITY_PERIOD GNUNET_TIME_UNIT_HOURS
  77
  78 /**
  79  * AES key size.
  80  */
  81 #define AES_KEY_SIZE (256 / 8)
  82
  83 /**
  84  * AES (GCM) IV size.
  85  */
  86 #define AES_IV_SIZE (96 / 8)
  87
  88 /**
  89  * Size of the GCM tag.
  90  */
  91 #define GCM_TAG_SIZE (128 / 8)
  92
  93 /**
  94  * If we fall below this number of available KCNs,
  95  * we generate additional ACKs until we reach
  96  * #KCN_TARGET.
  97  * Should be large enough that we don't generate ACKs all
  98  * the time and still have enough time for the ACK to
  99  * arrive before the sender runs out. So really this
 100  * should ideally be based on the RTT.
 101  */
 102 #define KCN_THRESHOLD 92
 103
 104 /**
 105  * How many KCNs do we keep around *after* we hit
 106  * the #KCN_THRESHOLD? Should be larger than
 107  * #KCN_THRESHOLD so we do not generate just one
 108  * ACK at the time.
 109  */
 110 #define KCN_TARGET 128
 111
 112 /**
 113  * What is the maximum delta between KCN sequence numbers
 114  * that we allow. Used to expire 'ancient' KCNs that likely
 115  * were dropped by the network.  Must be larger than
 116  * KCN_TARGET (otherwise we generate new KCNs all the time),
 117  * but not too large (otherwise packet loss may cause
 118  * sender to fall back to KX needlessly when sender runs
 119  * out of ACK'ed KCNs due to losses).
 120  */
 121 #define MAX_SQN_DELTA 160
 122
 123 /**
 124  * How many shared master secrets do we keep around
 125  * at most per sender?  Should be large enough so
 126  * that we generally have a chance of sending an ACK
 127  * before the sender already rotated out the master
 128  * secret.  Generally values around #KCN_TARGET make
 129  * sense. Might make sense to adapt to RTT if we had
 130  * a good measurement...
 131  */
 132 #define MAX_SECRETS 128
 133
 134 /**
 135  * How often do we rekey based on number of bytes transmitted?
 136  * (additionally randomized).
 137  */
 138 #define REKEY_MAX_BYTES (1024LLU * 1024 * 1024 * 4LLU)
 139
 140 /**
 141  * Address prefix used by the communicator.
 142  */
 143
 144 #define COMMUNICATOR_ADDRESS_PREFIX "udp"
 145
 146 /**
 147  * Configuration section used by the communicator.
 148  */
 149 #define COMMUNICATOR_CONFIG_SECTION "communicator-udp"
 150
 151 GNUNET_NETWORK_STRUCT_BEGIN
 152
 153
 154 /**
 155  * Signature we use to verify that the ephemeral key was really chosen by
 156  * the specified sender.  If possible, the receiver should respond with
 157  * a `struct UDPAck` (possibly via backchannel).
 158  */
 159 struct UdpHandshakeSignature
 160 {
 161   /**
 162    * Purpose must be #GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE
 163    */
 164   struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
 165
 166   /**
 167    * Identity of the inititor of the UDP connection (UDP client).
 168    */
 169   struct GNUNET_PeerIdentity sender;
 170
 171   /**
 172    * Presumed identity of the target of the UDP connection (UDP server)
 173    */
 174   struct GNUNET_PeerIdentity receiver;
 175
 176   /**
 177    * Ephemeral key used by the @e sender.
 178    */
 179   struct GNUNET_CRYPTO_EcdhePublicKey ephemeral;
 180
 181   /**
 182    * Monotonic time of @e sender, to possibly help detect replay attacks
 183    * (if receiver persists times by sender).
 184    */
 185   struct GNUNET_TIME_AbsoluteNBO monotonic_time;
 186 };
 187
 188
 189 /**
 190  * "Plaintext" header at beginning of KX message. Followed
 191  * by encrypted `struct UDPConfirmation`.
 192  */
 193 struct InitialKX
 194 {
 195   /**
 196    * Ephemeral key for KX.
 197    */
 198   struct GNUNET_CRYPTO_EcdhePublicKey ephemeral;
 199
 200   /**
 201    * HMAC for the following encrypted message, using GCM.  HMAC uses
 202    * key derived from the handshake with sequence number zero.
 203    */
 204   char gcm_tag[GCM_TAG_SIZE];
 205 };
 206
 207
 208 /**
 209  * Encrypted continuation of UDP initial handshake, followed
 210  * by message header with payload.
 211  */
 212 struct UDPConfirmation
 213 {
 214   /**
 215    * Sender's identity
 216    */
 217   struct GNUNET_PeerIdentity sender;
 218
 219   /**
 220    * Sender's signature of type #GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE
 221    */
 222   struct GNUNET_CRYPTO_EddsaSignature sender_sig;
 223
 224   /**
 225    * Monotonic time of @e sender, to possibly help detect replay attacks
 226    * (if receiver persists times by sender).
 227    */
 228   struct GNUNET_TIME_AbsoluteNBO monotonic_time;
 229
 230   /* followed by messages */
 231
 232   /* padding may follow actual messages */
 233 };
 234
 235
 236 /**
 237  * UDP key acknowledgement.  May be sent via backchannel. Allows the
 238  * sender to use `struct UDPBox` with the acknowledge key henceforth.
 239  */
 240 struct UDPAck
 241 {
 242   /**
 243    * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK.
 244    */
 245   struct GNUNET_MessageHeader header;
 246
 247   /**
 248    * Sequence acknowledgement limit. Specifies current maximum sequence
 249    * number supported by receiver.
 250    */
 251   uint32_t sequence_max GNUNET_PACKED;
 252
 253   /**
 254    * CMAC of the base key being acknowledged.
 255    */
 256   struct GNUNET_HashCode cmac;
 257 };
 258
 259
 260 /**
 261  * Signature we use to verify that the broadcast was really made by
 262  * the peer that claims to have made it.  Basically, affirms that the
 263  * peer is really using this IP address (albeit possibly not in _our_
 264  * LAN).  Makes it difficult for peers in the LAN to claim to
 265  * be just any global peer -- an attacker must have at least
 266  * shared a LAN with the peer they're pretending to be here.
 267  */
 268 struct UdpBroadcastSignature
 269 {
 270   /**
 271    * Purpose must be #GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST
 272    */
 273   struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
 274
 275   /**
 276    * Identity of the inititor of the UDP broadcast.
 277    */
 278   struct GNUNET_PeerIdentity sender;
 279
 280   /**
 281    * Hash of the sender's UDP address.
 282    */
 283   struct GNUNET_HashCode h_address;
 284 };
 285
 286
 287 /**
 288  * Broadcast by peer in LAN announcing its presence.  Unusual in that
 289  * we don't pad these to full MTU, as we cannot prevent being
 290  * recognized in LAN as GNUnet peers if this feature is enabled
 291  * anyway.  Also, the entire message is in cleartext.
 292  */
 293 struct UDPBroadcast
 294 {
 295   /**
 296    * Sender's peer identity.
 297    */
 298   struct GNUNET_PeerIdentity sender;
 299
 300   /**
 301    * Sender's signature of type
 302    * #GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST
 303    */
 304   struct GNUNET_CRYPTO_EddsaSignature sender_sig;
 305 };
 306
 307
 308 /**
 309  * UDP message box.  Always sent encrypted, only allowed after
 310  * the receiver sent a `struct UDPAck` for the base key!
 311  */
 312 struct UDPBox
 313 {
 314   /**
 315    * Key and IV identification code. KDF applied to an acknowledged
 316    * base key and a sequence number.  Sequence numbers must be used
 317    * monotonically increasing up to the maximum specified in
 318    * `struct UDPAck`. Without further `struct UDPAck`s, the sender
 319    * must fall back to sending handshakes!
 320    */
 321   struct GNUNET_ShortHashCode kid;
 322
 323   /**
 324    * 128-bit authentication tag for the following encrypted message,
 325    * from GCM.  MAC starts at the @e body_start that follows and
 326    * extends until the end of the UDP payload.  If the @e hmac is
 327    * wrong, the receiver should check if the message might be a
 328    * `struct UdpHandshakeSignature`.
 329    */
 330   char gcm_tag[GCM_TAG_SIZE];
 331 };
 332
 333
 334 GNUNET_NETWORK_STRUCT_END
 335
 336 /**
 337  * Shared secret we generated for a particular sender or receiver.
 338  */
 339 struct SharedSecret;
 340
 341
 342 /**
 343  * Pre-generated "kid" code (key and IV identification code) to
 344  * quickly derive master key for a `struct UDPBox`.
 345  */
 346 struct KeyCacheEntry
 347 {
 348   /**
 349    * Kept in a DLL.
 350    */
 351   struct KeyCacheEntry *next;
 352
 353   /**
 354    * Kept in a DLL.
 355    */
 356   struct KeyCacheEntry *prev;
 357
 358   /**
 359    * Key and IV identification code. KDF applied to an acknowledged
 360    * base key and a sequence number.  Sequence numbers must be used
 361    * monotonically increasing up to the maximum specified in
 362    * `struct UDPAck`. Without further `struct UDPAck`s, the sender
 363    * must fall back to sending handshakes!
 364    */
 365   struct GNUNET_ShortHashCode kid;
 366
 367   /**
 368    * Corresponding shared secret.
 369    */
 370   struct SharedSecret *ss;
 371
 372   /**
 373    * Sequence number used to derive this entry from master key.
 374    */
 375   uint32_t sequence_number;
 376 };
 377
 378
 379 /**
 380  * Information we track per sender address we have recently been
 381  * in contact with (decryption from sender).
 382  */
 383 struct SenderAddress;
 384
 385 /**
 386  * Information we track per receiving address we have recently been
 387  * in contact with (encryption to receiver).
 388  */
 389 struct ReceiverAddress;
 390
 391 /**
 392  * Shared secret we generated for a particular sender or receiver.
 393  */
 394 struct SharedSecret
 395 {
 396   /**
 397    * Kept in a DLL.
 398    */
 399   struct SharedSecret *next;
 400
 401   /**
 402    * Kept in a DLL.
 403    */
 404   struct SharedSecret *prev;
 405
 406   /**
 407    * Kept in a DLL, sorted by sequence number. Only if we are decrypting.
 408    */
 409   struct KeyCacheEntry *kce_head;
 410
 411   /**
 412    * Kept in a DLL, sorted by sequence number. Only if we are decrypting.
 413    */
 414   struct KeyCacheEntry *kce_tail;
 415
 416   /**
 417    * Sender we use this shared secret with, or NULL.
 418    */
 419   struct SenderAddress *sender;
 420
 421   /**
 422    * Receiver we use this shared secret with, or NULL.
 423    */
 424   struct ReceiverAddress *receiver;
 425
 426   /**
 427    * Master shared secret.
 428    */
 429   struct GNUNET_HashCode master;
 430
 431   /**
 432    * CMAC is used to identify @e master in ACKs.
 433    */
 434   struct GNUNET_HashCode cmac;
 435
 436   /**
 437    * Up to which sequence number did we use this @e master already?
 438    * (for encrypting only)
 439    */
 440   uint32_t sequence_used;
 441
 442   /**
 443    * Up to which sequence number did the other peer allow us to use
 444    * this key, or up to which number did we allow the other peer to
 445    * use this key?
 446    */
 447   uint32_t sequence_allowed;
 448
 449   /**
 450    * Number of active KCN entries.
 451    */
 452   unsigned int active_kce_count;
 453 };
 454
 455
 456 /**
 457  * Information we track per sender address we have recently been
 458  * in contact with (we decrypt messages from the sender).
 459  */
 460 struct SenderAddress
 461 {
 462   /**
 463    * To whom are we talking to.
 464    */
 465   struct GNUNET_PeerIdentity target;
 466
 467   /**
 468    * Entry in sender expiration heap.
 469    */
 470   struct GNUNET_CONTAINER_HeapNode *hn;
 471
 472   /**
 473    * Shared secrets we used with @e target, first used is head.
 474    */
 475   struct SharedSecret *ss_head;
 476
 477   /**
 478    * Shared secrets we used with @e target, last used is tail.
 479    */
 480   struct SharedSecret *ss_tail;
 481
 482   /**
 483    * Address of the other peer.
 484    */
 485   struct sockaddr *address;
 486
 487   /**
 488    * Length of the address.
 489    */
 490   socklen_t address_len;
 491
 492   /**
 493    * Timeout for this sender.
 494    */
 495   struct GNUNET_TIME_Absolute timeout;
 496
 497   /**
 498    * Length of the DLL at @a ss_head.
 499    */
 500   unsigned int num_secrets;
 501
 502   /**
 503    * Which network type does this queue use?
 504    */
 505   enum GNUNET_NetworkType nt;
 506 };
 507
 508
 509 /**
 510  * Information we track per receiving address we have recently been
 511  * in contact with (encryption to receiver).
 512  */
 513 struct ReceiverAddress
 514 {
 515   /**
 516    * To whom are we talking to.
 517    */
 518   struct GNUNET_PeerIdentity target;
 519
 520   /**
 521    * Shared secrets we received from @e target, first used is head.
 522    */
 523   struct SharedSecret *ss_head;
 524
 525   /**
 526    * Shared secrets we received with @e target, last used is tail.
 527    */
 528   struct SharedSecret *ss_tail;
 529
 530   /**
 531    * Address of the receiver in the human-readable format
 532    * with the #COMMUNICATOR_ADDRESS_PREFIX.
 533    */
 534   char *foreign_addr;
 535
 536   /**
 537    * Address of the other peer.
 538    */
 539   struct sockaddr *address;
 540
 541   /**
 542    * Length of the address.
 543    */
 544   socklen_t address_len;
 545
 546   /**
 547    * Entry in sender expiration heap.
 548    */
 549   struct GNUNET_CONTAINER_HeapNode *hn;
 550
 551   /**
 552    * Message queue we are providing for the #ch.
 553    */
 554   struct GNUNET_MQ_Handle *mq;
 555
 556   /**
 557    * handle for this queue with the #ch.
 558    */
 559   struct GNUNET_TRANSPORT_QueueHandle *qh;
 560
 561   /**
 562    * Timeout for this receiver address.
 563    */
 564   struct GNUNET_TIME_Absolute timeout;
 565
 566   /**
 567    * MTU we allowed transport for this receiver right now.
 568    */
 569   size_t mtu;
 570
 571   /**
 572    * Length of the DLL at @a ss_head.
 573    */
 574   unsigned int num_secrets;
 575
 576   /**
 577    * Number of BOX keys from ACKs we have currently
 578    * available for this receiver.
 579    */
 580   unsigned int acks_available;
 581
 582   /**
 583    * Which network type does this queue use?
 584    */
 585   enum GNUNET_NetworkType nt;
 586 };
 587
 588
 589 /**
 590  * Interface we broadcast our presence on.
 591  */
 592 struct BroadcastInterface
 593 {
 594   /**
 595    * Kept in a DLL.
 596    */
 597   struct BroadcastInterface *next;
 598
 599   /**
 600    * Kept in a DLL.
 601    */
 602   struct BroadcastInterface *prev;
 603
 604   /**
 605    * Task for this broadcast interface.
 606    */
 607   struct GNUNET_SCHEDULER_Task *broadcast_task;
 608
 609   /**
 610    * Sender's address of the interface.
 611    */
 612   struct sockaddr *sa;
 613
 614   /**
 615    * Broadcast address to use on the interface.
 616    */
 617   struct sockaddr *ba;
 618
 619   /**
 620    * Message we broadcast on this interface.
 621    */
 622   struct UDPBroadcast bcm;
 623
 624   /**
 625    * If this is an IPv6 interface, this is the request
 626    * we use to join/leave the group.
 627    */
 628   struct ipv6_mreq mcreq;
 629
 630   /**
 631    * Number of bytes in @e sa.
 632    */
 633   socklen_t salen;
 634
 635   /**
 636    * Was this interface found in the last #iface_proc() scan?
 637    */
 638   int found;
 639 };
 640
 641
 642 /**
 643  * Cache of pre-generated key IDs.
 644  */
 645 static struct GNUNET_CONTAINER_MultiShortmap *key_cache;
 646
 647 /**
 648  * ID of read task
 649  */
 650 static struct GNUNET_SCHEDULER_Task *read_task;
 651
 652 /**
 653  * ID of timeout task
 654  */
 655 static struct GNUNET_SCHEDULER_Task *timeout_task;
 656
 657 /**
 658  * ID of master broadcast task
 659  */
 660 static struct GNUNET_SCHEDULER_Task *broadcast_task;
 661
 662 /**
 663  * For logging statistics.
 664  */
 665 static struct GNUNET_STATISTICS_Handle *stats;
 666
 667 /**
 668  * Our environment.
 669  */
 670 static struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
 671
 672 /**
 673  * Receivers (map from peer identity to `struct ReceiverAddress`)
 674  */
 675 static struct GNUNET_CONTAINER_MultiPeerMap *receivers;
 676
 677 /**
 678  * Senders (map from peer identity to `struct SenderAddress`)
 679  */
 680 static struct GNUNET_CONTAINER_MultiPeerMap *senders;
 681
 682 /**
 683  * Expiration heap for senders (contains `struct SenderAddress`)
 684  */
 685 static struct GNUNET_CONTAINER_Heap *senders_heap;
 686
 687 /**
 688  * Expiration heap for receivers (contains `struct ReceiverAddress`)
 689  */
 690 static struct GNUNET_CONTAINER_Heap *receivers_heap;
 691
 692 /**
 693  * Broadcast interface tasks. Kept in a DLL.
 694  */
 695 static struct BroadcastInterface *bi_head;
 696
 697 /**
 698  * Broadcast interface tasks. Kept in a DLL.
 699  */
 700 static struct BroadcastInterface *bi_tail;
 701
 702 /**
 703  * Our socket.
 704  */
 705 static struct GNUNET_NETWORK_Handle *udp_sock;
 706
 707 /**
 708  * #GNUNET_YES if #udp_sock supports IPv6.
 709  */
 710 static int have_v6_socket;
 711
 712 /**
 713  * Our public key.
 714  */
 715 static struct GNUNET_PeerIdentity my_identity;
 716
 717 /**
 718  * Our private key.
 719  */
 720 static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
 721
 722 /**
 723  * Our configuration.
 724  */
 725 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 726
 727 /**
 728  * Our handle to report addresses for validation to TRANSPORT.
 729  */
 730 static struct GNUNET_TRANSPORT_ApplicationHandle *ah;
 731
 732 /**
 733  * Network scanner to determine network types.
 734  */
 735 static struct GNUNET_NT_InterfaceScanner *is;
 736
 737 /**
 738  * Connection to NAT service.
 739  */
 740 static struct GNUNET_NAT_Handle *nat;
 741
 742 /**
 743  * Port number to which we are actually bound.
 744  */
 745 static uint16_t my_port;
 746
 747
 748 /**
 749  * An interface went away, stop broadcasting on it.
 750  *
 751  * @param bi entity to close down
 752  */
 753 static void
 754 bi_destroy (struct BroadcastInterface *bi)
 755 {
 756   if (AF_INET6 == bi->sa->sa_family)
 757   {
 758     /* Leave the multicast group */
 759     if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
 760                                                        IPPROTO_IPV6,
 761                                                        IPV6_LEAVE_GROUP,
 762                                                        &bi->mcreq,
 763                                                        sizeof(bi->mcreq)))
 764     {
 765       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
 766     }
 767   }
 768   GNUNET_CONTAINER_DLL_remove (bi_head, bi_tail, bi);
 769   GNUNET_SCHEDULER_cancel (bi->broadcast_task);
 770   GNUNET_free (bi->sa);
 771   GNUNET_free_non_null (bi->ba);
 772   GNUNET_free (bi);
 773 }
 774
 775
 776 /**
 777  * Destroys a receiving state due to timeout or shutdown.
 778  *
 779  * @param receiver entity to close down
 780  */
 781 static void
 782 receiver_destroy (struct ReceiverAddress *receiver)
 783 {
 784   struct GNUNET_MQ_Handle *mq;
 785
 786   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 787               "Disconnecting receiver for peer `%s'\n",
 788               GNUNET_i2s (&receiver->target));
 789   if (NULL != (mq = receiver->mq))
 790   {
 791     receiver->mq = NULL;
 792     GNUNET_MQ_destroy (mq);
 793   }
 794   if (NULL != receiver->qh)
 795   {
 796     GNUNET_TRANSPORT_communicator_mq_del (receiver->qh);
 797     receiver->qh = NULL;
 798   }
 799   GNUNET_assert (GNUNET_YES ==
 800                  GNUNET_CONTAINER_multipeermap_remove (receivers,
 801                                                        &receiver->target,
 802                                                        receiver));
 803   GNUNET_assert (receiver == GNUNET_CONTAINER_heap_remove_node (receiver->hn));
 804   GNUNET_STATISTICS_set (stats,
 805                          "# receivers active",
 806                          GNUNET_CONTAINER_multipeermap_size (receivers),
 807                          GNUNET_NO);
 808   GNUNET_free (receiver->address);
 809   GNUNET_free (receiver->foreign_addr);
 810   GNUNET_free (receiver);
 811 }
 812
 813
 814 /**
 815  * Free memory used by key cache entry.
 816  *
 817  * @param kce the key cache entry
 818  */
 819 static void
 820 kce_destroy (struct KeyCacheEntry *kce)
 821 {
 822   struct SharedSecret *ss = kce->ss;
 823
 824   ss->active_kce_count--;
 825   GNUNET_CONTAINER_DLL_remove (ss->kce_head, ss->kce_tail, kce);
 826   GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (key_cache,
 827                                                                       &kce->kid,
 828                                                                       kce));
 829   GNUNET_free (kce);
 830 }
 831
 832
 833 /**
 834  * Compute @a kid.
 835  *
 836  * @param msec master secret for HMAC calculation
 837  * @param serial number for the @a smac calculation
 838  * @param kid[out] where to write the key ID
 839  */
 840 static void
 841 get_kid (const struct GNUNET_HashCode *msec,
 842          uint32_t serial,
 843          struct GNUNET_ShortHashCode *kid)
 844 {
 845   uint32_t sid = htonl (serial);
 846
 847   GNUNET_CRYPTO_hkdf (kid,
 848                       sizeof(*kid),
 849                       GCRY_MD_SHA512,
 850                       GCRY_MD_SHA256,
 851                       &sid,
 852                       sizeof(sid),
 853                       msec,
 854                       sizeof(*msec),
 855                       "UDP-KID",
 856                       strlen ("UDP-KID"),
 857                       NULL,
 858                       0);
 859 }
 860
 861
 862 /**
 863  * Setup key cache entry for sequence number @a seq and shared secret @a ss.
 864  *
 865  * @param ss shared secret
 866  * @param seq sequence number for the key cache entry
 867  */
 868 static void
 869 kce_generate (struct SharedSecret *ss, uint32_t seq)
 870 {
 871   struct KeyCacheEntry *kce;
 872
 873   GNUNET_assert (0 < seq);
 874   kce = GNUNET_new (struct KeyCacheEntry);
 875   kce->ss = ss;
 876   kce->sequence_number = seq;
 877   get_kid (&ss->master, seq, &kce->kid);
 878   GNUNET_CONTAINER_DLL_insert (ss->kce_head, ss->kce_tail, kce);
 879   ss->active_kce_count++;
 880   (void) GNUNET_CONTAINER_multishortmap_put (
 881     key_cache,
 882     &kce->kid,
 883     kce,
 884     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
 885   GNUNET_STATISTICS_set (stats,
 886                          "# KIDs active",
 887                          GNUNET_CONTAINER_multishortmap_size (key_cache),
 888                          GNUNET_NO);
 889 }
 890
 891
 892 /**
 893  * Destroy @a ss and associated key cache entries.
 894  *
 895  * @param ss shared secret to destroy
 896  */
 897 static void
 898 secret_destroy (struct SharedSecret *ss)
 899 {
 900   struct SenderAddress *sender;
 901   struct ReceiverAddress *receiver;
 902   struct KeyCacheEntry *kce;
 903
 904   if (NULL != (sender = ss->sender))
 905   {
 906     GNUNET_CONTAINER_DLL_remove (sender->ss_head, sender->ss_tail, ss);
 907     sender->num_secrets--;
 908   }
 909   if (NULL != (receiver = ss->receiver))
 910   {
 911     GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
 912     receiver->num_secrets--;
 913     receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used);
 914   }
 915   while (NULL != (kce = ss->kce_head))
 916     kce_destroy (kce);
 917   GNUNET_STATISTICS_update (stats, "# Secrets active", -1, GNUNET_NO);
 918   GNUNET_STATISTICS_set (stats,
 919                          "# KIDs active",
 920                          GNUNET_CONTAINER_multishortmap_size (key_cache),
 921                          GNUNET_NO);
 922   GNUNET_free (ss);
 923 }
 924
 925
 926 /**
 927  * Functions with this signature are called whenever we need
 928  * to close a sender's state due to timeout.
 929  *
 930  * @param sender entity to close down
 931  */
 932 static void
 933 sender_destroy (struct SenderAddress *sender)
 934 {
 935   GNUNET_assert (
 936     GNUNET_YES ==
 937     GNUNET_CONTAINER_multipeermap_remove (senders, &sender->target, sender));
 938   GNUNET_assert (sender == GNUNET_CONTAINER_heap_remove_node (sender->hn));
 939   GNUNET_STATISTICS_set (stats,
 940                          "# senders active",
 941                          GNUNET_CONTAINER_multipeermap_size (senders),
 942                          GNUNET_NO);
 943   GNUNET_free (sender->address);
 944   GNUNET_free (sender);
 945 }
 946
 947
 948 /**
 949  * Compute @a key and @a iv.
 950  *
 951  * @param msec master secret for calculation
 952  * @param serial number for the @a smac calculation
 953  * @param key[out] where to write the decrption key
 954  * @param iv[out] where to write the IV
 955  */
 956 static void
 957 get_iv_key (const struct GNUNET_HashCode *msec,
 958             uint32_t serial,
 959             char key[AES_KEY_SIZE],
 960             char iv[AES_IV_SIZE])
 961 {
 962   uint32_t sid = htonl (serial);
 963   char res[AES_KEY_SIZE + AES_IV_SIZE];
 964
 965   GNUNET_CRYPTO_hkdf (res,
 966                       sizeof(res),
 967                       GCRY_MD_SHA512,
 968                       GCRY_MD_SHA256,
 969                       &sid,
 970                       sizeof(sid),
 971                       msec,
 972                       sizeof(*msec),
 973                       "UDP-IV-KEY",
 974                       strlen ("UDP-IV-KEY"),
 975                       NULL,
 976                       0);
 977   memcpy (key, res, AES_KEY_SIZE);
 978   memcpy (iv, &res[AES_KEY_SIZE], AES_IV_SIZE);
 979 }
 980
 981
 982 /**
 983  * Increment sender timeout due to activity.
 984  *
 985  * @param sender address for which the timeout should be rescheduled
 986  */
 987 static void
 988 reschedule_sender_timeout (struct SenderAddress *sender)
 989 {
 990   sender->timeout =
 991     GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
 992   GNUNET_CONTAINER_heap_update_cost (sender->hn, sender->timeout.abs_value_us);
 993 }
 994
 995
 996 /**
 997  * Increment receiver timeout due to activity.
 998  *
 999  * @param receiver address for which the timeout should be rescheduled
1000  */
1001 static void
1002 reschedule_receiver_timeout (struct ReceiverAddress *receiver)
1003 {
1004   receiver->timeout =
1005     GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
1006   GNUNET_CONTAINER_heap_update_cost (receiver->hn,
1007                                      receiver->timeout.abs_value_us);
1008 }
1009
1010
1011 /**
1012  * Task run to check #receiver_heap and #sender_heap for timeouts.
1013  *
1014  * @param cls unused, NULL
1015  */
1016 static void
1017 check_timeouts (void *cls)
1018 {
1019   struct GNUNET_TIME_Relative st;
1020   struct GNUNET_TIME_Relative rt;
1021   struct GNUNET_TIME_Relative delay;
1022   struct ReceiverAddress *receiver;
1023   struct SenderAddress *sender;
1024
1025   (void) cls;
1026   timeout_task = NULL;
1027   rt = GNUNET_TIME_UNIT_FOREVER_REL;
1028   while (NULL != (receiver = GNUNET_CONTAINER_heap_peek (receivers_heap)))
1029   {
1030     rt = GNUNET_TIME_absolute_get_remaining (receiver->timeout);
1031     if (0 != rt.rel_value_us)
1032       break;
1033     receiver_destroy (receiver);
1034   }
1035   st = GNUNET_TIME_UNIT_FOREVER_REL;
1036   while (NULL != (sender = GNUNET_CONTAINER_heap_peek (senders_heap)))
1037   {
1038     st = GNUNET_TIME_absolute_get_remaining (sender->timeout);
1039     if (0 != st.rel_value_us)
1040       break;
1041     sender_destroy (sender);
1042   }
1043   delay = GNUNET_TIME_relative_min (rt, st);
1044   if (delay.rel_value_us < GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
1045     timeout_task = GNUNET_SCHEDULER_add_delayed (delay, &check_timeouts, NULL);
1046 }
1047
1048
1049 /**
1050  * Calcualte cmac from master in @a ss.
1051  *
1052  * @param ss[in,out] data structure to complete
1053  */
1054 static void
1055 calculate_cmac (struct SharedSecret *ss)
1056 {
1057   GNUNET_CRYPTO_hkdf (&ss->cmac,
1058                       sizeof(ss->cmac),
1059                       GCRY_MD_SHA512,
1060                       GCRY_MD_SHA256,
1061                       "CMAC",
1062                       strlen ("CMAC"),
1063                       &ss->master,
1064                       sizeof(ss->master),
1065                       "UDP-CMAC",
1066                       strlen ("UDP-CMAC"),
1067                       NULL,
1068                       0);
1069 }
1070
1071
1072 /**
1073  * We received @a plaintext_len bytes of @a plaintext from a @a sender.
1074  * Pass it on to CORE.
1075  *
1076  * @param queue the queue that received the plaintext
1077  * @param plaintext the plaintext that was received
1078  * @param plaintext_len number of bytes of plaintext received
1079  */
1080 static void
1081 pass_plaintext_to_core (struct SenderAddress *sender,
1082                         const void *plaintext,
1083                         size_t plaintext_len)
1084 {
1085   const struct GNUNET_MessageHeader *hdr = plaintext;
1086
1087   while (ntohs (hdr->size) < plaintext_len)
1088   {
1089     GNUNET_STATISTICS_update (stats,
1090                               "# bytes given to core",
1091                               ntohs (hdr->size),
1092                               GNUNET_NO);
1093     (void)
1094     GNUNET_TRANSPORT_communicator_receive (ch,
1095                                            &sender->target,
1096                                            hdr,
1097                                            ADDRESS_VALIDITY_PERIOD,
1098                                            NULL   /* no flow control possible */
1099                                            ,
1100                                            NULL);
1101     /* move on to next message, if any */
1102     plaintext_len -= ntohs (hdr->size);
1103     if (plaintext_len < sizeof(*hdr))
1104       break;
1105     hdr = plaintext + ntohs (hdr->size);
1106   }
1107   GNUNET_STATISTICS_update (stats,
1108                             "# bytes padding discarded",
1109                             plaintext_len,
1110                             GNUNET_NO);
1111 }
1112
1113
1114 /**
1115  * Setup @a cipher based on shared secret @a msec and
1116  * serial number @a serial.
1117  *
1118  * @param msec master shared secret
1119  * @param serial serial number of cipher to set up
1120  * @param cipher[out] cipher to initialize
1121  */
1122 static void
1123 setup_cipher (const struct GNUNET_HashCode *msec,
1124               uint32_t serial,
1125               gcry_cipher_hd_t *cipher)
1126 {
1127   char key[AES_KEY_SIZE];
1128   char iv[AES_IV_SIZE];
1129
1130   gcry_cipher_open (cipher,
1131                     GCRY_CIPHER_AES256 /* low level: go for speed */,
1132                     GCRY_CIPHER_MODE_GCM,
1133                     0 /* flags */);
1134   get_iv_key (msec, serial, key, iv);
1135   gcry_cipher_setkey (*cipher, key, sizeof(key));
1136   gcry_cipher_setiv (*cipher, iv, sizeof(iv));
1137 }
1138
1139
1140 /**
1141  * Try to decrypt @a buf using shared secret @a ss and key/iv
1142  * derived using @a serial.
1143  *
1144  * @param ss shared secret
1145  * @param tag GCM authentication tag
1146  * @param serial serial number to use
1147  * @param in_buf input buffer to decrypt
1148  * @param in_buf_size number of bytes in @a in_buf and available in @a out_buf
1149  * @param out_buf where to write the result
1150  * @return #GNUNET_OK on success
1151  */
1152 static int
1153 try_decrypt (const struct SharedSecret *ss,
1154              const char tag[GCM_TAG_SIZE],
1155              uint32_t serial,
1156              const char *in_buf,
1157              size_t in_buf_size,
1158              char *out_buf)
1159 {
1160   gcry_cipher_hd_t cipher;
1161
1162   setup_cipher (&ss->master, serial, &cipher);
1163   GNUNET_assert (
1164     0 ==
1165     gcry_cipher_decrypt (cipher, out_buf, in_buf_size, in_buf, in_buf_size));
1166   if (0 != gcry_cipher_checktag (cipher, tag, GCM_TAG_SIZE))
1167   {
1168     gcry_cipher_close (cipher);
1169     GNUNET_STATISTICS_update (stats,
1170                               "# AEAD authentication failures",
1171                               1,
1172                               GNUNET_NO);
1173     return GNUNET_SYSERR;
1174   }
1175   gcry_cipher_close (cipher);
1176   return GNUNET_OK;
1177 }
1178
1179
1180 /**
1181  * Setup shared secret for decryption.
1182  *
1183  * @param ephemeral ephemeral key we received from the other peer
1184  * @return new shared secret
1185  */
1186 static struct SharedSecret *
1187 setup_shared_secret_dec (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral)
1188 {
1189   struct SharedSecret *ss;
1190
1191   ss = GNUNET_new (struct SharedSecret);
1192   GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &ss->master);
1193   return ss;
1194 }
1195
1196
1197 /**
1198  * Setup shared secret for encryption.
1199  *
1200  * @param ephemeral ephemeral key we are sending to the other peer
1201  * @param receiver[in,out] queue to initialize encryption key for
1202  * @return new shared secret
1203  */
1204 static struct SharedSecret *
1205 setup_shared_secret_enc (const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral,
1206                          struct ReceiverAddress *receiver)
1207 {
1208   struct SharedSecret *ss;
1209
1210   ss = GNUNET_new (struct SharedSecret);
1211   GNUNET_CRYPTO_ecdh_eddsa (ephemeral,
1212                             &receiver->target.public_key,
1213                             &ss->master);
1214   calculate_cmac (ss);
1215   ss->receiver = receiver;
1216   GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
1217   receiver->num_secrets++;
1218   GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
1219   return ss;
1220 }
1221
1222
1223 /**
1224  * Setup the MQ for the @a receiver.  If a queue exists,
1225  * the existing one is destroyed.  Then the MTU is
1226  * recalculated and a fresh queue is initialized.
1227  *
1228  * @param receiver receiver to setup MQ for
1229  */
1230 static void
1231 setup_receiver_mq (struct ReceiverAddress *receiver);
1232
1233
1234 /**
1235  * We received an ACK for @a pid. Check if it is for
1236  * the receiver in @a value and if so, handle it and
1237  * return #GNUNET_NO. Otherwise, return #GNUNET_YES.
1238  *
1239  * @param cls a `const struct UDPAck`
1240  * @param pid peer the ACK is from
1241  * @param value a `struct ReceiverAddress`
1242  * @return #GNUNET_YES to continue to iterate
1243  */
1244 static int
1245 handle_ack (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
1246 {
1247   const struct UDPAck *ack = cls;
1248   struct ReceiverAddress *receiver = value;
1249
1250   (void) pid;
1251   for (struct SharedSecret *ss = receiver->ss_head; NULL != ss; ss = ss->next)
1252   {
1253     if (0 == memcmp (&ack->cmac, &ss->cmac, sizeof(struct GNUNET_HashCode)))
1254     {
1255       uint32_t allowed;
1256
1257       allowed = ntohl (ack->sequence_max);
1258
1259       if (allowed > ss->sequence_allowed)
1260       {
1261         receiver->acks_available += (allowed - ss->sequence_allowed);
1262         if ((allowed - ss->sequence_allowed) == receiver->acks_available)
1263         {
1264           /* we just incremented from zero => MTU change! */
1265           setup_receiver_mq (receiver);
1266         }
1267         ss->sequence_allowed = allowed;
1268         /* move ss to head to avoid discarding it anytime soon! */
1269         GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
1270         GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
1271       }
1272       return GNUNET_NO;
1273     }
1274   }
1275   return GNUNET_YES;
1276 }
1277
1278
1279 /**
1280  * Test if we have received a valid message in plaintext.
1281  * If so, handle it.
1282  *
1283  * @param sender peer to process inbound plaintext for
1284  * @param buf buffer we received
1285  * @param buf_size number of bytes in @a buf
1286  */
1287 static void
1288 try_handle_plaintext (struct SenderAddress *sender,
1289                       const void *buf,
1290                       size_t buf_size)
1291 {
1292   const struct GNUNET_MessageHeader *hdr =
1293     (const struct GNUNET_MessageHeader *) buf;
1294   const struct UDPAck *ack = (const struct UDPAck *) buf;
1295   uint16_t type;
1296
1297   if (sizeof(*hdr) > buf_size)
1298     return; /* not even a header */
1299   if (ntohs (hdr->size) > buf_size)
1300     return; /* not even a header */
1301   type = ntohs (hdr->type);
1302   switch (type)
1303   {
1304   case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK:
1305     /* lookup master secret by 'cmac', then update sequence_max */
1306     GNUNET_CONTAINER_multipeermap_get_multiple (receivers,
1307                                                 &sender->target,
1308                                                 &handle_ack,
1309                                                 (void *) ack);
1310     /* There could be more messages after the ACK, handle those as well */
1311     buf += ntohs (hdr->size);
1312     buf_size -= ntohs (hdr->size);
1313     pass_plaintext_to_core (sender, buf, buf_size);
1314     break;
1315
1316   case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD:
1317     /* skip padding */
1318     break;
1319
1320   default:
1321     pass_plaintext_to_core (sender, buf, buf_size);
1322   }
1323 }
1324
1325
1326 /**
1327  * We established a shared secret with a sender. We should try to send
1328  * the sender an `struct UDPAck` at the next opportunity to allow the
1329  * sender to use @a ss longer (assuming we did not yet already
1330  * recently).
1331  *
1332  * @param ss shared secret to generate ACKs for
1333  */
1334 static void
1335 consider_ss_ack (struct SharedSecret *ss)
1336 {
1337   GNUNET_assert (NULL != ss->sender);
1338   /* drop ancient KeyCacheEntries */
1339   while ((NULL != ss->kce_head) &&
1340          (MAX_SQN_DELTA <
1341           ss->kce_head->sequence_number - ss->kce_tail->sequence_number))
1342     kce_destroy (ss->kce_tail);
1343   if (ss->active_kce_count < KCN_THRESHOLD)
1344   {
1345     struct UDPAck ack;
1346
1347     while (ss->active_kce_count < KCN_TARGET)
1348       kce_generate (ss, ++ss->sequence_allowed);
1349     ack.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK);
1350     ack.header.size = htons (sizeof(ack));
1351     ack.sequence_max = htonl (ss->sequence_allowed);
1352     ack.cmac = ss->cmac;
1353     GNUNET_TRANSPORT_communicator_notify (ch,
1354                                           &ss->sender->target,
1355                                           COMMUNICATOR_ADDRESS_PREFIX,
1356                                           &ack.header);
1357   }
1358 }
1359
1360
1361 /**
1362  * We received a @a box with matching @a kce.  Decrypt and process it.
1363  *
1364  * @param box the data we received
1365  * @param box_len number of bytes in @a box
1366  * @param kce key index to decrypt @a box
1367  */
1368 static void
1369 decrypt_box (const struct UDPBox *box,
1370              size_t box_len,
1371              struct KeyCacheEntry *kce)
1372 {
1373   struct SharedSecret *ss = kce->ss;
1374   char out_buf[box_len - sizeof(*box)];
1375
1376   GNUNET_assert (NULL != ss->sender);
1377   if (GNUNET_OK != try_decrypt (ss,
1378                                 box->gcm_tag,
1379                                 kce->sequence_number,
1380                                 (const char *) &box[1],
1381                                 sizeof(out_buf),
1382                                 out_buf))
1383   {
1384     GNUNET_STATISTICS_update (stats,
1385                               "# Decryption failures with valid KCE",
1386                               1,
1387                               GNUNET_NO);
1388     kce_destroy (kce);
1389     return;
1390   }
1391   kce_destroy (kce);
1392   GNUNET_STATISTICS_update (stats,
1393                             "# bytes decrypted with BOX",
1394                             sizeof(out_buf),
1395                             GNUNET_NO);
1396   try_handle_plaintext (ss->sender, out_buf, sizeof(out_buf));
1397   consider_ss_ack (ss);
1398 }
1399
1400
1401 /**
1402  * Closure for #find_sender_by_address()
1403  */
1404 struct SearchContext
1405 {
1406   /**
1407    * Address we are looking for.
1408    */
1409   const struct sockaddr *address;
1410
1411   /**
1412    * Number of bytes in @e address.
1413    */
1414   socklen_t address_len;
1415
1416   /**
1417    * Return value to set if we found a match.
1418    */
1419   struct SenderAddress *sender;
1420 };
1421
1422
1423 /**
1424  * Find existing `struct SenderAddress` by matching addresses.
1425  *
1426  * @param cls a `struct SearchContext`
1427  * @param key ignored, must match already
1428  * @param value a `struct SenderAddress`
1429  * @return #GNUNET_YES if not found (continue to search), #GNUNET_NO if found
1430  */
1431 static int
1432 find_sender_by_address (void *cls,
1433                         const struct GNUNET_PeerIdentity *key,
1434                         void *value)
1435 {
1436   struct SearchContext *sc = cls;
1437   struct SenderAddress *sender = value;
1438
1439   if ((sender->address_len == sc->address_len) &&
1440       (0 == memcmp (sender->address, sc->address, sender->address_len)))
1441   {
1442     sc->sender = sender;
1443     return GNUNET_NO;   /* stop iterating! */
1444   }
1445   return GNUNET_YES;
1446 }
1447
1448
1449 /**
1450  * Create sender address for @a target.  Note that we
1451  * might already have one, so a fresh one is only allocated
1452  * if one does not yet exist for @a address.
1453  *
1454  * @param target peer to generate address for
1455  * @param address target address
1456  * @param address_len number of bytes in @a address
1457  * @return data structure to keep track of key material for
1458  *         decrypting data from @a target
1459  */
1460 static struct SenderAddress *
1461 setup_sender (const struct GNUNET_PeerIdentity *target,
1462               const struct sockaddr *address,
1463               socklen_t address_len)
1464 {
1465   struct SenderAddress *sender;
1466   struct SearchContext sc = { .address = address,
1467                               .address_len = address_len,
1468                               .sender = NULL };
1469
1470   GNUNET_CONTAINER_multipeermap_get_multiple (senders,
1471                                               target,
1472                                               &find_sender_by_address,
1473                                               &sc);
1474   if (NULL != sc.sender)
1475   {
1476     reschedule_sender_timeout (sc.sender);
1477     return sc.sender;
1478   }
1479   sender = GNUNET_new (struct SenderAddress);
1480   sender->target = *target;
1481   sender->address = GNUNET_memdup (address, address_len);
1482   sender->address_len = address_len;
1483   (void) GNUNET_CONTAINER_multipeermap_put (
1484     senders,
1485     &sender->target,
1486     sender,
1487     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
1488   GNUNET_STATISTICS_set (stats,
1489                          "# senders active",
1490                          GNUNET_CONTAINER_multipeermap_size (receivers),
1491                          GNUNET_NO);
1492   sender->timeout =
1493     GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
1494   sender->hn = GNUNET_CONTAINER_heap_insert (senders_heap,
1495                                              sender,
1496                                              sender->timeout.abs_value_us);
1497   sender->nt = GNUNET_NT_scanner_get_type (is, address, address_len);
1498   if (NULL == timeout_task)
1499     timeout_task = GNUNET_SCHEDULER_add_now (&check_timeouts, NULL);
1500   return sender;
1501 }
1502
1503
1504 /**
1505  * Check signature from @a uc against @a ephemeral.
1506  *
1507  * @param ephermal key that is signed
1508  * @param uc signature of claimant
1509  * @return #GNUNET_OK if signature is valid
1510  */
1511 static int
1512 verify_confirmation (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral,
1513                      const struct UDPConfirmation *uc)
1514 {
1515   struct UdpHandshakeSignature uhs;
1516
1517   uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE);
1518   uhs.purpose.size = htonl (sizeof(uhs));
1519   uhs.sender = uc->sender;
1520   uhs.receiver = my_identity;
1521   uhs.ephemeral = *ephemeral;
1522   uhs.monotonic_time = uc->monotonic_time;
1523   return GNUNET_CRYPTO_eddsa_verify (
1524     GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE,
1525     &uhs.purpose,
1526     &uc->sender_sig,
1527     &uc->sender.public_key);
1528 }
1529
1530
1531 /**
1532  * Converts @a address to the address string format used by this
1533  * communicator in HELLOs.
1534  *
1535  * @param address the address to convert, must be AF_INET or AF_INET6.
1536  * @param address_len number of bytes in @a address
1537  * @return string representation of @a address
1538  */
1539 static char *
1540 sockaddr_to_udpaddr_string (const struct sockaddr *address,
1541                             socklen_t address_len)
1542 {
1543   char *ret;
1544
1545   switch (address->sa_family)
1546   {
1547   case AF_INET:
1548     GNUNET_asprintf (&ret,
1549                      "%s-%s",
1550                      COMMUNICATOR_ADDRESS_PREFIX,
1551                      GNUNET_a2s (address, address_len));
1552     break;
1553
1554   case AF_INET6:
1555     GNUNET_asprintf (&ret,
1556                      "%s-%s",
1557                      COMMUNICATOR_ADDRESS_PREFIX,
1558                      GNUNET_a2s (address, address_len));
1559     break;
1560
1561   default:
1562     GNUNET_assert (0);
1563   }
1564   return ret;
1565 }
1566
1567
1568 /**
1569  * Socket read task.
1570  *
1571  * @param cls NULL
1572  */
1573 static void
1574 sock_read (void *cls)
1575 {
1576   struct sockaddr_storage sa;
1577   socklen_t salen = sizeof(sa);
1578   char buf[UINT16_MAX];
1579   ssize_t rcvd;
1580
1581   (void) cls;
1582   read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
1583                                              udp_sock,
1584                                              &sock_read,
1585                                              NULL);
1586   rcvd = GNUNET_NETWORK_socket_recvfrom (udp_sock,
1587                                          buf,
1588                                          sizeof(buf),
1589                                          (struct sockaddr *) &sa,
1590                                          &salen);
1591   if (-1 == rcvd)
1592   {
1593     GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv");
1594     return;
1595   }
1596   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1597               "Read %lu bytes\n", rcvd);
1598   /* first, see if it is a UDPBox */
1599   if (rcvd > sizeof(struct UDPBox))
1600   {
1601     const struct UDPBox *box;
1602     struct KeyCacheEntry *kce;
1603
1604     box = (const struct UDPBox *) buf;
1605     kce = GNUNET_CONTAINER_multishortmap_get (key_cache, &box->kid);
1606     if (NULL != kce)
1607     {
1608       decrypt_box (box, (size_t) rcvd, kce);
1609       return;
1610     }
1611   }
1612
1613   /* next, check if it is a broadcast */
1614   if (sizeof(struct UDPBroadcast) == rcvd)
1615   {
1616     const struct UDPBroadcast *ub;
1617     struct UdpBroadcastSignature uhs;
1618
1619     ub = (const struct UDPBroadcast *) buf;
1620     uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST);
1621     uhs.purpose.size = htonl (sizeof(uhs));
1622     uhs.sender = ub->sender;
1623     GNUNET_CRYPTO_hash (&sa, salen, &uhs.h_address);
1624     if (GNUNET_OK ==
1625         GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST,
1626                                     &uhs.purpose,
1627                                     &ub->sender_sig,
1628                                     &ub->sender.public_key))
1629     {
1630       char *addr_s;
1631       enum GNUNET_NetworkType nt;
1632
1633       addr_s =
1634         sockaddr_to_udpaddr_string ((const struct sockaddr *) &sa, salen);
1635       GNUNET_STATISTICS_update (stats, "# broadcasts received", 1, GNUNET_NO);
1636       /* use our own mechanism to determine network type */
1637       nt =
1638         GNUNET_NT_scanner_get_type (is, (const struct sockaddr *) &sa, salen);
1639       GNUNET_TRANSPORT_application_validate (ah, &ub->sender, nt, addr_s);
1640       GNUNET_free (addr_s);
1641       return;
1642     }
1643     /* continue with KX, mostly for statistics... */
1644   }
1645
1646
1647   /* finally, test if it is a KX */
1648   if (rcvd < sizeof(struct UDPConfirmation) + sizeof(struct InitialKX))
1649   {
1650     GNUNET_STATISTICS_update (stats,
1651                               "# messages dropped (no kid, too small for KX)",
1652                               1,
1653                               GNUNET_NO);
1654     return;
1655   }
1656   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1657               "Got KX\n");
1658   {
1659     const struct InitialKX *kx;
1660     struct SharedSecret *ss;
1661     char pbuf[rcvd - sizeof(struct InitialKX)];
1662     const struct UDPConfirmation *uc;
1663     struct SenderAddress *sender;
1664
1665     kx = (const struct InitialKX *) buf;
1666     ss = setup_shared_secret_dec (&kx->ephemeral);
1667     if (GNUNET_OK != try_decrypt (ss,
1668                                   kx->gcm_tag,
1669                                   0,
1670                                   &buf[sizeof(*kx)],
1671                                   sizeof(pbuf),
1672                                   pbuf))
1673     {
1674       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1675                   "Unable to decrypt tag, dropping...\n");
1676       GNUNET_free (ss);
1677       GNUNET_STATISTICS_update (
1678         stats,
1679         "# messages dropped (no kid, AEAD decryption failed)",
1680         1,
1681         GNUNET_NO);
1682       return;
1683     }
1684     uc = (const struct UDPConfirmation *) pbuf;
1685     if (GNUNET_OK != verify_confirmation (&kx->ephemeral, uc))
1686     {
1687       GNUNET_break_op (0);
1688       GNUNET_free (ss);
1689       GNUNET_STATISTICS_update (stats,
1690                                 "# messages dropped (sender signature invalid)",
1691                                 1,
1692                                 GNUNET_NO);
1693       return;
1694     }
1695     calculate_cmac (ss);
1696     sender = setup_sender (&uc->sender, (const struct sockaddr *) &sa, salen);
1697     ss->sender = sender;
1698     GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss);
1699     sender->num_secrets++;
1700     GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
1701     GNUNET_STATISTICS_update (stats,
1702                               "# messages decrypted without BOX",
1703                               1,
1704                               GNUNET_NO);
1705     try_handle_plaintext (sender, &uc[1], sizeof(pbuf) - sizeof(*uc));
1706     consider_ss_ack (ss);
1707     if (sender->num_secrets > MAX_SECRETS)
1708       secret_destroy (sender->ss_tail);
1709   }
1710 }
1711
1712
1713 /**
1714  * Convert UDP bind specification to a `struct sockaddr *`
1715  *
1716  * @param bindto bind specification to convert
1717  * @param[out] sock_len set to the length of the address
1718  * @return converted bindto specification
1719  */
1720 static struct sockaddr *
1721 udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
1722 {
1723   struct sockaddr *in;
1724   unsigned int port;
1725   char dummy[2];
1726   char *colon;
1727   char *cp;
1728
1729   if (1 == sscanf (bindto, "%u%1s", &port, dummy))
1730   {
1731     /* interpreting value as just a PORT number */
1732     if (port > UINT16_MAX)
1733     {
1734       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1735                   "BINDTO specification `%s' invalid: value too large for port\n",
1736                   bindto);
1737       return NULL;
1738     }
1739     if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
1740         (GNUNET_YES ==
1741          GNUNET_CONFIGURATION_get_value_yesno (cfg,
1742                                                COMMUNICATOR_CONFIG_SECTION,
1743                                                "DISABLE_V6")))
1744     {
1745       struct sockaddr_in *i4;
1746
1747       i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
1748       i4->sin_family = AF_INET;
1749       i4->sin_port = htons ((uint16_t) port);
1750       *sock_len = sizeof(struct sockaddr_in);
1751       in = (struct sockaddr *) i4;
1752     }
1753     else
1754     {
1755       struct sockaddr_in6 *i6;
1756
1757       i6 = GNUNET_malloc (sizeof(struct sockaddr_in6));
1758       i6->sin6_family = AF_INET6;
1759       i6->sin6_port = htons ((uint16_t) port);
1760       *sock_len = sizeof(struct sockaddr_in6);
1761       in = (struct sockaddr *) i6;
1762     }
1763     return in;
1764   }
1765   cp = GNUNET_strdup (bindto);
1766   colon = strrchr (cp, ':');
1767   if (NULL != colon)
1768   {
1769     /* interpet value after colon as port */
1770     *colon = '\0';
1771     colon++;
1772     if (1 == sscanf (colon, "%u%1s", &port, dummy))
1773     {
1774       /* interpreting value as just a PORT number */
1775       if (port > UINT16_MAX)
1776       {
1777         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1778                     "BINDTO specification `%s' invalid: value too large for port\n",
1779                     bindto);
1780         GNUNET_free (cp);
1781         return NULL;
1782       }
1783     }
1784     else
1785     {
1786       GNUNET_log (
1787         GNUNET_ERROR_TYPE_ERROR,
1788         "BINDTO specification `%s' invalid: last ':' not followed by number\n",
1789         bindto);
1790       GNUNET_free (cp);
1791       return NULL;
1792     }
1793   }
1794   else
1795   {
1796     /* interpret missing port as 0, aka pick any free one */
1797     port = 0;
1798   }
1799   {
1800     /* try IPv4 */
1801     struct sockaddr_in v4;
1802     if (1 == inet_pton (AF_INET, cp, &v4.sin_addr))
1803     {
1804       v4.sin_family = AF_INET;
1805       v4.sin_port = htons ((uint16_t) port);
1806 #if HAVE_SOCKADDR_IN_SIN_LEN
1807       v4.sin_len = sizeof(struct sockaddr_in);
1808 #endif
1809       in = GNUNET_memdup (&v4, sizeof(struct sockaddr_in));
1810       *sock_len = sizeof(struct sockaddr_in);
1811       GNUNET_free (cp);
1812       return in;
1813     }
1814   }
1815   {
1816     /* try IPv6 */
1817     struct sockaddr_in6 v6;
1818     const char *start;
1819
1820     start = cp;
1821     if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
1822     {
1823       start++;   /* skip over '[' */
1824       cp[strlen (cp) - 1] = '\0';  /* eat ']' */
1825     }
1826     if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
1827     {
1828       v6.sin6_family = AF_INET6;
1829       v6.sin6_port = htons ((uint16_t) port);
1830 #if HAVE_SOCKADDR_IN_SIN_LEN
1831       v6.sin6_len = sizeof(sizeof(struct sockaddr_in6));
1832 #endif
1833       in = GNUNET_memdup (&v6, sizeof(v6));
1834       *sock_len = sizeof(v6);
1835       GNUNET_free (cp);
1836       return in;
1837     }
1838   }
1839   /* #5528 FIXME (feature!): maybe also try getnameinfo()? */
1840   GNUNET_free (cp);
1841   return NULL;
1842 }
1843
1844
1845 /**
1846  * Pad @a dgram by @a pad_size using @a out_cipher.
1847  *
1848  * @param out_cipher cipher to use
1849  * @param dgram datagram to pad
1850  * @param pad_size number of bytes of padding to append
1851  */
1852 static void
1853 do_pad (gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
1854 {
1855   char pad[pad_size];
1856
1857   GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, pad, sizeof(pad));
1858   if (sizeof(pad) > sizeof(struct GNUNET_MessageHeader))
1859   {
1860     struct GNUNET_MessageHeader hdr =
1861     { .size = htons (sizeof(pad)),
1862       .type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD) };
1863
1864     memcpy (pad, &hdr, sizeof(hdr));
1865   }
1866   GNUNET_assert (
1867     0 ==
1868     gcry_cipher_encrypt (out_cipher, dgram, sizeof(pad), pad, sizeof(pad)));
1869 }
1870
1871
1872 /**
1873  * Signature of functions implementing the sending functionality of a
1874  * message queue.
1875  *
1876  * @param mq the message queue
1877  * @param msg the message to send
1878  * @param impl_state our `struct ReceiverAddress`
1879  */
1880 static void
1881 mq_send (struct GNUNET_MQ_Handle *mq,
1882          const struct GNUNET_MessageHeader *msg,
1883          void *impl_state)
1884 {
1885   struct ReceiverAddress *receiver = impl_state;
1886   uint16_t msize = ntohs (msg->size);
1887
1888   GNUNET_assert (mq == receiver->mq);
1889   if (msize > receiver->mtu)
1890   {
1891     GNUNET_break (0);
1892     receiver_destroy (receiver);
1893     return;
1894   }
1895   reschedule_receiver_timeout (receiver);
1896
1897   if (0 == receiver->acks_available)
1898   {
1899     /* use KX encryption method */
1900     struct UdpHandshakeSignature uhs;
1901     struct UDPConfirmation uc;
1902     struct InitialKX kx;
1903     struct GNUNET_CRYPTO_EcdhePrivateKey epriv;
1904     char dgram[receiver->mtu + sizeof(uc) + sizeof(kx)];
1905     size_t dpos;
1906     gcry_cipher_hd_t out_cipher;
1907     struct SharedSecret *ss;
1908
1909     /* setup key material */
1910     GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_ecdhe_key_create2 (&epriv));
1911
1912     ss = setup_shared_secret_enc (&epriv, receiver);
1913     setup_cipher (&ss->master, 0, &out_cipher);
1914     /* compute 'uc' */
1915     uc.sender = my_identity;
1916     uc.monotonic_time =
1917       GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg));
1918     uhs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_HANDSHAKE);
1919     uhs.purpose.size = htonl (sizeof(uhs));
1920     uhs.sender = my_identity;
1921     uhs.receiver = receiver->target;
1922     GNUNET_CRYPTO_ecdhe_key_get_public (&epriv, &uhs.ephemeral);
1923     uhs.monotonic_time = uc.monotonic_time;
1924     GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key,
1925                                                           &uhs.purpose,
1926                                                           &uc.sender_sig));
1927     /* Leave space for kx */
1928     dpos = sizeof(kx);
1929     /* Append encrypted uc to dgram */
1930     GNUNET_assert (0 == gcry_cipher_encrypt (out_cipher,
1931                                              &dgram[dpos],
1932                                              sizeof(uc),
1933                                              &uc,
1934                                              sizeof(uc)));
1935     dpos += sizeof(uc);
1936     /* Append encrypted payload to dgram */
1937     GNUNET_assert (
1938       0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
1939     dpos += msize;
1940     do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
1941     /* Datagram starts with kx */
1942     kx.ephemeral = uhs.ephemeral;
1943     GNUNET_assert (
1944       0 == gcry_cipher_gettag (out_cipher, kx.gcm_tag, sizeof(kx.gcm_tag)));
1945     gcry_cipher_close (out_cipher);
1946     memcpy (dgram, &kx, sizeof(kx));
1947     if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
1948                                             dgram,
1949                                             sizeof(dgram),
1950                                             receiver->address,
1951                                             receiver->address_len))
1952       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
1953     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1954                 "Sending KX to %s\n", GNUNET_a2s (receiver->address, receiver->address_len));
1955     GNUNET_MQ_impl_send_continue (mq);
1956     return;
1957   }   /* End of KX encryption method */
1958
1959   /* begin "BOX" encryption method, scan for ACKs from tail! */
1960   for (struct SharedSecret *ss = receiver->ss_tail; NULL != ss; ss = ss->prev)
1961   {
1962     if (ss->sequence_used < ss->sequence_allowed)
1963     {
1964       char dgram[sizeof(struct UDPBox) + receiver->mtu];
1965       struct UDPBox *box;
1966       gcry_cipher_hd_t out_cipher;
1967       size_t dpos;
1968
1969       box = (struct UDPBox *) dgram;
1970       ss->sequence_used++;
1971       get_kid (&ss->master, ss->sequence_used, &box->kid);
1972       setup_cipher (&ss->master, ss->sequence_used, &out_cipher);
1973       /* Append encrypted payload to dgram */
1974       dpos = sizeof(struct UDPBox);
1975       GNUNET_assert (
1976         0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
1977       dpos += msize;
1978       do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
1979       GNUNET_assert (0 == gcry_cipher_gettag (out_cipher,
1980                                               box->gcm_tag,
1981                                               sizeof(box->gcm_tag)));
1982       gcry_cipher_close (out_cipher);
1983       if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
1984                                               dgram,
1985                                               sizeof(dgram),
1986                                               receiver->address,
1987                                               receiver->address_len))
1988         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
1989       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1990                 "Sending data\n");
1991
1992       GNUNET_MQ_impl_send_continue (mq);
1993       receiver->acks_available--;
1994       if (0 == receiver->acks_available)
1995       {
1996         /* We have no more ACKs => MTU change! */
1997         setup_receiver_mq (receiver);
1998         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1999                     "No more acks, MTU changed\n");
2000       }
2001       return;
2002     }
2003   }
2004   GNUNET_assert (0);
2005 }
2006
2007
2008 /**
2009  * Signature of functions implementing the destruction of a message
2010  * queue.  Implementations must not free @a mq, but should take care
2011  * of @a impl_state.
2012  *
2013  * @param mq the message queue to destroy
2014  * @param impl_state our `struct ReceiverAddress`
2015  */
2016 static void
2017 mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state)
2018 {
2019   struct ReceiverAddress *receiver = impl_state;
2020
2021   if (mq == receiver->mq)
2022   {
2023     receiver->mq = NULL;
2024     receiver_destroy (receiver);
2025   }
2026 }
2027
2028
2029 /**
2030  * Implementation function that cancels the currently sent message.
2031  *
2032  * @param mq message queue
2033  * @param impl_state our `struct RecvierAddress`
2034  */
2035 static void
2036 mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
2037 {
2038   /* Cancellation is impossible with UDP; bail */
2039   GNUNET_assert (0);
2040 }
2041
2042
2043 /**
2044  * Generic error handler, called with the appropriate
2045  * error code and the same closure specified at the creation of
2046  * the message queue.
2047  * Not every message queue implementation supports an error handler.
2048  *
2049  * @param cls our `struct ReceiverAddress`
2050  * @param error error code
2051  */
2052 static void
2053 mq_error (void *cls, enum GNUNET_MQ_Error error)
2054 {
2055   struct ReceiverAddress *receiver = cls;
2056
2057   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2058               "MQ error in queue to %s: %d\n",
2059               GNUNET_i2s (&receiver->target),
2060               (int) error);
2061   receiver_destroy (receiver);
2062 }
2063
2064
2065 /**
2066  * Setup the MQ for the @a receiver.  If a queue exists,
2067  * the existing one is destroyed.  Then the MTU is
2068  * recalculated and a fresh queue is initialized.
2069  *
2070  * @param receiver receiver to setup MQ for
2071  */
2072 static void
2073 setup_receiver_mq (struct ReceiverAddress *receiver)
2074 {
2075   size_t base_mtu;
2076
2077   if (NULL != receiver->qh)
2078   {
2079     GNUNET_TRANSPORT_communicator_mq_del (receiver->qh);
2080     receiver->qh = NULL;
2081   }
2082   GNUNET_assert (NULL == receiver->mq);
2083   switch (receiver->address->sa_family)
2084   {
2085   case AF_INET:
2086     base_mtu = 1480   /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */
2087                - sizeof(struct GNUNET_TUN_IPv4Header)   /* 20 */
2088                - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
2089     break;
2090
2091   case AF_INET6:
2092     base_mtu = 1280   /* Minimum MTU required by IPv6 */
2093                - sizeof(struct GNUNET_TUN_IPv6Header)   /* 40 */
2094                - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
2095     break;
2096
2097   default:
2098     GNUNET_assert (0);
2099     break;
2100   }
2101   if (0 == receiver->acks_available)
2102   {
2103     /* MTU based on full KX messages */
2104     receiver->mtu = base_mtu - sizeof(struct InitialKX)   /* 48 */
2105                     - sizeof(struct UDPConfirmation);   /* 104 */
2106   }
2107   else
2108   {
2109     /* MTU based on BOXed messages */
2110     receiver->mtu = base_mtu - sizeof(struct UDPBox);
2111   }
2112   /* => Effective MTU for CORE will range from 1080 (IPv6 + KX) to
2113      1404 (IPv4 + Box) bytes, depending on circumstances... */
2114   if (NULL == receiver->mq)
2115     receiver->mq = GNUNET_MQ_queue_for_callbacks (&mq_send,
2116                                                   &mq_destroy,
2117                                                   &mq_cancel,
2118                                                   receiver,
2119                                                   NULL,
2120                                                   &mq_error,
2121                                                   receiver);
2122   receiver->qh =
2123     GNUNET_TRANSPORT_communicator_mq_add (ch,
2124                                           &receiver->target,
2125                                           receiver->foreign_addr,
2126                                           receiver->mtu,
2127                                           receiver->nt,
2128                                           GNUNET_TRANSPORT_CS_OUTBOUND,
2129                                           receiver->mq);
2130 }
2131
2132
2133 /**
2134  * Function called by the transport service to initialize a
2135  * message queue given address information about another peer.
2136  * If and when the communication channel is established, the
2137  * communicator must call #GNUNET_TRANSPORT_communicator_mq_add()
2138  * to notify the service that the channel is now up.  It is
2139  * the responsibility of the communicator to manage sane
2140  * retries and timeouts for any @a peer/@a address combination
2141  * provided by the transport service.  Timeouts and retries
2142  * do not need to be signalled to the transport service.
2143  *
2144  * @param cls closure
2145  * @param peer identity of the other peer
2146  * @param address where to send the message, human-readable
2147  *        communicator-specific format, 0-terminated, UTF-8
2148  * @return #GNUNET_OK on success, #GNUNET_SYSERR if the provided address is
2149  * invalid
2150  */
2151 static int
2152 mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
2153 {
2154   struct ReceiverAddress *receiver;
2155   const char *path;
2156   struct sockaddr *in;
2157   socklen_t in_len;
2158
2159   if (0 != strncmp (address,
2160                     COMMUNICATOR_ADDRESS_PREFIX "-",
2161                     strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
2162   {
2163     GNUNET_break_op (0);
2164     return GNUNET_SYSERR;
2165   }
2166   path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
2167   in = udp_address_to_sockaddr (path, &in_len);
2168
2169   receiver = GNUNET_new (struct ReceiverAddress);
2170   receiver->address = in;
2171   receiver->address_len = in_len;
2172   receiver->target = *peer;
2173   receiver->nt = GNUNET_NT_scanner_get_type (is, in, in_len);
2174   (void) GNUNET_CONTAINER_multipeermap_put (
2175     receivers,
2176     &receiver->target,
2177     receiver,
2178     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
2179   receiver->timeout =
2180     GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
2181   receiver->hn = GNUNET_CONTAINER_heap_insert (receivers_heap,
2182                                                receiver,
2183                                                receiver->timeout.abs_value_us);
2184   GNUNET_STATISTICS_set (stats,
2185                          "# receivers active",
2186                          GNUNET_CONTAINER_multipeermap_size (receivers),
2187                          GNUNET_NO);
2188   receiver->foreign_addr =
2189     sockaddr_to_udpaddr_string (receiver->address, receiver->address_len);
2190   setup_receiver_mq (receiver);
2191   if (NULL == timeout_task)
2192     timeout_task = GNUNET_SCHEDULER_add_now (&check_timeouts, NULL);
2193   return GNUNET_OK;
2194 }
2195
2196
2197 /**
2198  * Iterator over all receivers to clean up.
2199  *
2200  * @param cls NULL
2201  * @param target unused
2202  * @param value the queue to destroy
2203  * @return #GNUNET_OK to continue to iterate
2204  */
2205 static int
2206 get_receiver_delete_it (void *cls,
2207                         const struct GNUNET_PeerIdentity *target,
2208                         void *value)
2209 {
2210   struct ReceiverAddress *receiver = value;
2211
2212   (void) cls;
2213   (void) target;
2214   receiver_destroy (receiver);
2215   return GNUNET_OK;
2216 }
2217
2218
2219 /**
2220  * Iterator over all senders to clean up.
2221  *
2222  * @param cls NULL
2223  * @param target unused
2224  * @param value the queue to destroy
2225  * @return #GNUNET_OK to continue to iterate
2226  */
2227 static int
2228 get_sender_delete_it (void *cls,
2229                       const struct GNUNET_PeerIdentity *target,
2230                       void *value)
2231 {
2232   struct SenderAddress *sender = value;
2233
2234   (void) cls;
2235   (void) target;
2236   sender_destroy (sender);
2237   return GNUNET_OK;
2238 }
2239
2240
2241 /**
2242  * Shutdown the UNIX communicator.
2243  *
2244  * @param cls NULL (always)
2245  */
2246 static void
2247 do_shutdown (void *cls)
2248 {
2249   if (NULL != nat)
2250   {
2251     GNUNET_NAT_unregister (nat);
2252     nat = NULL;
2253   }
2254   while (NULL != bi_head)
2255     bi_destroy (bi_head);
2256   if (NULL != broadcast_task)
2257   {
2258     GNUNET_SCHEDULER_cancel (broadcast_task);
2259     broadcast_task = NULL;
2260   }
2261   if (NULL != read_task)
2262   {
2263     GNUNET_SCHEDULER_cancel (read_task);
2264     read_task = NULL;
2265   }
2266   if (NULL != udp_sock)
2267   {
2268     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (udp_sock));
2269     udp_sock = NULL;
2270   }
2271   GNUNET_CONTAINER_multipeermap_iterate (receivers,
2272                                          &get_receiver_delete_it,
2273                                          NULL);
2274   GNUNET_CONTAINER_multipeermap_destroy (receivers);
2275   GNUNET_CONTAINER_multipeermap_iterate (senders, &get_sender_delete_it, NULL);
2276   GNUNET_CONTAINER_multipeermap_destroy (senders);
2277   GNUNET_CONTAINER_multishortmap_destroy (key_cache);
2278   GNUNET_CONTAINER_heap_destroy (senders_heap);
2279   GNUNET_CONTAINER_heap_destroy (receivers_heap);
2280   if (NULL != ch)
2281   {
2282     GNUNET_TRANSPORT_communicator_disconnect (ch);
2283     ch = NULL;
2284   }
2285   if (NULL != ah)
2286   {
2287     GNUNET_TRANSPORT_application_done (ah);
2288     ah = NULL;
2289   }
2290   if (NULL != stats)
2291   {
2292     GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
2293     stats = NULL;
2294   }
2295   if (NULL != my_private_key)
2296   {
2297     GNUNET_free (my_private_key);
2298     my_private_key = NULL;
2299   }
2300   if (NULL != is)
2301   {
2302     GNUNET_NT_scanner_done (is);
2303     is = NULL;
2304   }
2305 }
2306
2307
2308 /**
2309  * Function called when the transport service has received a
2310  * backchannel message for this communicator (!) via a different return
2311  * path. Should be an acknowledgement.
2312  *
2313  * @param cls closure, NULL
2314  * @param sender which peer sent the notification
2315  * @param msg payload
2316  */
2317 static void
2318 enc_notify_cb (void *cls,
2319                const struct GNUNET_PeerIdentity *sender,
2320                const struct GNUNET_MessageHeader *msg)
2321 {
2322   const struct UDPAck *ack;
2323
2324   (void) cls;
2325   if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK) ||
2326       (ntohs (msg->size) != sizeof(struct UDPAck)))
2327   {
2328     GNUNET_break_op (0);
2329     return;
2330   }
2331   ack = (const struct UDPAck *) msg;
2332   GNUNET_CONTAINER_multipeermap_get_multiple (receivers,
2333                                               sender,
2334                                               &handle_ack,
2335                                               (void *) ack);
2336 }
2337
2338
2339 /**
2340  * Signature of the callback passed to #GNUNET_NAT_register() for
2341  * a function to call whenever our set of 'valid' addresses changes.
2342  *
2343  * @param cls closure
2344  * @param app_ctx[in,out] location where the app can store stuff
2345  *                  on add and retrieve it on remove
2346  * @param add_remove #GNUNET_YES to add a new public IP address,
2347  *                   #GNUNET_NO to remove a previous (now invalid) one
2348  * @param ac address class the address belongs to
2349  * @param addr either the previous or the new public IP address
2350  * @param addrlen actual length of the @a addr
2351  */
2352 static void
2353 nat_address_cb (void *cls,
2354                 void **app_ctx,
2355                 int add_remove,
2356                 enum GNUNET_NAT_AddressClass ac,
2357                 const struct sockaddr *addr,
2358                 socklen_t addrlen)
2359 {
2360   char *my_addr;
2361   struct GNUNET_TRANSPORT_AddressIdentifier *ai;
2362
2363   if (GNUNET_YES == add_remove)
2364   {
2365     enum GNUNET_NetworkType nt;
2366
2367     GNUNET_asprintf (&my_addr,
2368                      "%s-%s",
2369                      COMMUNICATOR_ADDRESS_PREFIX,
2370                      GNUNET_a2s (addr, addrlen));
2371     nt = GNUNET_NT_scanner_get_type (is, addr, addrlen);
2372     ai =
2373       GNUNET_TRANSPORT_communicator_address_add (ch,
2374                                                  my_addr,
2375                                                  nt,
2376                                                  GNUNET_TIME_UNIT_FOREVER_REL);
2377     GNUNET_free (my_addr);
2378     *app_ctx = ai;
2379   }
2380   else
2381   {
2382     ai = *app_ctx;
2383     GNUNET_TRANSPORT_communicator_address_remove (ai);
2384     *app_ctx = NULL;
2385   }
2386 }
2387
2388
2389 /**
2390  * Broadcast our presence on one of our interfaces.
2391  *
2392  * @param cls a `struct BroadcastInterface`
2393  */
2394 static void
2395 ifc_broadcast (void *cls)
2396 {
2397   struct BroadcastInterface *bi = cls;
2398   struct GNUNET_TIME_Relative delay;
2399
2400   delay = BROADCAST_FREQUENCY;
2401   delay.rel_value_us =
2402     GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, delay.rel_value_us);
2403   bi->broadcast_task =
2404     GNUNET_SCHEDULER_add_delayed (INTERFACE_SCAN_FREQUENCY, &ifc_broadcast, bi);
2405
2406   switch (bi->sa->sa_family)
2407   {
2408   case AF_INET: {
2409       static int yes = 1;
2410       static int no = 0;
2411       ssize_t sent;
2412
2413       if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
2414                                                          SOL_SOCKET,
2415                                                          SO_BROADCAST,
2416                                                          &yes,
2417                                                          sizeof(int)))
2418         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
2419       sent = GNUNET_NETWORK_socket_sendto (udp_sock,
2420                                            &bi->bcm,
2421                                            sizeof(bi->bcm),
2422                                            bi->ba,
2423                                            bi->salen);
2424       if (-1 == sent)
2425         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto");
2426       if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
2427                                                          SOL_SOCKET,
2428                                                          SO_BROADCAST,
2429                                                          &no,
2430                                                          sizeof(int)))
2431         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
2432       break;
2433     }
2434
2435   case AF_INET6: {
2436       ssize_t sent;
2437       struct sockaddr_in6 dst;
2438
2439       dst.sin6_family = AF_INET6;
2440       dst.sin6_port = htons (my_port);
2441       dst.sin6_addr = bi->mcreq.ipv6mr_multiaddr;
2442       dst.sin6_scope_id = ((struct sockaddr_in6 *) bi->ba)->sin6_scope_id;
2443
2444       sent = GNUNET_NETWORK_socket_sendto (udp_sock,
2445                                            &bi->bcm,
2446                                            sizeof(bi->bcm),
2447                                            (const struct sockaddr *) &dst,
2448                                            sizeof(dst));
2449       if (-1 == sent)
2450         GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto");
2451       break;
2452     }
2453
2454   default:
2455     GNUNET_break (0);
2456     break;
2457   }
2458 }
2459
2460
2461 /**
2462  * Callback function invoked for each interface found.
2463  * Activates/deactivates broadcast interfaces.
2464  *
2465  * @param cls NULL
2466  * @param name name of the interface (can be NULL for unknown)
2467  * @param isDefault is this presumably the default interface
2468  * @param addr address of this interface (can be NULL for unknown or unassigned)
2469  * @param broadcast_addr the broadcast address (can be NULL for unknown or
2470  * unassigned)
2471  * @param netmask the network mask (can be NULL for unknown or unassigned)
2472  * @param addrlen length of the address
2473  * @return #GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort
2474  */
2475 static int
2476 iface_proc (void *cls,
2477             const char *name,
2478             int isDefault,
2479             const struct sockaddr *addr,
2480             const struct sockaddr *broadcast_addr,
2481             const struct sockaddr *netmask,
2482             socklen_t addrlen)
2483 {
2484   struct BroadcastInterface *bi;
2485   enum GNUNET_NetworkType network;
2486   struct UdpBroadcastSignature ubs;
2487
2488   (void) cls;
2489   (void) netmask;
2490   if (NULL == addr)
2491     return GNUNET_YES; /* need to know our address! */
2492   network = GNUNET_NT_scanner_get_type (is, addr, addrlen);
2493   if (GNUNET_NT_LOOPBACK == network)
2494   {
2495     /* Broadcasting on loopback does not make sense */
2496     return GNUNET_YES;
2497   }
2498   for (bi = bi_head; NULL != bi; bi = bi->next)
2499   {
2500     if ((bi->salen == addrlen) && (0 == memcmp (addr, bi->sa, addrlen)))
2501     {
2502       bi->found = GNUNET_YES;
2503       return GNUNET_OK;
2504     }
2505   }
2506
2507   if ((AF_INET6 == addr->sa_family) && (NULL == broadcast_addr))
2508     return GNUNET_OK; /* broadcast_addr is required for IPv6! */
2509   if ((AF_INET6 == addr->sa_family) && (GNUNET_YES != have_v6_socket))
2510     return GNUNET_OK; /* not using IPv6 */
2511
2512   bi = GNUNET_new (struct BroadcastInterface);
2513   bi->sa = GNUNET_memdup (addr, addrlen);
2514   if (NULL != broadcast_addr)
2515     bi->ba = GNUNET_memdup (broadcast_addr, addrlen);
2516   bi->salen = addrlen;
2517   bi->found = GNUNET_YES;
2518   bi->bcm.sender = my_identity;
2519   ubs.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_UDP_BROADCAST);
2520   ubs.purpose.size = htonl (sizeof(ubs));
2521   ubs.sender = my_identity;
2522   GNUNET_CRYPTO_hash (addr, addrlen, &ubs.h_address);
2523   GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_eddsa_sign (my_private_key,
2524                                                         &ubs.purpose,
2525                                                         &bi->bcm.sender_sig));
2526   if (NULL != broadcast_addr)
2527   {
2528     bi->broadcast_task = GNUNET_SCHEDULER_add_now (&ifc_broadcast, bi);
2529     GNUNET_CONTAINER_DLL_insert (bi_head, bi_tail, bi);
2530   }
2531   if ((AF_INET6 == addr->sa_family) && (NULL != broadcast_addr))
2532   {
2533     /* Create IPv6 multicast request */
2534     const struct sockaddr_in6 *s6 =
2535       (const struct sockaddr_in6 *) broadcast_addr;
2536
2537     GNUNET_assert (
2538       1 == inet_pton (AF_INET6, "FF05::13B", &bi->mcreq.ipv6mr_multiaddr));
2539
2540     /* http://tools.ietf.org/html/rfc2553#section-5.2:
2541      *
2542      * IPV6_JOIN_GROUP
2543      *
2544      * Join a multicast group on a specified local interface.  If the
2545      * interface index is specified as 0, the kernel chooses the local
2546      * interface.  For example, some kernels look up the multicast
2547      * group in the normal IPv6 routing table and using the resulting
2548      * interface; we do this for each interface, so no need to use
2549      * zero (anymore...).
2550      */bi->mcreq.ipv6mr_interface = s6->sin6_scope_id;
2551
2552     /* Join the multicast group */
2553     if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
2554                                                        IPPROTO_IPV6,
2555                                                        IPV6_JOIN_GROUP,
2556                                                        &bi->mcreq,
2557                                                        sizeof(bi->mcreq)))
2558     {
2559       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
2560     }
2561   }
2562   return GNUNET_OK;
2563 }
2564
2565
2566 /**
2567  * Scan interfaces to broadcast our presence on the LAN.
2568  *
2569  * @param cls NULL, unused
2570  */
2571 static void
2572 do_broadcast (void *cls)
2573 {
2574   struct BroadcastInterface *bin;
2575
2576   (void) cls;
2577   for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bi->next)
2578     bi->found = GNUNET_NO;
2579   GNUNET_OS_network_interfaces_list (&iface_proc, NULL);
2580   for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bin)
2581   {
2582     bin = bi->next;
2583     if (GNUNET_NO == bi->found)
2584       bi_destroy (bi);
2585   }
2586   broadcast_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_SCAN_FREQUENCY,
2587                                                  &do_broadcast,
2588                                                  NULL);
2589 }
2590
2591
2592 /**
2593  * Setup communicator and launch network interactions.
2594  *
2595  * @param cls NULL (always)
2596  * @param args remaining command-line arguments
2597  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
2598  * @param c configuration
2599  */
2600 static void
2601 run (void *cls,
2602      char *const *args,
2603      const char *cfgfile,
2604      const struct GNUNET_CONFIGURATION_Handle *c)
2605 {
2606   char *bindto;
2607   struct sockaddr *in;
2608   socklen_t in_len;
2609   struct sockaddr_storage in_sto;
2610   socklen_t sto_len;
2611
2612   (void) cls;
2613   cfg = c;
2614   if (GNUNET_OK !=
2615       GNUNET_CONFIGURATION_get_value_string (cfg,
2616                                              COMMUNICATOR_CONFIG_SECTION,
2617                                              "BINDTO",
2618                                              &bindto))
2619   {
2620     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
2621                                COMMUNICATOR_CONFIG_SECTION,
2622                                "BINDTO");
2623     return;
2624   }
2625
2626   in = udp_address_to_sockaddr (bindto, &in_len);
2627   if (NULL == in)
2628   {
2629     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2630                 "Failed to setup UDP socket address with path `%s'\n",
2631                 bindto);
2632     GNUNET_free (bindto);
2633     return;
2634   }
2635   udp_sock =
2636     GNUNET_NETWORK_socket_create (in->sa_family, SOCK_DGRAM, IPPROTO_UDP);
2637   if (NULL == udp_sock)
2638   {
2639     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
2640     GNUNET_free (in);
2641     GNUNET_free (bindto);
2642     return;
2643   }
2644   if (AF_INET6 == in->sa_family)
2645     have_v6_socket = GNUNET_YES;
2646   if (GNUNET_OK != GNUNET_NETWORK_socket_bind (udp_sock, in, in_len))
2647   {
2648     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "bind", bindto);
2649     GNUNET_NETWORK_socket_close (udp_sock);
2650     udp_sock = NULL;
2651     GNUNET_free (in);
2652     GNUNET_free (bindto);
2653     return;
2654   }
2655
2656   /* We might have bound to port 0, allowing the OS to figure it out;
2657      thus, get the real IN-address from the socket */
2658   sto_len = sizeof(in_sto);
2659   if (0 != getsockname (GNUNET_NETWORK_get_fd (udp_sock),
2660                         (struct sockaddr *) &in_sto,
2661                         &sto_len))
2662   {
2663     memcpy (&in_sto, in, in_len);
2664     sto_len = in_len;
2665   }
2666   GNUNET_free (in);
2667   GNUNET_free (bindto);
2668   in = (struct sockaddr *) &in_sto;
2669   in_len = sto_len;
2670   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2671               "Bound to `%s'\n",
2672               GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len));
2673   switch (in->sa_family)
2674   {
2675   case AF_INET:
2676     my_port = ntohs (((struct sockaddr_in *) in)->sin_port);
2677     break;
2678
2679   case AF_INET6:
2680     my_port = ntohs (((struct sockaddr_in6 *) in)->sin6_port);
2681     break;
2682
2683   default:
2684     GNUNET_break (0);
2685     my_port = 0;
2686   }
2687   stats = GNUNET_STATISTICS_create ("C-UDP", cfg);
2688   senders = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES);
2689   receivers = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES);
2690   senders_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
2691   receivers_heap =
2692     GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
2693   key_cache = GNUNET_CONTAINER_multishortmap_create (1024, GNUNET_YES);
2694   GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
2695   is = GNUNET_NT_scanner_init ();
2696   my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
2697   if (NULL == my_private_key)
2698   {
2699     GNUNET_log (
2700       GNUNET_ERROR_TYPE_ERROR,
2701       _ (
2702         "Transport service is lacking key configuration settings. Exiting.\n"));
2703     GNUNET_SCHEDULER_shutdown ();
2704     return;
2705   }
2706   GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
2707   /* start reading */
2708   read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
2709                                              udp_sock,
2710                                              &sock_read,
2711                                              NULL);
2712   ch = GNUNET_TRANSPORT_communicator_connect (cfg,
2713                                               COMMUNICATOR_CONFIG_SECTION,
2714                                               COMMUNICATOR_ADDRESS_PREFIX,
2715                                               GNUNET_TRANSPORT_CC_UNRELIABLE,
2716                                               &mq_init,
2717                                               NULL,
2718                                               &enc_notify_cb,
2719                                               NULL);
2720   if (NULL == ch)
2721   {
2722     GNUNET_break (0);
2723     GNUNET_SCHEDULER_shutdown ();
2724     return;
2725   }
2726   ah = GNUNET_TRANSPORT_application_init (cfg);
2727   if (NULL == ah)
2728   {
2729     GNUNET_break (0);
2730     GNUNET_SCHEDULER_shutdown ();
2731     return;
2732   }
2733   /* start broadcasting */
2734   if (GNUNET_YES !=
2735       GNUNET_CONFIGURATION_get_value_yesno (cfg,
2736                                             COMMUNICATOR_CONFIG_SECTION,
2737                                             "DISABLE_BROADCAST"))
2738   {
2739     broadcast_task = GNUNET_SCHEDULER_add_now (&do_broadcast, NULL);
2740   }
2741   nat = GNUNET_NAT_register (cfg,
2742                              COMMUNICATOR_CONFIG_SECTION,
2743                              IPPROTO_UDP,
2744                              1 /* one address */,
2745                              (const struct sockaddr **) &in,
2746                              &in_len,
2747                              &nat_address_cb,
2748                              NULL /* FIXME: support reversal: #5529 */,
2749                              NULL /* closure */);
2750 }
2751
2752
2753 /**
2754  * The main function for the UNIX communicator.
2755  *
2756  * @param argc number of arguments from the command line
2757  * @param argv command line arguments
2758  * @return 0 ok, 1 on error
2759  */
2760 int
2761 main (int argc, char *const *argv)
2762 {
2763   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
2764     GNUNET_GETOPT_OPTION_END
2765   };
2766   int ret;
2767
2768   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
2769     return 2;
2770
2771   ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc,
2772                                           argv,
2773                                           "gnunet-communicator-udp",
2774                                           _ ("GNUnet UDP communicator"),
2775                                           options,
2776                                           &run,
2777                                           NULL))
2778         ? 0
2779         : 1;
2780   GNUNET_free ((void *) argv);
2781   return ret;
2782 }
2783
2784
2785 /* end of gnunet-communicator-udp.c */