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