src/transport/plugin_transport_udp.c

   1 /*
   2      This file is part of GNUnet
   3      (C) 2010-2013 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file transport/plugin_transport_udp.c
  23  * @brief Implementation of the UDP transport protocol
  24  * @author Christian Grothoff
  25  * @author Nathan Evans
  26  * @author Matthias Wachs
  27  */
  28 #include "platform.h"
  29 #include "plugin_transport_udp.h"
  30 #include "gnunet_hello_lib.h"
  31 #include "gnunet_util_lib.h"
  32 #include "gnunet_fragmentation_lib.h"
  33 #include "gnunet_nat_lib.h"
  34 #include "gnunet_protocols.h"
  35 #include "gnunet_resolver_service.h"
  36 #include "gnunet_signatures.h"
  37 #include "gnunet_constants.h"
  38 #include "gnunet_statistics_service.h"
  39 #include "gnunet_transport_service.h"
  40 #include "gnunet_transport_plugin.h"
  41 #include "transport.h"
  42
  43 #define LOG(kind,...) GNUNET_log_from (kind, "transport-udp", __VA_ARGS__)
  44
  45 #define UDP_SESSION_TIME_OUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
  46
  47 #define PLUGIN_NAME "udp"
  48
  49 /**
  50  * Number of messages we can defragment in parallel.  We only really
  51  * defragment 1 message at a time, but if messages get re-ordered, we
  52  * may want to keep knowledge about the previous message to avoid
  53  * discarding the current message in favor of a single fragment of a
  54  * previous message.  3 should be good since we don't expect massive
  55  * message reorderings with UDP.
  56  */
  57 #define UDP_MAX_MESSAGES_IN_DEFRAG 3
  58
  59 /**
  60  * We keep a defragmentation queue per sender address.  How many
  61  * sender addresses do we support at the same time? Memory consumption
  62  * is roughly a factor of 32k * UDP_MAX_MESSAGES_IN_DEFRAG times this
  63  * value. (So 128 corresponds to 12 MB and should suffice for
  64  * connecting to roughly 128 peers via UDP).
  65  */
  66 #define UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG 128
  67
  68 /**
  69  * Running pretty printers: head
  70  */
  71 static struct PrettyPrinterContext *ppc_dll_head;
  72
  73 /**
  74  * Running pretty printers: tail
  75  */
  76 static struct PrettyPrinterContext *ppc_dll_tail;
  77
  78 /**
  79  * Closure for 'append_port'.
  80  */
  81 struct PrettyPrinterContext
  82 {
  83   /**
  84    * DLL
  85    */
  86   struct PrettyPrinterContext *next;
  87
  88   /**
  89    * DLL
  90    */
  91   struct PrettyPrinterContext *prev;
  92
  93   /**
  94    * Timeout task
  95    */
  96   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
  97
  98   /**
  99    * Resolver handle
 100    */
 101   struct GNUNET_RESOLVER_RequestHandle *resolver_handle;
 102
 103   /**
 104    * Function to call with the result.
 105    */
 106   GNUNET_TRANSPORT_AddressStringCallback asc;
 107
 108   /**
 109    * Clsoure for 'asc'.
 110    */
 111   void *asc_cls;
 112
 113   /**
 114    * Port to add after the IP address.
 115    */
 116   uint16_t port;
 117
 118   /**
 119    * IPv6 address
 120    */
 121
 122   int ipv6;
 123
 124   /**
 125    * Options
 126    */
 127   uint32_t options;
 128 };
 129
 130
 131 enum UDP_MessageType
 132 {
 133   UNDEFINED = 0,
 134   MSG_FRAGMENTED = 1,
 135   MSG_FRAGMENTED_COMPLETE = 2,
 136   MSG_UNFRAGMENTED = 3,
 137   MSG_ACK = 4,
 138   MSG_BEACON = 5
 139 };
 140
 141
 142 struct Session
 143 {
 144   /**
 145    * Which peer is this session for?
 146    */
 147   struct GNUNET_PeerIdentity target;
 148
 149   /**
 150    * Plugin this session belongs to.
 151    */
 152   struct Plugin *plugin;
 153
 154   /**
 155    * Context for dealing with fragments.
 156    */
 157   struct UDP_FragmentationContext *frag_ctx;
 158
 159   /**
 160    * Address of the other peer
 161    */
 162   const struct sockaddr *sock_addr;
 163
 164   /**
 165    * Desired delay for next sending we send to other peer
 166    */
 167   struct GNUNET_TIME_Relative flow_delay_for_other_peer;
 168
 169   /**
 170    * Desired delay for next sending we received from other peer
 171    */
 172   struct GNUNET_TIME_Absolute flow_delay_from_other_peer;
 173
 174   /**
 175    * Session timeout task
 176    */
 177   GNUNET_SCHEDULER_TaskIdentifier timeout_task;
 178
 179   /**
 180    * expected delay for ACKs
 181    */
 182   struct GNUNET_TIME_Relative last_expected_ack_delay;
 183
 184   /**
 185    * desired delay between UDP messages
 186    */
 187   struct GNUNET_TIME_Relative last_expected_msg_delay;
 188
 189   struct GNUNET_ATS_Information ats;
 190
 191   /**
 192    * Number of bytes in @e sock_addr.
 193    */
 194   size_t addrlen;
 195
 196   /**
 197    * Reference counter to indicate that this session is
 198    * currently being used and must not be destroyed;
 199    * setting @e in_destroy will destroy it as soon as
 200    * possible.
 201    */
 202   unsigned int rc;
 203
 204   /**
 205    * Is this session about to be destroyed (sometimes we cannot
 206    * destroy a session immediately as below us on the stack
 207    * there might be code that still uses it; in this case,
 208    * @e rc is non-zero).
 209    */
 210   int in_destroy;
 211
 212   int inbound;
 213 };
 214
 215
 216 /**
 217  * Closure for #session_cmp_it().
 218  */
 219 struct SessionCompareContext
 220 {
 221   struct Session *res;
 222   const struct GNUNET_HELLO_Address *addr;
 223   int inbound;
 224 };
 225
 226
 227 /**
 228  * Closure for #process_inbound_tokenized_messages().
 229  */
 230 struct SourceInformation
 231 {
 232   /**
 233    * Sender identity.
 234    */
 235   struct GNUNET_PeerIdentity sender;
 236
 237   /**
 238    * Source address.
 239    */
 240   const void *arg;
 241
 242   /**
 243    * Associated session.
 244    */
 245   struct Session *session;
 246
 247   /**
 248    * Number of bytes in source address.
 249    */
 250   size_t args;
 251
 252 };
 253
 254
 255 /**
 256  * Closure for #find_receive_context().
 257  */
 258 struct FindReceiveContext
 259 {
 260   /**
 261    * Where to store the result.
 262    */
 263   struct DefragContext *rc;
 264
 265   /**
 266    * Address to find.
 267    */
 268   const struct sockaddr *addr;
 269
 270   struct Session *session;
 271
 272   /**
 273    * Number of bytes in @e addr.
 274    */
 275   socklen_t addr_len;
 276
 277 };
 278
 279
 280
 281 /**
 282  * Data structure to track defragmentation contexts based
 283  * on the source of the UDP traffic.
 284  */
 285 struct DefragContext
 286 {
 287
 288   /**
 289    * Defragmentation context.
 290    */
 291   struct GNUNET_DEFRAGMENT_Context *defrag;
 292
 293   /**
 294    * Source address this receive context is for (allocated at the
 295    * end of the struct).
 296    */
 297   const struct sockaddr *src_addr;
 298
 299   /**
 300    * Reference to master plugin struct.
 301    */
 302   struct Plugin *plugin;
 303
 304   /**
 305    * Node in the defrag heap.
 306    */
 307   struct GNUNET_CONTAINER_HeapNode *hnode;
 308
 309   /**
 310    * Length of 'src_addr'
 311    */
 312   size_t addr_len;
 313 };
 314
 315
 316
 317 /**
 318  * Context to send fragmented messages
 319  */
 320 struct UDP_FragmentationContext
 321 {
 322   /**
 323    * Next in linked list
 324    */
 325   struct UDP_FragmentationContext *next;
 326
 327   /**
 328    * Previous in linked list
 329    */
 330   struct UDP_FragmentationContext *prev;
 331
 332   /**
 333    * The plugin
 334    */
 335   struct Plugin *plugin;
 336
 337   /**
 338    * Handle for GNUNET_FRAGMENT context
 339    */
 340   struct GNUNET_FRAGMENT_Context *frag;
 341
 342   /**
 343    * The session this fragmentation context belongs to
 344    */
 345   struct Session *session;
 346
 347   /**
 348    * Function to call upon completion of the transmission.
 349    */
 350   GNUNET_TRANSPORT_TransmitContinuation cont;
 351
 352   /**
 353    * Closure for @e cont.
 354    */
 355   void *cont_cls;
 356
 357   /**
 358    * Message timeout
 359    */
 360   struct GNUNET_TIME_Absolute timeout;
 361
 362   /**
 363    * Payload size of original unfragmented message
 364    */
 365   size_t payload_size;
 366
 367   /**
 368    * Bytes used to send all fragments on wire including UDP overhead
 369    */
 370   size_t on_wire_size;
 371
 372   unsigned int fragments_used;
 373
 374 };
 375
 376
 377 struct UDP_MessageWrapper
 378 {
 379   /**
 380    * Session this message belongs to
 381    */
 382   struct Session *session;
 383
 384   /**
 385    * DLL of messages
 386    * previous element
 387    */
 388   struct UDP_MessageWrapper *prev;
 389
 390   /**
 391    * DLL of messages
 392    * previous element
 393    */
 394   struct UDP_MessageWrapper *next;
 395
 396   /**
 397    * Message type
 398    * According to UDP_MessageType
 399    */
 400   int msg_type;
 401
 402   /**
 403    * Message with size msg_size including UDP specific overhead
 404    */
 405   char *msg_buf;
 406
 407   /**
 408    * Size of UDP message to send including UDP specific overhead
 409    */
 410   size_t msg_size;
 411
 412   /**
 413    * Payload size of original message
 414    */
 415   size_t payload_size;
 416
 417   /**
 418    * Message timeout
 419    */
 420   struct GNUNET_TIME_Absolute timeout;
 421
 422   /**
 423    * Function to call upon completion of the transmission.
 424    */
 425   GNUNET_TRANSPORT_TransmitContinuation cont;
 426
 427   /**
 428    * Closure for 'cont'.
 429    */
 430   void *cont_cls;
 431
 432   /**
 433    * Fragmentation context
 434    * frag_ctx == NULL if transport <= MTU
 435    * frag_ctx != NULL if transport > MTU
 436    */
 437   struct UDP_FragmentationContext *frag_ctx;
 438 };
 439
 440
 441 /**
 442  * UDP ACK Message-Packet header (after defragmentation).
 443  */
 444 struct UDP_ACK_Message
 445 {
 446   /**
 447    * Message header.
 448    */
 449   struct GNUNET_MessageHeader header;
 450
 451   /**
 452    * Desired delay for flow control
 453    */
 454   uint32_t delay;
 455
 456   /**
 457    * What is the identity of the sender
 458    */
 459   struct GNUNET_PeerIdentity sender;
 460
 461 };
 462
 463 /**
 464  * Address options
 465  */
 466 static uint32_t myoptions;
 467
 468
 469 /**
 470  * Encapsulation of all of the state of the plugin.
 471  */
 472 struct Plugin * plugin;
 473
 474
 475 /**
 476  * We have been notified that our readset has something to read.  We don't
 477  * know which socket needs to be read, so we have to check each one
 478  * Then reschedule this function to be called again once more is available.
 479  *
 480  * @param cls the plugin handle
 481  * @param tc the scheduling context (for rescheduling this function again)
 482  */
 483 static void
 484 udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 485
 486
 487 /**
 488  * We have been notified that our readset has something to read.  We don't
 489  * know which socket needs to be read, so we have to check each one
 490  * Then reschedule this function to be called again once more is available.
 491  *
 492  * @param cls the plugin handle
 493  * @param tc the scheduling context (for rescheduling this function again)
 494  */
 495 static void
 496 udp_plugin_select_v6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 497
 498
 499 /**
 500  * (re)schedule select tasks for this plugin.
 501  *
 502  * @param plugin plugin to reschedule
 503  */
 504 static void
 505 schedule_select (struct Plugin *plugin)
 506 {
 507   struct GNUNET_TIME_Relative min_delay;
 508   struct UDP_MessageWrapper *udpw;
 509
 510   if ((GNUNET_YES == plugin->enable_ipv4) && (NULL != plugin->sockv4))
 511   {
 512     /* Find a message ready to send:
 513      * Flow delay from other peer is expired or not set (0) */
 514     min_delay = GNUNET_TIME_UNIT_FOREVER_REL;
 515     for (udpw = plugin->ipv4_queue_head; NULL != udpw; udpw = udpw->next)
 516       min_delay = GNUNET_TIME_relative_min (min_delay,
 517                                             GNUNET_TIME_absolute_get_remaining (udpw->session->flow_delay_from_other_peer));
 518
 519     if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
 520       GNUNET_SCHEDULER_cancel(plugin->select_task);
 521
 522     /* Schedule with:
 523      * - write active set if message is ready
 524      * - timeout minimum delay */
 525     plugin->select_task =
 526       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
 527                                    (0 == min_delay.rel_value_us) ? GNUNET_TIME_UNIT_FOREVER_REL : min_delay,
 528                                    plugin->rs_v4,
 529                                    (0 == min_delay.rel_value_us) ? plugin->ws_v4 : NULL,
 530                                    &udp_plugin_select, plugin);
 531   }
 532   if ((GNUNET_YES == plugin->enable_ipv6) && (NULL != plugin->sockv6))
 533   {
 534     min_delay = GNUNET_TIME_UNIT_FOREVER_REL;
 535     for (udpw = plugin->ipv6_queue_head; NULL != udpw; udpw = udpw->next)
 536       min_delay = GNUNET_TIME_relative_min (min_delay,
 537                                             GNUNET_TIME_absolute_get_remaining (udpw->session->flow_delay_from_other_peer));
 538
 539     if (GNUNET_SCHEDULER_NO_TASK != plugin->select_task_v6)
 540       GNUNET_SCHEDULER_cancel(plugin->select_task_v6);
 541     plugin->select_task_v6 =
 542       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
 543                                    (0 == min_delay.rel_value_us) ? GNUNET_TIME_UNIT_FOREVER_REL : min_delay,
 544                                    plugin->rs_v6,
 545                                    (0 == min_delay.rel_value_us) ? plugin->ws_v6 : NULL,
 546                                    &udp_plugin_select_v6, plugin);
 547   }
 548 }
 549
 550
 551 /**
 552  * Function called for a quick conversion of the binary address to
 553  * a numeric address.  Note that the caller must not free the
 554  * address and that the next call to this function is allowed
 555  * to override the address again.
 556  *
 557  * @param cls closure
 558  * @param addr binary address
 559  * @param addrlen length of the address
 560  * @return string representing the same address
 561  */
 562 const char *
 563 udp_address_to_string (void *cls, const void *addr, size_t addrlen)
 564 {
 565   static char rbuf[INET6_ADDRSTRLEN + 10];
 566   char buf[INET6_ADDRSTRLEN];
 567   const void *sb;
 568   struct in_addr a4;
 569   struct in6_addr a6;
 570   const struct IPv4UdpAddress *t4;
 571   const struct IPv6UdpAddress *t6;
 572   int af;
 573   uint16_t port;
 574   uint32_t options;
 575
 576   if ((NULL != addr) && (addrlen == sizeof (struct IPv6UdpAddress)))
 577   {
 578     t6 = addr;
 579     af = AF_INET6;
 580     options = ntohl (t6->options);
 581     port = ntohs (t6->u6_port);
 582     memcpy (&a6, &t6->ipv6_addr, sizeof (a6));
 583     sb = &a6;
 584   }
 585   else if ((NULL != addr) && (addrlen == sizeof (struct IPv4UdpAddress)))
 586   {
 587     t4 = addr;
 588     af = AF_INET;
 589     options = ntohl (t4->options);
 590     port = ntohs (t4->u4_port);
 591     memcpy (&a4, &t4->ipv4_addr, sizeof (a4));
 592     sb = &a4;
 593   }
 594   else
 595   {
 596     return NULL;
 597   }
 598   inet_ntop (af, sb, buf, INET6_ADDRSTRLEN);
 599
 600   GNUNET_snprintf (rbuf, sizeof (rbuf),
 601                    (af == AF_INET6) ? "%s.%u.[%s]:%u" : "%s.%u.%s:%u",
 602                    PLUGIN_NAME, options, buf, port);
 603   return rbuf;
 604 }
 605
 606
 607 /**
 608  * Function called to convert a string address to
 609  * a binary address.
 610  *
 611  * @param cls closure ('struct Plugin*')
 612  * @param addr string address
 613  * @param addrlen length of the address
 614  * @param buf location to store the buffer
 615  * @param added location to store the number of bytes in the buffer.
 616  *        If the function returns GNUNET_SYSERR, its contents are undefined.
 617  * @return GNUNET_OK on success, GNUNET_SYSERR on failure
 618  */
 619 static int
 620 udp_string_to_address (void *cls, const char *addr, uint16_t addrlen,
 621     void **buf, size_t *added)
 622 {
 623   struct sockaddr_storage socket_address;
 624   char *address;
 625   char *plugin;
 626   char *optionstr;
 627   uint32_t options;
 628
 629   /* Format tcp.options.address:port */
 630   address = NULL;
 631   plugin = NULL;
 632   optionstr = NULL;
 633
 634   if ((NULL == addr) || (addrlen == 0))
 635   {
 636     GNUNET_break (0);
 637     return GNUNET_SYSERR;
 638   }
 639   if ('\0' != addr[addrlen - 1])
 640   {
 641     GNUNET_break (0);
 642     return GNUNET_SYSERR;
 643   }
 644   if (strlen (addr) != addrlen - 1)
 645   {
 646     GNUNET_break (0);
 647     return GNUNET_SYSERR;
 648   }
 649   plugin = GNUNET_strdup (addr);
 650   optionstr = strchr (plugin, '.');
 651   if (NULL == optionstr)
 652   {
 653     GNUNET_break (0);
 654     GNUNET_free (plugin);
 655     return GNUNET_SYSERR;
 656   }
 657   optionstr[0] = '\0';
 658   optionstr ++;
 659   options = atol (optionstr);
 660   address = strchr (optionstr, '.');
 661   if (NULL == address)
 662   {
 663     GNUNET_break (0);
 664     GNUNET_free (plugin);
 665     return GNUNET_SYSERR;
 666   }
 667   address[0] = '\0';
 668   address ++;
 669
 670   if (GNUNET_OK !=
 671       GNUNET_STRINGS_to_address_ip (address, strlen (address),
 672                                     &socket_address))
 673   {
 674     GNUNET_break (0);
 675     GNUNET_free (plugin);
 676     return GNUNET_SYSERR;
 677   }
 678
 679   GNUNET_free (plugin);
 680
 681   switch (socket_address.ss_family)
 682   {
 683   case AF_INET:
 684     {
 685       struct IPv4UdpAddress *u4;
 686       struct sockaddr_in *in4 = (struct sockaddr_in *) &socket_address;
 687       u4 = GNUNET_new (struct IPv4UdpAddress);
 688       u4->options =  htonl (options);
 689       u4->ipv4_addr = in4->sin_addr.s_addr;
 690       u4->u4_port = in4->sin_port;
 691       *buf = u4;
 692       *added = sizeof (struct IPv4UdpAddress);
 693       return GNUNET_OK;
 694     }
 695   case AF_INET6:
 696     {
 697       struct IPv6UdpAddress *u6;
 698       struct sockaddr_in6 *in6 = (struct sockaddr_in6 *) &socket_address;
 699       u6 = GNUNET_new (struct IPv6UdpAddress);
 700       u6->options =  htonl (options);
 701       u6->ipv6_addr = in6->sin6_addr;
 702       u6->u6_port = in6->sin6_port;
 703       *buf = u6;
 704       *added = sizeof (struct IPv6UdpAddress);
 705       return GNUNET_OK;
 706     }
 707   default:
 708     GNUNET_break (0);
 709     return GNUNET_SYSERR;
 710   }
 711 }
 712
 713
 714 static void
 715 ppc_cancel_task (void *cls,
 716                  const struct GNUNET_SCHEDULER_TaskContext *tc)
 717 {
 718   struct PrettyPrinterContext *ppc = cls;
 719
 720   ppc->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 721   if (NULL != ppc->resolver_handle)
 722   {
 723     GNUNET_RESOLVER_request_cancel (ppc->resolver_handle);
 724     ppc->resolver_handle = NULL;
 725   }
 726   GNUNET_CONTAINER_DLL_remove (ppc_dll_head, ppc_dll_tail, ppc);
 727   GNUNET_free (ppc);
 728 }
 729
 730
 731 /**
 732  * Append our port and forward the result.
 733  *
 734  * @param cls a 'struct PrettyPrinterContext'
 735  * @param hostname result from DNS resolver
 736  */
 737 static void
 738 append_port (void *cls, const char *hostname)
 739 {
 740   struct PrettyPrinterContext *ppc = cls;
 741   struct PrettyPrinterContext *cur;
 742   char *ret;
 743
 744   if (hostname == NULL)
 745   {
 746     ppc->asc (ppc->asc_cls, NULL);
 747     GNUNET_CONTAINER_DLL_remove (ppc_dll_head, ppc_dll_tail, ppc);
 748     GNUNET_SCHEDULER_cancel (ppc->timeout_task);
 749     ppc->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 750     ppc->resolver_handle = NULL;
 751     GNUNET_free (ppc);
 752     return;
 753   }
 754   for (cur = ppc_dll_head; (NULL != cur); cur = cur->next)
 755   {
 756     if (cur == ppc)
 757       break;
 758   }
 759   if (NULL == cur)
 760   {
 761     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 762                 "Invalid callback for PPC %p \n", ppc);
 763     return;
 764   }
 765
 766   if (GNUNET_YES == ppc->ipv6)
 767     GNUNET_asprintf (&ret,
 768                      "%s.%u.[%s]:%d",
 769                      PLUGIN_NAME,
 770                      ppc->options,
 771                      hostname,
 772                      ppc->port);
 773   else
 774     GNUNET_asprintf (&ret,
 775                      "%s.%u.%s:%d",
 776                      PLUGIN_NAME,
 777                      ppc->options,
 778                      hostname,
 779                      ppc->port);
 780   ppc->asc (ppc->asc_cls, ret);
 781   GNUNET_free (ret);
 782 }
 783
 784
 785 /**
 786  * Convert the transports address to a nice, human-readable
 787  * format.
 788  *
 789  * @param cls closure
 790  * @param type name of the transport that generated the address
 791  * @param addr one of the addresses of the host, NULL for the last address
 792  *        the specific address format depends on the transport
 793  * @param addrlen length of the address
 794  * @param numeric should (IP) addresses be displayed in numeric form?
 795  * @param timeout after how long should we give up?
 796  * @param asc function to call on each string
 797  * @param asc_cls closure for @a asc
 798  */
 799 static void
 800 udp_plugin_address_pretty_printer (void *cls, const char *type,
 801                                    const void *addr, size_t addrlen,
 802                                    int numeric,
 803                                    struct GNUNET_TIME_Relative timeout,
 804                                    GNUNET_TRANSPORT_AddressStringCallback asc,
 805                                    void *asc_cls)
 806 {
 807   struct PrettyPrinterContext *ppc;
 808   const void *sb;
 809   size_t sbs;
 810   struct sockaddr_in a4;
 811   struct sockaddr_in6 a6;
 812   const struct IPv4UdpAddress *u4;
 813   const struct IPv6UdpAddress *u6;
 814   uint16_t port;
 815   uint32_t options;
 816
 817   if (addrlen == sizeof (struct IPv6UdpAddress))
 818   {
 819     u6 = addr;
 820     memset (&a6, 0, sizeof (a6));
 821     a6.sin6_family = AF_INET6;
 822 #if HAVE_SOCKADDR_IN_SIN_LEN
 823     a6.sin6_len = sizeof (a6);
 824 #endif
 825     a6.sin6_port = u6->u6_port;
 826     memcpy (&a6.sin6_addr, &u6->ipv6_addr, sizeof (struct in6_addr));
 827     port = ntohs (u6->u6_port);
 828     options = ntohl (u6->options);
 829     sb = &a6;
 830     sbs = sizeof (a6);
 831   }
 832   else if (addrlen == sizeof (struct IPv4UdpAddress))
 833   {
 834     u4 = addr;
 835     memset (&a4, 0, sizeof (a4));
 836     a4.sin_family = AF_INET;
 837 #if HAVE_SOCKADDR_IN_SIN_LEN
 838     a4.sin_len = sizeof (a4);
 839 #endif
 840     a4.sin_port = u4->u4_port;
 841     a4.sin_addr.s_addr = u4->ipv4_addr;
 842     port = ntohs (u4->u4_port);
 843     options = ntohl (u4->options);
 844     sb = &a4;
 845     sbs = sizeof (a4);
 846   }
 847   else
 848   {
 849     /* invalid address */
 850     GNUNET_break_op (0);
 851     asc (asc_cls, NULL);
 852     return;
 853   }
 854   ppc = GNUNET_new (struct PrettyPrinterContext);
 855   ppc->asc = asc;
 856   ppc->asc_cls = asc_cls;
 857   ppc->port = port;
 858   ppc->options = options;
 859   if (addrlen == sizeof (struct IPv6UdpAddress))
 860     ppc->ipv6 = GNUNET_YES;
 861   else
 862     ppc->ipv6 = GNUNET_NO;
 863   ppc->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(timeout, 2),
 864                 &ppc_cancel_task, ppc);
 865   GNUNET_CONTAINER_DLL_insert (ppc_dll_head, ppc_dll_tail, ppc);
 866   ppc->resolver_handle = GNUNET_RESOLVER_hostname_get (sb, sbs,
 867                                                        !numeric,
 868                                                        timeout,
 869                                                        &append_port, ppc);
 870 }
 871
 872
 873 static void
 874 call_continuation (struct UDP_MessageWrapper *udpw, int result)
 875 {
 876   size_t overhead;
 877
 878   LOG (GNUNET_ERROR_TYPE_DEBUG,
 879       "Calling continuation for %u byte message to `%s' with result %s\n",
 880       udpw->payload_size, GNUNET_i2s (&udpw->session->target),
 881       (GNUNET_OK == result) ? "OK" : "SYSERR");
 882
 883   if (udpw->msg_size >= udpw->payload_size)
 884     overhead = udpw->msg_size - udpw->payload_size;
 885   else
 886     overhead = udpw->msg_size;
 887
 888   switch (result) {
 889     case GNUNET_OK:
 890       switch (udpw->msg_type) {
 891         case MSG_UNFRAGMENTED:
 892           if (NULL != udpw->cont)
 893           {
 894             /* Transport continuation */
 895             udpw->cont (udpw->cont_cls, &udpw->session->target, result,
 896                       udpw->payload_size, udpw->msg_size);
 897           }
 898           GNUNET_STATISTICS_update (plugin->env->stats,
 899                                     "# UDP, unfragmented msgs, messages, sent, success",
 900                                     1, GNUNET_NO);
 901           GNUNET_STATISTICS_update (plugin->env->stats,
 902                                     "# UDP, unfragmented msgs, bytes payload, sent, success",
 903                                     udpw->payload_size, GNUNET_NO);
 904           GNUNET_STATISTICS_update (plugin->env->stats,
 905                                     "# UDP, unfragmented msgs, bytes overhead, sent, success",
 906                                     overhead, GNUNET_NO);
 907           GNUNET_STATISTICS_update (plugin->env->stats,
 908                                     "# UDP, total, bytes overhead, sent",
 909                                     overhead, GNUNET_NO);
 910           GNUNET_STATISTICS_update (plugin->env->stats,
 911                                     "# UDP, total, bytes payload, sent",
 912                                     udpw->payload_size, GNUNET_NO);
 913           break;
 914         case MSG_FRAGMENTED_COMPLETE:
 915           GNUNET_assert (NULL != udpw->frag_ctx);
 916           if (udpw->frag_ctx->cont != NULL)
 917             udpw->frag_ctx->cont (udpw->frag_ctx->cont_cls, &udpw->session->target, GNUNET_OK,
 918                                udpw->frag_ctx->payload_size, udpw->frag_ctx->on_wire_size);
 919           GNUNET_STATISTICS_update (plugin->env->stats,
 920                                     "# UDP, fragmented msgs, messages, sent, success",
 921                                     1, GNUNET_NO);
 922           GNUNET_STATISTICS_update (plugin->env->stats,
 923                                     "# UDP, fragmented msgs, bytes payload, sent, success",
 924                                     udpw->payload_size, GNUNET_NO);
 925           GNUNET_STATISTICS_update (plugin->env->stats,
 926                                     "# UDP, fragmented msgs, bytes overhead, sent, success",
 927                                     overhead, GNUNET_NO);
 928           GNUNET_STATISTICS_update (plugin->env->stats,
 929                                     "# UDP, total, bytes overhead, sent",
 930                                     overhead, GNUNET_NO);
 931           GNUNET_STATISTICS_update (plugin->env->stats,
 932                                     "# UDP, total, bytes payload, sent",
 933                                     udpw->payload_size, GNUNET_NO);
 934           GNUNET_STATISTICS_update (plugin->env->stats,
 935                                     "# UDP, fragmented msgs, messages, pending",
 936                                     -1, GNUNET_NO);
 937           break;
 938         case MSG_FRAGMENTED:
 939           /* Fragmented message: enqueue next fragment */
 940           if (NULL != udpw->cont)
 941             udpw->cont (udpw->cont_cls, &udpw->session->target, result,
 942                       udpw->payload_size, udpw->msg_size);
 943           GNUNET_STATISTICS_update (plugin->env->stats,
 944                                     "# UDP, fragmented msgs, fragments, sent, success",
 945                                     1, GNUNET_NO);
 946           GNUNET_STATISTICS_update (plugin->env->stats,
 947                                     "# UDP, fragmented msgs, fragments bytes, sent, success",
 948                                     udpw->msg_size, GNUNET_NO);
 949           break;
 950         case MSG_ACK:
 951           /* No continuation */
 952           GNUNET_STATISTICS_update (plugin->env->stats,
 953                                     "# UDP, ACK msgs, messages, sent, success",
 954                                     1, GNUNET_NO);
 955           GNUNET_STATISTICS_update (plugin->env->stats,
 956                                     "# UDP, ACK msgs, bytes overhead, sent, success",
 957                                     overhead, GNUNET_NO);
 958           GNUNET_STATISTICS_update (plugin->env->stats,
 959                                     "# UDP, total, bytes overhead, sent",
 960                                     overhead, GNUNET_NO);
 961           break;
 962         case MSG_BEACON:
 963           GNUNET_break (0);
 964           break;
 965         default:
 966           LOG (GNUNET_ERROR_TYPE_ERROR,
 967               "ERROR: %u\n", udpw->msg_type);
 968           GNUNET_break (0);
 969           break;
 970       }
 971       break;
 972     case GNUNET_SYSERR:
 973       switch (udpw->msg_type) {
 974         case MSG_UNFRAGMENTED:
 975           /* Unfragmented message: failed to send */
 976           if (NULL != udpw->cont)
 977             udpw->cont (udpw->cont_cls, &udpw->session->target, result,
 978                       udpw->payload_size, overhead);
 979           GNUNET_STATISTICS_update (plugin->env->stats,
 980                                   "# UDP, unfragmented msgs, messages, sent, failure",
 981                                   1, GNUNET_NO);
 982           GNUNET_STATISTICS_update (plugin->env->stats,
 983                                     "# UDP, unfragmented msgs, bytes payload, sent, failure",
 984                                     udpw->payload_size, GNUNET_NO);
 985           GNUNET_STATISTICS_update (plugin->env->stats,
 986                                     "# UDP, unfragmented msgs, bytes overhead, sent, failure",
 987                                     overhead, GNUNET_NO);
 988           break;
 989         case MSG_FRAGMENTED_COMPLETE:
 990           GNUNET_assert (NULL != udpw->frag_ctx);
 991           if (udpw->frag_ctx->cont != NULL)
 992             udpw->frag_ctx->cont (udpw->frag_ctx->cont_cls, &udpw->session->target, GNUNET_SYSERR,
 993                                udpw->frag_ctx->payload_size, udpw->frag_ctx->on_wire_size);
 994           GNUNET_STATISTICS_update (plugin->env->stats,
 995                                     "# UDP, fragmented msgs, messages, sent, failure",
 996                                     1, GNUNET_NO);
 997           GNUNET_STATISTICS_update (plugin->env->stats,
 998                                     "# UDP, fragmented msgs, bytes payload, sent, failure",
 999                                     udpw->payload_size, GNUNET_NO);
1000           GNUNET_STATISTICS_update (plugin->env->stats,
1001                                     "# UDP, fragmented msgs, bytes payload, sent, failure",
1002                                     overhead, GNUNET_NO);
1003           GNUNET_STATISTICS_update (plugin->env->stats,
1004                                     "# UDP, fragmented msgs, bytes payload, sent, failure",
1005                                     overhead, GNUNET_NO);
1006           GNUNET_STATISTICS_update (plugin->env->stats,
1007                                     "# UDP, fragmented msgs, messages, pending",
1008                                     -1, GNUNET_NO);
1009           break;
1010         case MSG_FRAGMENTED:
1011           GNUNET_assert (NULL != udpw->frag_ctx);
1012           /* Fragmented message: failed to send */
1013           GNUNET_STATISTICS_update (plugin->env->stats,
1014                                     "# UDP, fragmented msgs, fragments, sent, failure",
1015                                     1, GNUNET_NO);
1016           GNUNET_STATISTICS_update (plugin->env->stats,
1017                                     "# UDP, fragmented msgs, fragments bytes, sent, failure",
1018                                     udpw->msg_size, GNUNET_NO);
1019           break;
1020         case MSG_ACK:
1021           /* ACK message: failed to send */
1022           GNUNET_STATISTICS_update (plugin->env->stats,
1023                                     "# UDP, ACK msgs, messages, sent, failure",
1024                                     1, GNUNET_NO);
1025           break;
1026         case MSG_BEACON:
1027           /* Beacon message: failed to send */
1028           GNUNET_break (0);
1029           break;
1030         default:
1031           GNUNET_break (0);
1032           break;
1033       }
1034       break;
1035     default:
1036       GNUNET_break (0);
1037       break;
1038   }
1039 }
1040
1041
1042 /**
1043  * Check if the given port is plausible (must be either our listen
1044  * port or our advertised port).  If it is neither, we return
1045  * #GNUNET_SYSERR.
1046  *
1047  * @param plugin global variables
1048  * @param in_port port number to check
1049  * @return #GNUNET_OK if port is either open_port or adv_port
1050  */
1051 static int
1052 check_port (struct Plugin *plugin, uint16_t in_port)
1053 {
1054   if ((in_port == plugin->port) || (in_port == plugin->aport))
1055     return GNUNET_OK;
1056   return GNUNET_SYSERR;
1057 }
1058
1059
1060 /**
1061  * Function that will be called to check if a binary address for this
1062  * plugin is well-formed and corresponds to an address for THIS peer
1063  * (as per our configuration).  Naturally, if absolutely necessary,
1064  * plugins can be a bit conservative in their answer, but in general
1065  * plugins should make sure that the address does not redirect
1066  * traffic to a 3rd party that might try to man-in-the-middle our
1067  * traffic.
1068  *
1069  * @param cls closure, should be our handle to the Plugin
1070  * @param addr pointer to the address
1071  * @param addrlen length of @a addr
1072  * @return #GNUNET_OK if this is a plausible address for this peer
1073  *         and transport, #GNUNET_SYSERR if not
1074  *
1075  */
1076 static int
1077 udp_plugin_check_address (void *cls,
1078                           const void *addr,
1079                           size_t addrlen)
1080 {
1081   struct Plugin *plugin = cls;
1082   struct IPv4UdpAddress *v4;
1083   struct IPv6UdpAddress *v6;
1084
1085   if ((addrlen != sizeof (struct IPv4UdpAddress)) &&
1086       (addrlen != sizeof (struct IPv6UdpAddress)))
1087   {
1088     GNUNET_break_op (0);
1089     return GNUNET_SYSERR;
1090   }
1091   if (addrlen == sizeof (struct IPv4UdpAddress))
1092   {
1093     v4 = (struct IPv4UdpAddress *) addr;
1094     if (GNUNET_OK != check_port (plugin, ntohs (v4->u4_port)))
1095       return GNUNET_SYSERR;
1096     if (GNUNET_OK !=
1097         GNUNET_NAT_test_address (plugin->nat, &v4->ipv4_addr,
1098                                  sizeof (struct in_addr)))
1099       return GNUNET_SYSERR;
1100   }
1101   else
1102   {
1103     v6 = (struct IPv6UdpAddress *) addr;
1104     if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr))
1105     {
1106       GNUNET_break_op (0);
1107       return GNUNET_SYSERR;
1108     }
1109     if (GNUNET_OK != check_port (plugin, ntohs (v6->u6_port)))
1110       return GNUNET_SYSERR;
1111     if (GNUNET_OK !=
1112         GNUNET_NAT_test_address (plugin->nat, &v6->ipv6_addr,
1113                                  sizeof (struct in6_addr)))
1114       return GNUNET_SYSERR;
1115   }
1116   return GNUNET_OK;
1117 }
1118
1119
1120 /**
1121  * Function to free last resources associated with a session.
1122  *
1123  * @param s session to free
1124  */
1125 static void
1126 free_session (struct Session *s)
1127 {
1128   if (NULL != s->frag_ctx)
1129   {
1130     GNUNET_FRAGMENT_context_destroy (s->frag_ctx->frag, NULL, NULL);
1131     GNUNET_free (s->frag_ctx);
1132     s->frag_ctx = NULL;
1133   }
1134   GNUNET_free (s);
1135 }
1136
1137
1138 static void
1139 dequeue (struct Plugin *plugin,
1140          struct UDP_MessageWrapper * udpw)
1141 {
1142   if (plugin->bytes_in_buffer < udpw->msg_size)
1143       GNUNET_break (0);
1144   else
1145   {
1146     GNUNET_STATISTICS_update (plugin->env->stats,
1147                               "# UDP, total, bytes in buffers",
1148                               - (long long) udpw->msg_size, GNUNET_NO);
1149     plugin->bytes_in_buffer -= udpw->msg_size;
1150   }
1151   GNUNET_STATISTICS_update (plugin->env->stats,
1152                             "# UDP, total, msgs in buffers",
1153                             -1, GNUNET_NO);
1154   if (udpw->session->addrlen == sizeof (struct sockaddr_in))
1155     GNUNET_CONTAINER_DLL_remove (plugin->ipv4_queue_head,
1156                                  plugin->ipv4_queue_tail, udpw);
1157   if (udpw->session->addrlen == sizeof (struct sockaddr_in6))
1158     GNUNET_CONTAINER_DLL_remove (plugin->ipv6_queue_head,
1159                                  plugin->ipv6_queue_tail, udpw);
1160 }
1161
1162
1163 static void
1164 fragmented_message_done (struct UDP_FragmentationContext *fc, int result)
1165 {
1166   struct UDP_MessageWrapper *udpw;
1167   struct UDP_MessageWrapper *tmp;
1168   struct UDP_MessageWrapper dummy;
1169   struct Session *s = fc->session;
1170
1171   LOG (GNUNET_ERROR_TYPE_DEBUG,
1172        "%p : Fragmented message removed with result %s\n",
1173        fc,
1174        (result == GNUNET_SYSERR) ? "FAIL" : "SUCCESS");
1175
1176   /* Call continuation for fragmented message */
1177   memset (&dummy, 0, sizeof (dummy));
1178   dummy.msg_type = MSG_FRAGMENTED_COMPLETE;
1179   dummy.msg_size = s->frag_ctx->on_wire_size;
1180   dummy.payload_size = s->frag_ctx->payload_size;
1181   dummy.frag_ctx = s->frag_ctx;
1182   dummy.cont = NULL;
1183   dummy.cont_cls = NULL;
1184   dummy.session = s;
1185
1186   call_continuation (&dummy, result);
1187
1188   /* Remove leftover fragments from queue */
1189   if (s->addrlen == sizeof (struct sockaddr_in6))
1190   {
1191     udpw = plugin->ipv6_queue_head;
1192     while (NULL != udpw)
1193     {
1194       tmp = udpw->next;
1195       if ((udpw->frag_ctx != NULL) && (udpw->frag_ctx == s->frag_ctx))
1196       {
1197         dequeue (plugin, udpw);
1198         call_continuation (udpw, GNUNET_SYSERR);
1199         GNUNET_free (udpw);
1200       }
1201       udpw = tmp;
1202     }
1203   }
1204   if (s->addrlen == sizeof (struct sockaddr_in))
1205   {
1206     udpw = plugin->ipv4_queue_head;
1207     while (udpw!= NULL)
1208     {
1209       tmp = udpw->next;
1210       if ((NULL != udpw->frag_ctx) && (udpw->frag_ctx == s->frag_ctx))
1211       {
1212         dequeue (plugin, udpw);
1213         call_continuation (udpw, GNUNET_SYSERR);
1214         GNUNET_free (udpw);
1215       }
1216       udpw = tmp;
1217     }
1218   }
1219
1220   /* Destroy fragmentation context */
1221   GNUNET_FRAGMENT_context_destroy (fc->frag,
1222                                      &s->last_expected_msg_delay,
1223                                      &s->last_expected_ack_delay);
1224   s->frag_ctx = NULL;
1225   GNUNET_free (fc);
1226 }
1227
1228
1229 /**
1230  * Functions with this signature are called whenever we need
1231  * to close a session due to a disconnect or failure to
1232  * establish a connection.
1233  *
1234  * @param cls closure with the `struct Plugin`
1235  * @param s session to close down
1236  * @return #GNUNET_OK on success
1237  */
1238 static int
1239 udp_disconnect_session (void *cls,
1240                         struct Session *s)
1241 {
1242   struct Plugin *plugin = cls;
1243   struct UDP_MessageWrapper *udpw;
1244   struct UDP_MessageWrapper *next;
1245
1246   GNUNET_assert (GNUNET_YES != s->in_destroy);
1247   LOG (GNUNET_ERROR_TYPE_DEBUG,
1248        "Session %p to peer `%s' address ended\n",
1249        s,
1250        GNUNET_i2s (&s->target),
1251        GNUNET_a2s (s->sock_addr, s->addrlen));
1252   /* stop timeout task */
1253   if (GNUNET_SCHEDULER_NO_TASK != s->timeout_task)
1254   {
1255     GNUNET_SCHEDULER_cancel (s->timeout_task);
1256     s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1257   }
1258   if (NULL != s->frag_ctx)
1259   {
1260     /* Remove fragmented message due to disconnect */
1261     fragmented_message_done (s->frag_ctx, GNUNET_SYSERR);
1262   }
1263
1264   next = plugin->ipv4_queue_head;
1265   while (NULL != (udpw = next))
1266   {
1267     next = udpw->next;
1268     if (udpw->session == s)
1269     {
1270       dequeue (plugin, udpw);
1271       call_continuation (udpw, GNUNET_SYSERR);
1272       GNUNET_free (udpw);
1273     }
1274   }
1275   next = plugin->ipv6_queue_head;
1276   while (NULL != (udpw = next))
1277   {
1278     next = udpw->next;
1279     if (udpw->session == s)
1280     {
1281       dequeue (plugin, udpw);
1282       call_continuation (udpw, GNUNET_SYSERR);
1283       GNUNET_free (udpw);
1284     }
1285   }
1286   plugin->env->session_end (plugin->env->cls, &s->target, s);
1287
1288   if (NULL != s->frag_ctx)
1289   {
1290     if (NULL != s->frag_ctx->cont)
1291     {
1292       s->frag_ctx->cont (s->frag_ctx->cont_cls, &s->target, GNUNET_SYSERR,
1293                          s->frag_ctx->payload_size, s->frag_ctx->on_wire_size);
1294       LOG (GNUNET_ERROR_TYPE_DEBUG,
1295           "Calling continuation for fragemented message to `%s' with result SYSERR\n",
1296           GNUNET_i2s (&s->target));
1297     }
1298   }
1299
1300   GNUNET_assert (GNUNET_YES ==
1301                  GNUNET_CONTAINER_multipeermap_remove (plugin->sessions,
1302                                                        &s->target,
1303                                                        s));
1304   GNUNET_STATISTICS_set (plugin->env->stats,
1305                          "# UDP, sessions active",
1306                          GNUNET_CONTAINER_multipeermap_size(plugin->sessions),
1307                          GNUNET_NO);
1308   if (s->rc > 0)
1309     s->in_destroy = GNUNET_YES;
1310   else
1311     free_session (s);
1312   return GNUNET_OK;
1313 }
1314
1315
1316 /**
1317  * Function that is called to get the keepalive factor.
1318  * GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to
1319  * calculate the interval between keepalive packets.
1320  *
1321  * @param cls closure with the `struct Plugin`
1322  * @return keepalive factor
1323  */
1324 static unsigned int
1325 udp_query_keepalive_factor (void *cls)
1326 {
1327   return 15;
1328 }
1329
1330
1331 /**
1332  * Destroy a session, plugin is being unloaded.
1333  *
1334  * @param cls the `struct Plugin`
1335  * @param key hash of public key of target peer
1336  * @param value a `struct PeerSession *` to clean up
1337  * @return #GNUNET_OK (continue to iterate)
1338  */
1339 static int
1340 disconnect_and_free_it (void *cls,
1341                         const struct GNUNET_PeerIdentity *key,
1342                         void *value)
1343 {
1344   struct Plugin *plugin = cls;
1345
1346   udp_disconnect_session (plugin, value);
1347   return GNUNET_OK;
1348 }
1349
1350
1351 /**
1352  * Disconnect from a remote node.  Clean up session if we have one for
1353  * this peer.
1354  *
1355  * @param cls closure for this call (should be handle to Plugin)
1356  * @param target the peeridentity of the peer to disconnect
1357  * @return #GNUNET_OK on success, #GNUNET_SYSERR if the operation failed
1358  */
1359 static void
1360 udp_disconnect (void *cls,
1361                 const struct GNUNET_PeerIdentity *target)
1362 {
1363   struct Plugin *plugin = cls;
1364
1365   LOG (GNUNET_ERROR_TYPE_DEBUG,
1366        "Disconnecting from peer `%s'\n",
1367        GNUNET_i2s (target));
1368   /* Clean up sessions */
1369   GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessions, target,
1370                                               &disconnect_and_free_it, plugin);
1371 }
1372
1373
1374 /**
1375  * Session was idle, so disconnect it
1376  *
1377  * @param cls the `struct Session` to time out
1378  * @param tc scheduler context
1379  */
1380 static void
1381 session_timeout (void *cls,
1382                  const struct GNUNET_SCHEDULER_TaskContext *tc)
1383 {
1384   struct Session *s = cls;
1385
1386   s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
1387   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1388               "Session %p was idle for %s, disconnecting\n",
1389               s,
1390               GNUNET_STRINGS_relative_time_to_string (UDP_SESSION_TIME_OUT,
1391                                                       GNUNET_YES));
1392   /* call session destroy function */
1393   udp_disconnect_session (s->plugin,
1394                           s);
1395 }
1396
1397
1398 /**
1399  * Increment session timeout due to activity
1400  *
1401  * @param s session to reschedule timeout activity for
1402  */
1403 static void
1404 reschedule_session_timeout (struct Session *s)
1405 {
1406   if (GNUNET_YES == s->in_destroy)
1407     return;
1408   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != s->timeout_task);
1409   GNUNET_SCHEDULER_cancel (s->timeout_task);
1410   s->timeout_task = GNUNET_SCHEDULER_add_delayed (UDP_SESSION_TIME_OUT,
1411                                                   &session_timeout,
1412                                                   s);
1413   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1414               "Timeout restarted for session %p\n",
1415               s);
1416 }
1417
1418
1419 static struct Session *
1420 create_session (struct Plugin *plugin,
1421                 const struct GNUNET_PeerIdentity *target,
1422                 const void *addr, size_t addrlen,
1423                 GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
1424 {
1425   struct Session *s;
1426   const struct IPv4UdpAddress *t4;
1427   const struct IPv6UdpAddress *t6;
1428   struct sockaddr_in *v4;
1429   struct sockaddr_in6 *v6;
1430   size_t len;
1431
1432   if (NULL == addr)
1433   {
1434     GNUNET_break (0);
1435     return NULL;
1436   }
1437
1438   switch (addrlen)
1439   {
1440   case sizeof (struct IPv4UdpAddress):
1441     if (NULL == plugin->sockv4)
1442     {
1443       LOG (GNUNET_ERROR_TYPE_DEBUG,
1444            "Could not create session for peer `%s' address `%s': IPv4 is not enabled\n",
1445            GNUNET_i2s(target),
1446            udp_address_to_string (NULL, addr, addrlen));
1447       return NULL;
1448     }
1449     t4 = addr;
1450     s = GNUNET_malloc (sizeof (struct Session) + sizeof (struct sockaddr_in));
1451     s->plugin = plugin;
1452     len = sizeof (struct sockaddr_in);
1453     v4 = (struct sockaddr_in *) &s[1];
1454     v4->sin_family = AF_INET;
1455 #if HAVE_SOCKADDR_IN_SIN_LEN
1456     v4->sin_len = sizeof (struct sockaddr_in);
1457 #endif
1458     v4->sin_port = t4->u4_port;
1459     v4->sin_addr.s_addr = t4->ipv4_addr;
1460     s->ats = plugin->env->get_address_type (plugin->env->cls, (const struct sockaddr *) v4, sizeof (struct sockaddr_in));
1461     break;
1462   case sizeof (struct IPv6UdpAddress):
1463     if (NULL == plugin->sockv6)
1464     {
1465       LOG (GNUNET_ERROR_TYPE_INFO,
1466            "Could not create session for peer `%s' address `%s': IPv6 is not enabled\n",
1467            GNUNET_i2s(target),
1468            udp_address_to_string(NULL, addr, addrlen));
1469       return NULL;
1470     }
1471     t6 = addr;
1472     s = GNUNET_malloc (sizeof (struct Session) + sizeof (struct sockaddr_in6));
1473     s->plugin = plugin;
1474     len = sizeof (struct sockaddr_in6);
1475     v6 = (struct sockaddr_in6 *) &s[1];
1476     v6->sin6_family = AF_INET6;
1477 #if HAVE_SOCKADDR_IN_SIN_LEN
1478     v6->sin6_len = sizeof (struct sockaddr_in6);
1479 #endif
1480     v6->sin6_port = t6->u6_port;
1481     v6->sin6_addr = t6->ipv6_addr;
1482     s->ats = plugin->env->get_address_type (plugin->env->cls, (const struct sockaddr *) v6, sizeof (struct sockaddr_in6));
1483     break;
1484   default:
1485     /* Must have a valid address to send to */
1486     GNUNET_STATISTICS_update (plugin->env->stats,
1487                               gettext_noop
1488                               ("# requests to create session with invalid address"),
1489                               1, GNUNET_NO);
1490     return NULL;
1491   }
1492   s->addrlen = len;
1493   s->target = *target;
1494   s->sock_addr = (const struct sockaddr *) &s[1];
1495   s->last_expected_ack_delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250);
1496   s->last_expected_msg_delay = GNUNET_TIME_UNIT_MILLISECONDS;
1497   s->flow_delay_from_other_peer = GNUNET_TIME_UNIT_ZERO_ABS;
1498   s->flow_delay_for_other_peer = GNUNET_TIME_UNIT_ZERO;
1499   s->inbound = GNUNET_NO;
1500   s->timeout_task =  GNUNET_SCHEDULER_add_delayed (UDP_SESSION_TIME_OUT,
1501                                                    &session_timeout,
1502                                                    s);
1503   return s;
1504 }
1505
1506
1507 static int
1508 session_cmp_it (void *cls,
1509                 const struct GNUNET_PeerIdentity * key,
1510                 void *value)
1511 {
1512   struct SessionCompareContext * cctx = cls;
1513   const struct GNUNET_HELLO_Address *address = cctx->addr;
1514   struct Session *s = value;
1515   socklen_t s_addrlen = s->addrlen;
1516
1517   LOG (GNUNET_ERROR_TYPE_DEBUG,
1518        "Comparing address %s <-> %s\n",
1519        udp_address_to_string (NULL, (void *) address->address,
1520                               address->address_length),
1521        GNUNET_a2s (s->sock_addr, s->addrlen));
1522   if (s->inbound != cctx->inbound)
1523     return GNUNET_YES;
1524   if ((address->address_length == sizeof (struct IPv4UdpAddress)) &&
1525       (s_addrlen == sizeof (struct sockaddr_in)))
1526   {
1527     struct IPv4UdpAddress * u4 = NULL;
1528     u4 = (struct IPv4UdpAddress *) address->address;
1529     GNUNET_assert (NULL != u4);
1530     const struct sockaddr_in *s4 = (const struct sockaddr_in *) s->sock_addr;
1531     if ((0 == memcmp ((const void *) &u4->ipv4_addr,(const void *) &s4->sin_addr, sizeof (struct in_addr))) &&
1532         (u4->u4_port == s4->sin_port))
1533     {
1534       cctx->res = s;
1535       return GNUNET_NO;
1536     }
1537
1538   }
1539   if ((address->address_length == sizeof (struct IPv6UdpAddress)) &&
1540       (s_addrlen == sizeof (struct sockaddr_in6)))
1541   {
1542     struct IPv6UdpAddress * u6 = NULL;
1543     u6 = (struct IPv6UdpAddress *) address->address;
1544     GNUNET_assert (NULL != u6);
1545     const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) s->sock_addr;
1546     if ((0 == memcmp (&u6->ipv6_addr, &s6->sin6_addr, sizeof (struct in6_addr))) &&
1547         (u6->u6_port == s6->sin6_port))
1548     {
1549       cctx->res = s;
1550       return GNUNET_NO;
1551     }
1552   }
1553   return GNUNET_YES;
1554 }
1555
1556
1557 /**
1558  * Function obtain the network type for a session
1559  *
1560  * @param cls closure ('struct Plugin*')
1561  * @param session the session
1562  * @return the network type
1563  */
1564 static enum GNUNET_ATS_Network_Type
1565 udp_get_network (void *cls,
1566                  struct Session *session)
1567 {
1568   return ntohl (session->ats.value);
1569 }
1570
1571
1572 /**
1573  * Creates a new outbound session the transport service will use to
1574  * send data to the peer
1575  *
1576  * @param cls the plugin
1577  * @param address the address
1578  * @param inbound look for inbound session
1579  * @return the session or NULL of max connections exceeded
1580  */
1581 static struct Session *
1582 udp_plugin_lookup_session (void *cls,
1583                            const struct GNUNET_HELLO_Address *address,
1584                            int inbound)
1585 {
1586   struct Plugin * plugin = cls;
1587   struct IPv6UdpAddress * udp_a6;
1588   struct IPv4UdpAddress * udp_a4;
1589
1590   GNUNET_assert (plugin != NULL);
1591   GNUNET_assert (address != NULL);
1592
1593
1594   if ((address->address == NULL) ||
1595       ((address->address_length != sizeof (struct IPv4UdpAddress)) &&
1596       (address->address_length != sizeof (struct IPv6UdpAddress))))
1597   {
1598     LOG (GNUNET_ERROR_TYPE_WARNING,
1599         _("Trying to create session for address of unexpected length %u (should be %u or %u)\n"),
1600         address->address_length,
1601         sizeof (struct IPv4UdpAddress),
1602         sizeof (struct IPv6UdpAddress));
1603     return NULL;
1604   }
1605
1606   if (address->address_length == sizeof (struct IPv4UdpAddress))
1607   {
1608     if (plugin->sockv4 == NULL)
1609       return NULL;
1610     udp_a4 = (struct IPv4UdpAddress *) address->address;
1611     if (udp_a4->u4_port == 0)
1612       return NULL;
1613   }
1614
1615   if (address->address_length == sizeof (struct IPv6UdpAddress))
1616   {
1617     if (plugin->sockv6 == NULL)
1618       return NULL;
1619     udp_a6 = (struct IPv6UdpAddress *) address->address;
1620     if (udp_a6->u6_port == 0)
1621       return NULL;
1622   }
1623
1624   /* check if session already exists */
1625   struct SessionCompareContext cctx;
1626   cctx.addr = address;
1627   cctx.res = NULL;
1628   cctx.inbound = inbound;
1629   LOG (GNUNET_ERROR_TYPE_DEBUG,
1630        "Looking for existing session for peer `%s' `%s' \n",
1631        GNUNET_i2s (&address->peer),
1632        udp_address_to_string(NULL, address->address, address->address_length));
1633   GNUNET_CONTAINER_multipeermap_get_multiple(plugin->sessions, &address->peer, session_cmp_it, &cctx);
1634   if (cctx.res != NULL)
1635   {
1636     LOG (GNUNET_ERROR_TYPE_DEBUG, "Found existing session %p\n", cctx.res);
1637     return cctx.res;
1638   }
1639   return NULL;
1640 }
1641
1642
1643 static struct Session *
1644 udp_plugin_create_session (void *cls,
1645                            const struct GNUNET_HELLO_Address *address,
1646                            int inbound)
1647 {
1648   struct Session *s;
1649
1650   s = create_session (plugin,
1651                       &address->peer,
1652                       address->address,
1653                       address->address_length,
1654                       NULL, NULL);
1655   if (NULL == s)
1656     return NULL; /* protocol not supported or address invalid */
1657   s->inbound = inbound;
1658   LOG (GNUNET_ERROR_TYPE_DEBUG,
1659        "Creating new %s session %p for peer `%s' address `%s'\n",
1660        (GNUNET_YES == s->inbound) ? "inbound" : "outbound",
1661        s,
1662        GNUNET_i2s(&address->peer),
1663        udp_address_to_string(NULL,address->address,address->address_length));
1664   GNUNET_assert (GNUNET_OK ==
1665                  GNUNET_CONTAINER_multipeermap_put (plugin->sessions,
1666                                                     &s->target,
1667                                                     s,
1668                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
1669   GNUNET_STATISTICS_set(plugin->env->stats,
1670                         "# UDP, sessions active",
1671                         GNUNET_CONTAINER_multipeermap_size(plugin->sessions),
1672                         GNUNET_NO);
1673   return s;
1674 }
1675
1676 static void
1677 udp_plugin_update_session_timeout (void *cls,
1678                                   const struct GNUNET_PeerIdentity *peer,
1679                                   struct Session *session)
1680 {
1681   if (GNUNET_YES
1682       != GNUNET_CONTAINER_multipeermap_contains_value (plugin->sessions,
1683           peer, session))
1684   {
1685     GNUNET_break(0);
1686     return;
1687   }
1688
1689   /* Reschedule session timeout */
1690   reschedule_session_timeout (session);
1691 }
1692
1693 /**
1694  * Creates a new outbound session the transport service will use to send data to the
1695  * peer
1696  *
1697  * @param cls the plugin
1698  * @param address the address
1699  * @return the session or NULL of max connections exceeded
1700  */
1701 static struct Session *
1702 udp_plugin_get_session (void *cls,
1703                         const struct GNUNET_HELLO_Address *address)
1704 {
1705   struct Session *s;
1706
1707   if (NULL == address)
1708   {
1709     GNUNET_break (0);
1710     return NULL;
1711   }
1712   if ((address->address_length != sizeof (struct IPv4UdpAddress)) &&
1713       (address->address_length != sizeof (struct IPv6UdpAddress)))
1714     return NULL;
1715
1716   /* otherwise create new */
1717   if (NULL != (s = udp_plugin_lookup_session (cls, address, GNUNET_NO)))
1718     return s;
1719   return udp_plugin_create_session (cls, address, GNUNET_NO);
1720 }
1721
1722
1723 static void
1724 enqueue (struct Plugin *plugin, struct UDP_MessageWrapper * udpw)
1725 {
1726   if (plugin->bytes_in_buffer + udpw->msg_size > INT64_MAX)
1727       GNUNET_break (0);
1728   else
1729   {
1730     GNUNET_STATISTICS_update (plugin->env->stats,
1731                               "# UDP, total, bytes in buffers",
1732                               udpw->msg_size, GNUNET_NO);
1733     plugin->bytes_in_buffer += udpw->msg_size;
1734   }
1735   GNUNET_STATISTICS_update (plugin->env->stats,
1736                             "# UDP, total, msgs in buffers",
1737                             1, GNUNET_NO);
1738   if (udpw->session->addrlen == sizeof (struct sockaddr_in))
1739     GNUNET_CONTAINER_DLL_insert (plugin->ipv4_queue_head,
1740                                  plugin->ipv4_queue_tail, udpw);
1741   if (udpw->session->addrlen == sizeof (struct sockaddr_in6))
1742     GNUNET_CONTAINER_DLL_insert (plugin->ipv6_queue_head,
1743                                  plugin->ipv6_queue_tail, udpw);
1744 }
1745
1746
1747
1748 /**
1749  * Fragment message was transmitted via UDP, let fragmentation know
1750  * to send the next fragment now.
1751  *
1752  * @param cls the 'struct UDPMessageWrapper' of the fragment
1753  * @param target destination peer (ignored)
1754  * @param result GNUNET_OK on success (ignored)
1755  * @param payload bytes payload sent
1756  * @param physical bytes physical sent
1757  */
1758 static void
1759 send_next_fragment (void *cls,
1760                     const struct GNUNET_PeerIdentity *target,
1761                     int result, size_t payload, size_t physical)
1762 {
1763   struct UDP_MessageWrapper *udpw = cls;
1764
1765   GNUNET_FRAGMENT_context_transmission_done (udpw->frag_ctx->frag);
1766 }
1767
1768
1769 /**
1770  * Function that is called with messages created by the fragmentation
1771  * module.  In the case of the 'proc' callback of the
1772  * GNUNET_FRAGMENT_context_create function, this function must
1773  * eventually call 'GNUNET_FRAGMENT_context_transmission_done'.
1774  *
1775  * @param cls closure, the 'struct FragmentationContext'
1776  * @param msg the message that was created
1777  */
1778 static void
1779 enqueue_fragment (void *cls, const struct GNUNET_MessageHeader *msg)
1780 {
1781   struct UDP_FragmentationContext *frag_ctx = cls;
1782   struct Plugin *plugin = frag_ctx->plugin;
1783   struct UDP_MessageWrapper * udpw;
1784   size_t msg_len = ntohs (msg->size);
1785
1786   LOG (GNUNET_ERROR_TYPE_DEBUG,
1787        "Enqueuing fragment with %u bytes\n", msg_len);
1788   frag_ctx->fragments_used ++;
1789   udpw = GNUNET_malloc (sizeof (struct UDP_MessageWrapper) + msg_len);
1790   udpw->session = frag_ctx->session;
1791   udpw->msg_buf = (char *) &udpw[1];
1792   udpw->msg_size = msg_len;
1793   udpw->payload_size = msg_len; /*FIXME: minus fragment overhead */
1794   udpw->cont = &send_next_fragment;
1795   udpw->cont_cls = udpw;
1796   udpw->timeout = frag_ctx->timeout;
1797   udpw->frag_ctx = frag_ctx;
1798   udpw->msg_type = MSG_FRAGMENTED;
1799   memcpy (udpw->msg_buf, msg, msg_len);
1800   enqueue (plugin, udpw);
1801   schedule_select (plugin);
1802 }
1803
1804
1805 /**
1806  * Function that can be used by the transport service to transmit
1807  * a message using the plugin.   Note that in the case of a
1808  * peer disconnecting, the continuation MUST be called
1809  * prior to the disconnect notification itself.  This function
1810  * will be called with this peer's HELLO message to initiate
1811  * a fresh connection to another peer.
1812  *
1813  * @param cls closure
1814  * @param s which session must be used
1815  * @param msgbuf the message to transmit
1816  * @param msgbuf_size number of bytes in 'msgbuf'
1817  * @param priority how important is the message (most plugins will
1818  *                 ignore message priority and just FIFO)
1819  * @param to how long to wait at most for the transmission (does not
1820  *                require plugins to discard the message after the timeout,
1821  *                just advisory for the desired delay; most plugins will ignore
1822  *                this as well)
1823  * @param cont continuation to call once the message has
1824  *        been transmitted (or if the transport is ready
1825  *        for the next transmission call; or if the
1826  *        peer disconnected...); can be NULL
1827  * @param cont_cls closure for cont
1828  * @return number of bytes used (on the physical network, with overheads);
1829  *         -1 on hard errors (i.e. address invalid); 0 is a legal value
1830  *         and does NOT mean that the message was not transmitted (DV)
1831  */
1832 static ssize_t
1833 udp_plugin_send (void *cls,
1834                   struct Session *s,
1835                   const char *msgbuf, size_t msgbuf_size,
1836                   unsigned int priority,
1837                   struct GNUNET_TIME_Relative to,
1838                   GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
1839 {
1840   struct Plugin *plugin = cls;
1841   size_t udpmlen = msgbuf_size + sizeof (struct UDPMessage);
1842   struct UDP_FragmentationContext * frag_ctx;
1843   struct UDP_MessageWrapper * udpw;
1844   struct UDPMessage *udp;
1845   char mbuf[udpmlen];
1846   GNUNET_assert (plugin != NULL);
1847   GNUNET_assert (s != NULL);
1848
1849   if ((s->addrlen == sizeof (struct sockaddr_in6)) && (plugin->sockv6 == NULL))
1850     return GNUNET_SYSERR;
1851   if ((s->addrlen == sizeof (struct sockaddr_in)) && (plugin->sockv4 == NULL))
1852     return GNUNET_SYSERR;
1853   if (udpmlen >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
1854   {
1855     GNUNET_break (0);
1856     return GNUNET_SYSERR;
1857   }
1858   if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_contains_value(plugin->sessions, &s->target, s))
1859   {
1860     GNUNET_break (0);
1861     return GNUNET_SYSERR;
1862   }
1863   LOG (GNUNET_ERROR_TYPE_DEBUG,
1864        "UDP transmits %u-byte message to `%s' using address `%s'\n",
1865        udpmlen,
1866        GNUNET_i2s (&s->target),
1867        GNUNET_a2s(s->sock_addr, s->addrlen));
1868
1869
1870   /* Message */
1871   udp = (struct UDPMessage *) mbuf;
1872   udp->header.size = htons (udpmlen);
1873   udp->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE);
1874   udp->reserved = htonl (0);
1875   udp->sender = *plugin->env->my_identity;
1876
1877   /* We do not update the session time out here!
1878    * Otherwise this session will not timeout since we send keep alive before
1879    * session can timeout
1880    *
1881    * For UDP we update session timeout only on receive, this will cover keep
1882    * alives, since remote peer will reply with keep alive response!
1883    */
1884   if (udpmlen <= UDP_MTU)
1885   {
1886     /* unfragmented message */
1887     udpw = GNUNET_malloc (sizeof (struct UDP_MessageWrapper) + udpmlen);
1888     udpw->session = s;
1889     udpw->msg_buf = (char *) &udpw[1];
1890     udpw->msg_size = udpmlen; /* message size with UDP overhead */
1891     udpw->payload_size = msgbuf_size; /* message size without UDP overhead */
1892     udpw->timeout = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), to);
1893     udpw->cont = cont;
1894     udpw->cont_cls = cont_cls;
1895     udpw->frag_ctx = NULL;
1896     udpw->msg_type = MSG_UNFRAGMENTED;
1897     memcpy (udpw->msg_buf, udp, sizeof (struct UDPMessage));
1898     memcpy (&udpw->msg_buf[sizeof (struct UDPMessage)], msgbuf, msgbuf_size);
1899     enqueue (plugin, udpw);
1900
1901     GNUNET_STATISTICS_update (plugin->env->stats,
1902                               "# UDP, unfragmented msgs, messages, attempt",
1903                               1, GNUNET_NO);
1904     GNUNET_STATISTICS_update (plugin->env->stats,
1905                               "# UDP, unfragmented msgs, bytes payload, attempt",
1906                               udpw->payload_size, GNUNET_NO);
1907   }
1908   else
1909   {
1910     /* fragmented message */
1911     if  (s->frag_ctx != NULL)
1912       return GNUNET_SYSERR;
1913     memcpy (&udp[1], msgbuf, msgbuf_size);
1914     frag_ctx = GNUNET_new (struct UDP_FragmentationContext);
1915     frag_ctx->plugin = plugin;
1916     frag_ctx->session = s;
1917     frag_ctx->cont = cont;
1918     frag_ctx->cont_cls = cont_cls;
1919     frag_ctx->timeout = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), to);
1920     frag_ctx->payload_size = msgbuf_size; /* unfragmented message size without UDP overhead */
1921     frag_ctx->on_wire_size = 0; /* bytes with UDP and fragmentation overhead */
1922     frag_ctx->frag = GNUNET_FRAGMENT_context_create (plugin->env->stats,
1923                                                      UDP_MTU,
1924                                                      &plugin->tracker,
1925                                                      s->last_expected_msg_delay,
1926                                                      s->last_expected_ack_delay,
1927                                                      &udp->header,
1928                                                      &enqueue_fragment,
1929                                                      frag_ctx);
1930     s->frag_ctx = frag_ctx;
1931     GNUNET_STATISTICS_update (plugin->env->stats,
1932                               "# UDP, fragmented msgs, messages, pending",
1933                               1, GNUNET_NO);
1934     GNUNET_STATISTICS_update (plugin->env->stats,
1935                               "# UDP, fragmented msgs, messages, attempt",
1936                               1, GNUNET_NO);
1937     GNUNET_STATISTICS_update (plugin->env->stats,
1938                               "# UDP, fragmented msgs, bytes payload, attempt",
1939                               frag_ctx->payload_size, GNUNET_NO);
1940   }
1941   schedule_select (plugin);
1942   return udpmlen;
1943 }
1944
1945
1946 /**
1947  * Our external IP address/port mapping has changed.
1948  *
1949  * @param cls closure, the 'struct LocalAddrList'
1950  * @param add_remove GNUNET_YES to mean the new public IP address, GNUNET_NO to mean
1951  *     the previous (now invalid) one
1952  * @param addr either the previous or the new public IP address
1953  * @param addrlen actual lenght of the address
1954  */
1955 static void
1956 udp_nat_port_map_callback (void *cls, int add_remove,
1957                            const struct sockaddr *addr, socklen_t addrlen)
1958 {
1959   struct Plugin *plugin = cls;
1960   struct IPv4UdpAddress u4;
1961   struct IPv6UdpAddress u6;
1962   void *arg;
1963   size_t args;
1964
1965   LOG (GNUNET_ERROR_TYPE_INFO,
1966        "NAT notification to %s address `%s'\n",
1967        (GNUNET_YES == add_remove) ? "add" : "remove",
1968        GNUNET_a2s (addr, addrlen));
1969
1970   /* convert 'addr' to our internal format */
1971   switch (addr->sa_family)
1972   {
1973   case AF_INET:
1974     GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
1975     memset (&u4, 0, sizeof (u4));
1976     u4.options = htonl(myoptions);
1977     u4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
1978     u4.u4_port = ((struct sockaddr_in *) addr)->sin_port;
1979     if (0 == ((struct sockaddr_in *) addr)->sin_port)
1980         return;
1981     arg = &u4;
1982     args = sizeof (struct IPv4UdpAddress);
1983     break;
1984   case AF_INET6:
1985     GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
1986     memset (&u4, 0, sizeof (u4));
1987     u6.options = htonl(myoptions);
1988     if (0 == ((struct sockaddr_in6 *) addr)->sin6_port)
1989         return;
1990     memcpy (&u6.ipv6_addr, &((struct sockaddr_in6 *) addr)->sin6_addr,
1991             sizeof (struct in6_addr));
1992     u6.u6_port = ((struct sockaddr_in6 *) addr)->sin6_port;
1993     arg = &u6;
1994     args = sizeof (struct IPv6UdpAddress);
1995     break;
1996   default:
1997     GNUNET_break (0);
1998     return;
1999   }
2000   /* modify our published address list */
2001   plugin->env->notify_address (plugin->env->cls, add_remove, arg, args, "udp");
2002 }
2003
2004
2005
2006 /**
2007  * Message tokenizer has broken up an incomming message. Pass it on
2008  * to the service.
2009  *
2010  * @param cls the 'struct Plugin'
2011  * @param client the `struct SourceInformation`
2012  * @param hdr the actual message
2013  * @return #GNUNET_OK (always)
2014  */
2015 static int
2016 process_inbound_tokenized_messages (void *cls, void *client,
2017                                     const struct GNUNET_MessageHeader *hdr)
2018 {
2019   struct Plugin *plugin = cls;
2020   struct SourceInformation *si = client;
2021   struct GNUNET_TIME_Relative delay;
2022
2023   GNUNET_assert (si->session != NULL);
2024   if (GNUNET_YES == si->session->in_destroy)
2025     return GNUNET_OK;
2026   /* setup ATS */
2027   GNUNET_break (ntohl(si->session->ats.value) != GNUNET_ATS_NET_UNSPECIFIED);
2028   reschedule_session_timeout (si->session);
2029   delay = plugin->env->receive (plugin->env->cls,
2030                                 &si->sender,
2031                                 hdr,
2032                                 si->session,
2033                                 (GNUNET_YES == si->session->inbound)
2034                                 ? NULL : si->arg,
2035                                 (GNUNET_YES == si->session->inbound)
2036                                 ? 0 : si->args);
2037   plugin->env->update_address_metrics (plugin->env->cls,
2038                                        &si->sender,
2039                                        (GNUNET_YES == si->session->inbound) ? NULL : si->arg,
2040                                        (GNUNET_YES == si->session->inbound) ? 0 : si->args,
2041                                        si->session,
2042                                        &si->session->ats, 1);
2043   si->session->flow_delay_for_other_peer = delay;
2044   return GNUNET_OK;
2045 }
2046
2047
2048 /**
2049  * We've received a UDP Message.  Process it (pass contents to main service).
2050  *
2051  * @param plugin plugin context
2052  * @param msg the message
2053  * @param sender_addr sender address
2054  * @param sender_addr_len number of bytes in sender_addr
2055  */
2056 static void
2057 process_udp_message (struct Plugin *plugin, const struct UDPMessage *msg,
2058                      const struct sockaddr *sender_addr,
2059                      socklen_t sender_addr_len)
2060 {
2061   struct SourceInformation si;
2062   struct Session * s;
2063   struct IPv4UdpAddress u4;
2064   struct IPv6UdpAddress u6;
2065   const void *arg;
2066   size_t args;
2067
2068   if (0 != ntohl (msg->reserved))
2069   {
2070     GNUNET_break_op (0);
2071     return;
2072   }
2073   if (ntohs (msg->header.size) <
2074       sizeof (struct GNUNET_MessageHeader) + sizeof (struct UDPMessage))
2075   {
2076     GNUNET_break_op (0);
2077     return;
2078   }
2079
2080   /* convert address */
2081   switch (sender_addr->sa_family)
2082   {
2083   case AF_INET:
2084     GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in));
2085     memset (&u4, 0, sizeof (u4));
2086     u6.options = htonl (0);
2087     u4.ipv4_addr = ((struct sockaddr_in *) sender_addr)->sin_addr.s_addr;
2088     u4.u4_port = ((struct sockaddr_in *) sender_addr)->sin_port;
2089     arg = &u4;
2090     args = sizeof (u4);
2091     break;
2092   case AF_INET6:
2093     GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in6));
2094     memset (&u6, 0, sizeof (u6));
2095     u6.options = htonl (0);
2096     u6.ipv6_addr = ((struct sockaddr_in6 *) sender_addr)->sin6_addr;
2097     u6.u6_port = ((struct sockaddr_in6 *) sender_addr)->sin6_port;
2098     arg = &u6;
2099     args = sizeof (u6);
2100     break;
2101   default:
2102     GNUNET_break (0);
2103     return;
2104   }
2105   LOG (GNUNET_ERROR_TYPE_DEBUG,
2106        "Received message with %u bytes from peer `%s' at `%s'\n",
2107        (unsigned int) ntohs (msg->header.size), GNUNET_i2s (&msg->sender),
2108        GNUNET_a2s (sender_addr, sender_addr_len));
2109
2110   struct GNUNET_HELLO_Address * address = GNUNET_HELLO_address_allocate(&msg->sender, "udp", arg, args);
2111   if (NULL == (s = udp_plugin_lookup_session (plugin, address, GNUNET_YES)))
2112   {
2113     s = udp_plugin_create_session (plugin, address, GNUNET_YES);
2114     plugin->env->session_start (NULL, &address->peer, PLUGIN_NAME,
2115                   address->address, address->address_length, s, NULL, 0);
2116   }
2117   GNUNET_free (address);
2118
2119   /* iterate over all embedded messages */
2120   si.session = s;
2121   si.sender = msg->sender;
2122   si.arg = arg;
2123   si.args = args;
2124   s->rc++;
2125   GNUNET_SERVER_mst_receive (plugin->mst,
2126                              &si,
2127                              (const char *) &msg[1],
2128                              ntohs (msg->header.size) - sizeof (struct UDPMessage),
2129                              GNUNET_YES,
2130                              GNUNET_NO);
2131   s->rc--;
2132   if ( (0 == s->rc) && (GNUNET_YES == s->in_destroy))
2133     free_session (s);
2134 }
2135
2136
2137 /**
2138  * Scan the heap for a receive context with the given address.
2139  *
2140  * @param cls the `struct FindReceiveContext`
2141  * @param node internal node of the heap
2142  * @param element value stored at the node (a 'struct ReceiveContext')
2143  * @param cost cost associated with the node
2144  * @return #GNUNET_YES if we should continue to iterate,
2145  *         #GNUNET_NO if not.
2146  */
2147 static int
2148 find_receive_context (void *cls, struct GNUNET_CONTAINER_HeapNode *node,
2149                       void *element, GNUNET_CONTAINER_HeapCostType cost)
2150 {
2151   struct FindReceiveContext *frc = cls;
2152   struct DefragContext *e = element;
2153
2154   if ((frc->addr_len == e->addr_len) &&
2155       (0 == memcmp (frc->addr, e->src_addr, frc->addr_len)))
2156   {
2157     frc->rc = e;
2158     return GNUNET_NO;
2159   }
2160   return GNUNET_YES;
2161 }
2162
2163
2164 /**
2165  * Process a defragmented message.
2166  *
2167  * @param cls the 'struct ReceiveContext'
2168  * @param msg the message
2169  */
2170 static void
2171 fragment_msg_proc (void *cls, const struct GNUNET_MessageHeader *msg)
2172 {
2173   struct DefragContext *rc = cls;
2174
2175   if (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE)
2176   {
2177     GNUNET_break (0);
2178     return;
2179   }
2180   if (ntohs (msg->size) < sizeof (struct UDPMessage))
2181   {
2182     GNUNET_break (0);
2183     return;
2184   }
2185   process_udp_message (rc->plugin, (const struct UDPMessage *) msg,
2186                        rc->src_addr, rc->addr_len);
2187 }
2188
2189
2190 struct LookupContext
2191 {
2192   struct Session *res;
2193
2194   const struct sockaddr * addr;
2195
2196   size_t addrlen;
2197
2198   int must_have_frag_ctx;
2199 };
2200
2201
2202 static int
2203 lookup_session_by_addr_it (void *cls,
2204                            const struct GNUNET_PeerIdentity *key,
2205                            void *value)
2206 {
2207   struct LookupContext *l_ctx = cls;
2208   struct Session * s = value;
2209
2210   if ((GNUNET_YES == l_ctx->must_have_frag_ctx) && (NULL == s->frag_ctx))
2211     return GNUNET_YES;
2212
2213   /*
2214   GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Comparing session: have %s %s %p<-> want %s\n",
2215       GNUNET_a2s(s->sock_addr, s->addrlen),
2216       (GNUNET_YES == s->inbound) ? "inbound" : "outbound",
2217       s->frag_ctx,
2218       GNUNET_a2s(l_ctx->addr, l_ctx->addrlen));
2219    */
2220   if ((s->addrlen == l_ctx->addrlen) &&
2221       (0 == memcmp (s->sock_addr, l_ctx->addr, s->addrlen)))
2222   {
2223     l_ctx->res = s;
2224     return GNUNET_YES;
2225   }
2226   return GNUNET_YES;
2227 }
2228
2229
2230 /**
2231  * Transmit an acknowledgement.
2232  *
2233  * @param cls the 'struct ReceiveContext'
2234  * @param id message ID (unused)
2235  * @param msg ack to transmit
2236  */
2237 static void
2238 ack_proc (void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg)
2239 {
2240   struct DefragContext *rc = cls;
2241   size_t msize = sizeof (struct UDP_ACK_Message) + ntohs (msg->size);
2242   struct UDP_ACK_Message *udp_ack;
2243   uint32_t delay = 0;
2244   struct UDP_MessageWrapper *udpw;
2245   struct Session *s;
2246   struct LookupContext l_ctx;
2247
2248   l_ctx.addr = rc->src_addr;
2249   l_ctx.addrlen = rc->addr_len;
2250   l_ctx.res = NULL;
2251   l_ctx.must_have_frag_ctx = GNUNET_NO;
2252   GNUNET_CONTAINER_multipeermap_iterate (rc->plugin->sessions,
2253       &lookup_session_by_addr_it,
2254       &l_ctx);
2255   s = l_ctx.res;
2256
2257   if (NULL == s)
2258     return;
2259
2260   if (s->flow_delay_for_other_peer.rel_value_us <= UINT32_MAX)
2261     delay = s->flow_delay_for_other_peer.rel_value_us;
2262
2263   LOG (GNUNET_ERROR_TYPE_DEBUG,
2264        "Sending ACK to `%s' including delay of %s\n",
2265        GNUNET_a2s (rc->src_addr,
2266                    (rc->src_addr->sa_family ==
2267                     AF_INET) ? sizeof (struct sockaddr_in) : sizeof (struct
2268                                                                      sockaddr_in6)),
2269        GNUNET_STRINGS_relative_time_to_string (s->flow_delay_for_other_peer,
2270                                                GNUNET_YES));
2271   udpw = GNUNET_malloc (sizeof (struct UDP_MessageWrapper) + msize);
2272   udpw->msg_size = msize;
2273   udpw->payload_size = 0;
2274   udpw->session = s;
2275   udpw->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
2276   udpw->msg_buf = (char *)&udpw[1];
2277   udpw->msg_type = MSG_ACK;
2278   udp_ack = (struct UDP_ACK_Message *) udpw->msg_buf;
2279   udp_ack->header.size = htons ((uint16_t) msize);
2280   udp_ack->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK);
2281   udp_ack->delay = htonl (delay);
2282   udp_ack->sender = *rc->plugin->env->my_identity;
2283   memcpy (&udp_ack[1], msg, ntohs (msg->size));
2284   enqueue (rc->plugin, udpw);
2285 }
2286
2287
2288 static void
2289 read_process_msg (struct Plugin *plugin,
2290                   const struct GNUNET_MessageHeader *msg,
2291                   const struct sockaddr *addr,
2292                   socklen_t fromlen)
2293 {
2294   if (ntohs (msg->size) < sizeof (struct UDPMessage))
2295   {
2296     GNUNET_break_op (0);
2297     return;
2298   }
2299   process_udp_message (plugin, (const struct UDPMessage *) msg,
2300                        addr, fromlen);
2301 }
2302
2303
2304 static void
2305 read_process_ack (struct Plugin *plugin,
2306                   const struct GNUNET_MessageHeader *msg,
2307                   const struct sockaddr *addr,
2308                   socklen_t fromlen)
2309 {
2310   const struct GNUNET_MessageHeader *ack;
2311   const struct UDP_ACK_Message *udp_ack;
2312   struct LookupContext l_ctx;
2313   struct Session *s;
2314   struct GNUNET_TIME_Relative flow_delay;
2315
2316   if (ntohs (msg->size) <
2317       sizeof (struct UDP_ACK_Message) + sizeof (struct GNUNET_MessageHeader))
2318   {
2319     GNUNET_break_op (0);
2320     return;
2321   }
2322   udp_ack = (const struct UDP_ACK_Message *) msg;
2323   l_ctx.addr = (const struct sockaddr *) addr;
2324   l_ctx.addrlen = fromlen;
2325   l_ctx.res = NULL;
2326   l_ctx.must_have_frag_ctx = GNUNET_YES;
2327   GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
2328                                          &lookup_session_by_addr_it,
2329                                          &l_ctx);
2330   s = l_ctx.res;
2331   if ((NULL == s) || (NULL == s->frag_ctx))
2332   {
2333     return;
2334   }
2335
2336
2337   flow_delay.rel_value_us = (uint64_t) ntohl (udp_ack->delay);
2338   LOG (GNUNET_ERROR_TYPE_DEBUG,
2339        "We received a sending delay of %s\n",
2340        GNUNET_STRINGS_relative_time_to_string (flow_delay,
2341                                                GNUNET_YES));
2342   s->flow_delay_from_other_peer =
2343       GNUNET_TIME_relative_to_absolute (flow_delay);
2344
2345   ack = (const struct GNUNET_MessageHeader *) &udp_ack[1];
2346   if (ntohs (ack->size) !=
2347       ntohs (msg->size) - sizeof (struct UDP_ACK_Message))
2348   {
2349     GNUNET_break_op (0);
2350     return;
2351   }
2352
2353   if (0 != memcmp (&l_ctx.res->target, &udp_ack->sender, sizeof (struct GNUNET_PeerIdentity)))
2354     GNUNET_break (0);
2355   if (GNUNET_OK != GNUNET_FRAGMENT_process_ack (s->frag_ctx->frag, ack))
2356   {
2357     LOG (GNUNET_ERROR_TYPE_DEBUG,
2358          "UDP processes %u-byte acknowledgement from `%s' at `%s'\n",
2359          (unsigned int) ntohs (msg->size), GNUNET_i2s (&udp_ack->sender),
2360          GNUNET_a2s (addr, fromlen));
2361     /* Expect more ACKs to arrive */
2362     return;
2363   }
2364
2365   LOG (GNUNET_ERROR_TYPE_DEBUG,
2366        "Message full ACK'ed\n",
2367        (unsigned int) ntohs (msg->size), GNUNET_i2s (&udp_ack->sender),
2368        GNUNET_a2s (addr, fromlen));
2369
2370   /* Remove fragmented message after successful sending */
2371   fragmented_message_done (s->frag_ctx, GNUNET_OK);
2372 }
2373
2374
2375 static void
2376 read_process_fragment (struct Plugin *plugin,
2377                        const struct GNUNET_MessageHeader *msg,
2378                        const struct sockaddr *addr,
2379                        socklen_t fromlen)
2380 {
2381   struct DefragContext *d_ctx;
2382   struct GNUNET_TIME_Absolute now;
2383   struct FindReceiveContext frc;
2384
2385   frc.rc = NULL;
2386   frc.addr = addr;
2387   frc.addr_len = fromlen;
2388
2389   LOG (GNUNET_ERROR_TYPE_DEBUG, "UDP processes %u-byte fragment from `%s'\n",
2390        (unsigned int) ntohs (msg->size),
2391        GNUNET_a2s (addr, fromlen));
2392   /* Lookup existing receive context for this address */
2393   GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs,
2394                                  &find_receive_context,
2395                                  &frc);
2396   now = GNUNET_TIME_absolute_get ();
2397   d_ctx = frc.rc;
2398
2399   if (d_ctx == NULL)
2400   {
2401     /* Create a new defragmentation context */
2402     d_ctx = GNUNET_malloc (sizeof (struct DefragContext) + fromlen);
2403     memcpy (&d_ctx[1], addr, fromlen);
2404     d_ctx->src_addr = (const struct sockaddr *) &d_ctx[1];
2405     d_ctx->addr_len = fromlen;
2406     d_ctx->plugin = plugin;
2407     d_ctx->defrag =
2408         GNUNET_DEFRAGMENT_context_create (plugin->env->stats, UDP_MTU,
2409                                           UDP_MAX_MESSAGES_IN_DEFRAG, d_ctx,
2410                                           &fragment_msg_proc, &ack_proc);
2411     d_ctx->hnode =
2412         GNUNET_CONTAINER_heap_insert (plugin->defrag_ctxs, d_ctx,
2413                                       (GNUNET_CONTAINER_HeapCostType)
2414                                       now.abs_value_us);
2415     LOG (GNUNET_ERROR_TYPE_DEBUG,
2416          "Created new defragmentation context for %u-byte fragment from `%s'\n",
2417          (unsigned int) ntohs (msg->size),
2418          GNUNET_a2s (addr, fromlen));
2419   }
2420   else
2421   {
2422     LOG (GNUNET_ERROR_TYPE_DEBUG,
2423          "Found existing defragmentation context for %u-byte fragment from `%s'\n",
2424          (unsigned int) ntohs (msg->size),
2425          GNUNET_a2s (addr, fromlen));
2426   }
2427
2428   if (GNUNET_OK == GNUNET_DEFRAGMENT_process_fragment (d_ctx->defrag, msg))
2429   {
2430     /* keep this 'rc' from expiring */
2431     GNUNET_CONTAINER_heap_update_cost (plugin->defrag_ctxs, d_ctx->hnode,
2432                                        (GNUNET_CONTAINER_HeapCostType)
2433                                        now.abs_value_us);
2434   }
2435   if (GNUNET_CONTAINER_heap_get_size (plugin->defrag_ctxs) >
2436       UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG)
2437   {
2438     /* remove 'rc' that was inactive the longest */
2439     d_ctx = GNUNET_CONTAINER_heap_remove_root (plugin->defrag_ctxs);
2440     GNUNET_assert (NULL != d_ctx);
2441     GNUNET_DEFRAGMENT_context_destroy (d_ctx->defrag);
2442     GNUNET_free (d_ctx);
2443   }
2444 }
2445
2446
2447 /**
2448  * Read and process a message from the given socket.
2449  *
2450  * @param plugin the overall plugin
2451  * @param rsock socket to read from
2452  */
2453 static void
2454 udp_select_read (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock)
2455 {
2456   socklen_t fromlen;
2457   struct sockaddr_storage addr;
2458   char buf[65536] GNUNET_ALIGN;
2459   ssize_t size;
2460   const struct GNUNET_MessageHeader *msg;
2461
2462   fromlen = sizeof (addr);
2463   memset (&addr, 0, sizeof (addr));
2464   size = GNUNET_NETWORK_socket_recvfrom (rsock, buf, sizeof (buf),
2465                                          (struct sockaddr *) &addr, &fromlen);
2466 #if MINGW
2467   /* On SOCK_DGRAM UDP sockets recvfrom might fail with a
2468    * WSAECONNRESET error to indicate that previous sendto() (yes, sendto!)
2469    * on this socket has failed.
2470    * Quote from MSDN:
2471    *   WSAECONNRESET - The virtual circuit was reset by the remote side
2472    *   executing a hard or abortive close. The application should close
2473    *   the socket; it is no longer usable. On a UDP-datagram socket this
2474    *   error indicates a previous send operation resulted in an ICMP Port
2475    *   Unreachable message.
2476    */
2477   if ( (-1 == size) && (ECONNRESET == errno) )
2478     return;
2479 #endif
2480   if (-1 == size)
2481   {
2482     LOG (GNUNET_ERROR_TYPE_DEBUG,
2483         "UDP failed to receive data: %s\n", STRERROR (errno));
2484     /* Connection failure or something. Not a protocol violation. */
2485     return;
2486   }
2487   if (size < sizeof (struct GNUNET_MessageHeader))
2488   {
2489     LOG (GNUNET_ERROR_TYPE_WARNING,
2490         "UDP got %u bytes, which is not enough for a GNUnet message header\n",
2491         (unsigned int) size);
2492     /* _MAY_ be a connection failure (got partial message) */
2493     /* But it _MAY_ also be that the other side uses non-GNUnet protocol. */
2494     GNUNET_break_op (0);
2495     return;
2496   }
2497   msg = (const struct GNUNET_MessageHeader *) buf;
2498
2499   LOG (GNUNET_ERROR_TYPE_DEBUG,
2500        "UDP received %u-byte message from `%s' type %u\n",
2501        (unsigned int) size,
2502        GNUNET_a2s ((const struct sockaddr *) &addr, fromlen),
2503        ntohs (msg->type));
2504
2505   if (size != ntohs (msg->size))
2506   {
2507     GNUNET_break_op (0);
2508     return;
2509   }
2510
2511   GNUNET_STATISTICS_update (plugin->env->stats,
2512                             "# UDP, total, bytes, received",
2513                             size, GNUNET_NO);
2514
2515   switch (ntohs (msg->type))
2516   {
2517   case GNUNET_MESSAGE_TYPE_TRANSPORT_BROADCAST_BEACON:
2518     if (GNUNET_YES == plugin->enable_broadcasting_receiving)
2519       udp_broadcast_receive (plugin, buf, size,
2520                            (const struct sockaddr *) &addr, fromlen);
2521     return;
2522   case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE:
2523     read_process_msg (plugin, msg,
2524                       (const struct sockaddr *) &addr, fromlen);
2525     return;
2526   case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK:
2527     read_process_ack (plugin, msg,
2528                       (const struct sockaddr *) &addr, fromlen);
2529     return;
2530   case GNUNET_MESSAGE_TYPE_FRAGMENT:
2531     read_process_fragment (plugin, msg,
2532                            (const struct sockaddr *) &addr, fromlen);
2533     return;
2534   default:
2535     GNUNET_break_op (0);
2536     return;
2537   }
2538 }
2539
2540
2541 static struct UDP_MessageWrapper *
2542 remove_timeout_messages_and_select (struct UDP_MessageWrapper *head,
2543                                     struct GNUNET_NETWORK_Handle *sock)
2544 {
2545   struct UDP_MessageWrapper *udpw = NULL;
2546   struct GNUNET_TIME_Relative remaining;
2547
2548   udpw = head;
2549   while (udpw != NULL)
2550   {
2551     /* Find messages with timeout */
2552     remaining = GNUNET_TIME_absolute_get_remaining (udpw->timeout);
2553     if (GNUNET_TIME_UNIT_ZERO.rel_value_us == remaining.rel_value_us)
2554     {
2555       /* Message timed out */
2556       switch (udpw->msg_type) {
2557         case MSG_UNFRAGMENTED:
2558           GNUNET_STATISTICS_update (plugin->env->stats,
2559                                     "# UDP, total, bytes, sent, timeout",
2560                                     udpw->msg_size, GNUNET_NO);
2561           GNUNET_STATISTICS_update (plugin->env->stats,
2562                                     "# UDP, total, messages, sent, timeout",
2563                                     1, GNUNET_NO);
2564           GNUNET_STATISTICS_update (plugin->env->stats,
2565                                     "# UDP, unfragmented msgs, messages, sent, timeout",
2566                                     1, GNUNET_NO);
2567           GNUNET_STATISTICS_update (plugin->env->stats,
2568                                     "# UDP, unfragmented msgs, bytes, sent, timeout",
2569                                     udpw->payload_size, GNUNET_NO);
2570           /* Not fragmented message */
2571           LOG (GNUNET_ERROR_TYPE_DEBUG,
2572                "Message for peer `%s' with size %u timed out\n",
2573                GNUNET_i2s(&udpw->session->target), udpw->payload_size);
2574           call_continuation (udpw, GNUNET_SYSERR);
2575           /* Remove message */
2576           dequeue (plugin, udpw);
2577           GNUNET_free (udpw);
2578           break;
2579         case MSG_FRAGMENTED:
2580           /* Fragmented message */
2581           GNUNET_STATISTICS_update (plugin->env->stats,
2582                                     "# UDP, total, bytes, sent, timeout",
2583                                     udpw->frag_ctx->on_wire_size, GNUNET_NO);
2584           GNUNET_STATISTICS_update (plugin->env->stats,
2585                                     "# UDP, total, messages, sent, timeout",
2586                                     1, GNUNET_NO);
2587           call_continuation (udpw, GNUNET_SYSERR);
2588           LOG (GNUNET_ERROR_TYPE_DEBUG,
2589                "Fragment for message for peer `%s' with size %u timed out\n",
2590                GNUNET_i2s(&udpw->session->target), udpw->frag_ctx->payload_size);
2591
2592
2593           GNUNET_STATISTICS_update (plugin->env->stats,
2594                                     "# UDP, fragmented msgs, messages, sent, timeout",
2595                                     1, GNUNET_NO);
2596           GNUNET_STATISTICS_update (plugin->env->stats,
2597                                     "# UDP, fragmented msgs, bytes, sent, timeout",
2598                                     udpw->frag_ctx->payload_size, GNUNET_NO);
2599           /* Remove fragmented message due to timeout */
2600           fragmented_message_done (udpw->frag_ctx, GNUNET_SYSERR);
2601           break;
2602         case MSG_ACK:
2603           GNUNET_STATISTICS_update (plugin->env->stats,
2604                                     "# UDP, total, bytes, sent, timeout",
2605                                     udpw->msg_size, GNUNET_NO);
2606           GNUNET_STATISTICS_update (plugin->env->stats,
2607                                     "# UDP, total, messages, sent, timeout",
2608                                     1, GNUNET_NO);
2609           LOG (GNUNET_ERROR_TYPE_DEBUG,
2610                "ACK Message for peer `%s' with size %u timed out\n",
2611                GNUNET_i2s(&udpw->session->target), udpw->payload_size);
2612           call_continuation (udpw, GNUNET_SYSERR);
2613           dequeue (plugin, udpw);
2614           GNUNET_free (udpw);
2615           break;
2616         default:
2617           break;
2618       }
2619       if (sock == plugin->sockv4)
2620         udpw = plugin->ipv4_queue_head;
2621       else if (sock == plugin->sockv6)
2622         udpw = plugin->ipv6_queue_head;
2623       else
2624       {
2625         GNUNET_break (0); /* should never happen */
2626         udpw = NULL;
2627       }
2628       GNUNET_STATISTICS_update (plugin->env->stats,
2629                                 "# messages dismissed due to timeout",
2630                                 1, GNUNET_NO);
2631     }
2632     else
2633     {
2634       /* Message did not time out, check flow delay */
2635       remaining = GNUNET_TIME_absolute_get_remaining (udpw->session->flow_delay_from_other_peer);
2636       if (GNUNET_TIME_UNIT_ZERO.rel_value_us == remaining.rel_value_us)
2637       {
2638         /* this message is not delayed */
2639         LOG (GNUNET_ERROR_TYPE_DEBUG,
2640              "Message for peer `%s' (%u bytes) is not delayed \n",
2641              GNUNET_i2s(&udpw->session->target), udpw->payload_size);
2642         break; /* Found message to send, break */
2643       }
2644       else
2645       {
2646         /* Message is delayed, try next */
2647         LOG (GNUNET_ERROR_TYPE_DEBUG,
2648              "Message for peer `%s' (%u bytes) is delayed for %s\n",
2649              GNUNET_i2s(&udpw->session->target), udpw->payload_size,
2650              GNUNET_STRINGS_relative_time_to_string (remaining,
2651                                                      GNUNET_YES));
2652         udpw = udpw->next;
2653       }
2654     }
2655   }
2656   return udpw;
2657 }
2658
2659
2660 static void
2661 analyze_send_error (struct Plugin *plugin,
2662                     const struct sockaddr * sa,
2663                     socklen_t slen,
2664                     int error)
2665 {
2666   static int network_down_error;
2667   struct GNUNET_ATS_Information type;
2668
2669  type = plugin->env->get_address_type (plugin->env->cls,sa, slen);
2670  if (((GNUNET_ATS_NET_LAN == ntohl(type.value)) || (GNUNET_ATS_NET_WAN == ntohl(type.value))) &&
2671      ((ENETUNREACH == errno) || (ENETDOWN == errno)))
2672  {
2673    if ((network_down_error == GNUNET_NO) && (slen == sizeof (struct sockaddr_in)))
2674    {
2675      /* IPv4: "Network unreachable" or "Network down"
2676       *
2677       * This indicates we do not have connectivity
2678       */
2679      LOG (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
2680          _("UDP could not transmit message to `%s': "
2681            "Network seems down, please check your network configuration\n"),
2682          GNUNET_a2s (sa, slen));
2683    }
2684    if ((network_down_error == GNUNET_NO) && (slen == sizeof (struct sockaddr_in6)))
2685    {
2686      /* IPv6: "Network unreachable" or "Network down"
2687       *
2688       * This indicates that this system is IPv6 enabled, but does not
2689       * have a valid global IPv6 address assigned or we do not have
2690       * connectivity
2691       */
2692
2693     LOG (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
2694         _("UDP could not transmit IPv6 message! "
2695         "Please check your network configuration and disable IPv6 if your "
2696         "connection does not have a global IPv6 address\n"));
2697    }
2698  }
2699  else
2700  {
2701    LOG (GNUNET_ERROR_TYPE_WARNING,
2702       "UDP could not transmit message to `%s': `%s'\n",
2703       GNUNET_a2s (sa, slen), STRERROR (error));
2704  }
2705 }
2706
2707
2708 static size_t
2709 udp_select_send (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *sock)
2710 {
2711   const struct sockaddr * sa;
2712   ssize_t sent;
2713   socklen_t slen;
2714
2715   struct UDP_MessageWrapper *udpw = NULL;
2716
2717   /* Find message to send */
2718   udpw = remove_timeout_messages_and_select ((sock == plugin->sockv4) ? plugin->ipv4_queue_head : plugin->ipv6_queue_head,
2719                                              sock);
2720   if (NULL == udpw)
2721     return 0; /* No message to send */
2722
2723   sa = udpw->session->sock_addr;
2724   slen = udpw->session->addrlen;
2725
2726   sent = GNUNET_NETWORK_socket_sendto (sock, udpw->msg_buf, udpw->msg_size, sa, slen);
2727
2728   if (GNUNET_SYSERR == sent)
2729   {
2730     /* Failure */
2731     analyze_send_error (plugin, sa, slen, errno);
2732     call_continuation(udpw, GNUNET_SYSERR);
2733     GNUNET_STATISTICS_update (plugin->env->stats,
2734                             "# UDP, total, bytes, sent, failure",
2735                             sent, GNUNET_NO);
2736     GNUNET_STATISTICS_update (plugin->env->stats,
2737                               "# UDP, total, messages, sent, failure",
2738                               1, GNUNET_NO);
2739   }
2740   else
2741   {
2742     /* Success */
2743     LOG (GNUNET_ERROR_TYPE_DEBUG,
2744          "UDP transmitted %u-byte message to  `%s' `%s' (%d: %s)\n",
2745          (unsigned int) (udpw->msg_size), GNUNET_i2s(&udpw->session->target) ,GNUNET_a2s (sa, slen), (int) sent,
2746          (sent < 0) ? STRERROR (errno) : "ok");
2747     GNUNET_STATISTICS_update (plugin->env->stats,
2748                               "# UDP, total, bytes, sent, success",
2749                               sent, GNUNET_NO);
2750     GNUNET_STATISTICS_update (plugin->env->stats,
2751                               "# UDP, total, messages, sent, success",
2752                               1, GNUNET_NO);
2753     if (NULL != udpw->frag_ctx)
2754         udpw->frag_ctx->on_wire_size += udpw->msg_size;
2755     call_continuation (udpw, GNUNET_OK);
2756   }
2757   dequeue (plugin, udpw);
2758   GNUNET_free (udpw);
2759   udpw = NULL;
2760
2761   return sent;
2762 }
2763
2764
2765 /**
2766  * We have been notified that our readset has something to read.  We don't
2767  * know which socket needs to be read, so we have to check each one
2768  * Then reschedule this function to be called again once more is available.
2769  *
2770  * @param cls the plugin handle
2771  * @param tc the scheduling context (for rescheduling this function again)
2772  */
2773 static void
2774 udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2775 {
2776   struct Plugin *plugin = cls;
2777
2778   plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
2779   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
2780     return;
2781   if ( (0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
2782        (NULL != plugin->sockv4) &&
2783        (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv4)) )
2784     udp_select_read (plugin, plugin->sockv4);
2785   if ( (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
2786        (NULL != plugin->sockv4) &&
2787        (NULL != plugin->ipv4_queue_head) &&
2788        (GNUNET_NETWORK_fdset_isset (tc->write_ready, plugin->sockv4)) )
2789     udp_select_send (plugin, plugin->sockv4);
2790   schedule_select (plugin);
2791 }
2792
2793
2794 /**
2795  * We have been notified that our readset has something to read.  We don't
2796  * know which socket needs to be read, so we have to check each one
2797  * Then reschedule this function to be called again once more is available.
2798  *
2799  * @param cls the plugin handle
2800  * @param tc the scheduling context (for rescheduling this function again)
2801  */
2802 static void
2803 udp_plugin_select_v6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2804 {
2805   struct Plugin *plugin = cls;
2806
2807   plugin->select_task_v6 = GNUNET_SCHEDULER_NO_TASK;
2808   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
2809     return;
2810   if ( ((tc->reason & GNUNET_SCHEDULER_REASON_READ_READY) != 0) &&
2811        (NULL != plugin->sockv6) &&
2812        (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv6)) )
2813     udp_select_read (plugin, plugin->sockv6);
2814   if ( (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
2815        (NULL != plugin->sockv6) && (plugin->ipv6_queue_head != NULL) &&
2816        (GNUNET_NETWORK_fdset_isset (tc->write_ready, plugin->sockv6)) )
2817     udp_select_send (plugin, plugin->sockv6);
2818   schedule_select (plugin);
2819 }
2820
2821
2822 /**
2823  *
2824  * @return number of sockets that were successfully bound
2825  */
2826 static int
2827 setup_sockets (struct Plugin *plugin,
2828                const struct sockaddr_in6 *bind_v6,
2829                const struct sockaddr_in *bind_v4)
2830 {
2831   int tries;
2832   int sockets_created = 0;
2833   struct sockaddr_in6 server_addrv6;
2834   struct sockaddr_in server_addrv4;
2835   struct sockaddr *server_addr;
2836   struct sockaddr *addrs[2];
2837   socklen_t addrlens[2];
2838   socklen_t addrlen;
2839   int eno;
2840
2841   /* Create IPv6 socket */
2842   eno = EINVAL;
2843   if (plugin->enable_ipv6 == GNUNET_YES)
2844   {
2845     plugin->sockv6 = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 0);
2846     if (NULL == plugin->sockv6)
2847     {
2848       LOG (GNUNET_ERROR_TYPE_WARNING, "Disabling IPv6 since it is not supported on this system!\n");
2849       plugin->enable_ipv6 = GNUNET_NO;
2850     }
2851     else
2852     {
2853         memset (&server_addrv6, '\0', sizeof (struct sockaddr_in6));
2854 #if HAVE_SOCKADDR_IN_SIN_LEN
2855       server_addrv6.sin6_len = sizeof (struct sockaddr_in6);
2856 #endif
2857       server_addrv6.sin6_family = AF_INET6;
2858       if (NULL != bind_v6)
2859         server_addrv6.sin6_addr = bind_v6->sin6_addr;
2860       else
2861         server_addrv6.sin6_addr = in6addr_any;
2862
2863       if (0 == plugin->port) /* autodetect */
2864                 server_addrv6.sin6_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);
2865       else
2866                 server_addrv6.sin6_port = htons (plugin->port);
2867       addrlen = sizeof (struct sockaddr_in6);
2868       server_addr = (struct sockaddr *) &server_addrv6;
2869
2870       tries = 0;
2871       while (tries < 10)
2872       {
2873                 LOG (GNUNET_ERROR_TYPE_DEBUG, "Binding to IPv6 `%s'\n",
2874                                  GNUNET_a2s (server_addr, addrlen));
2875                 /* binding */
2876                 if (GNUNET_OK == GNUNET_NETWORK_socket_bind (plugin->sockv6,
2877                                                              server_addr, addrlen))
2878                         break;
2879                 eno = errno;
2880                 if (0 != plugin->port)
2881                 {
2882                                 tries = 10; /* fail */
2883                                 break; /* bind failed on specific port */
2884                 }
2885                 /* autodetect */
2886                 server_addrv6.sin6_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);
2887                 tries ++;
2888       }
2889       if (tries >= 10)
2890       {
2891         GNUNET_NETWORK_socket_close (plugin->sockv6);
2892         plugin->enable_ipv6 = GNUNET_NO;
2893         plugin->sockv6 = NULL;
2894       }
2895
2896       if (plugin->sockv6 != NULL)
2897       {
2898         LOG (GNUNET_ERROR_TYPE_DEBUG,
2899              "IPv6 socket created on port %s\n",
2900              GNUNET_a2s (server_addr, addrlen));
2901         addrs[sockets_created] = (struct sockaddr *) &server_addrv6;
2902         addrlens[sockets_created] = sizeof (struct sockaddr_in6);
2903         sockets_created++;
2904       }
2905       else
2906       {
2907           LOG (GNUNET_ERROR_TYPE_ERROR,
2908                "Failed to bind UDP socket to %s: %s\n",
2909                GNUNET_a2s (server_addr, addrlen),
2910                STRERROR (eno));
2911       }
2912     }
2913   }
2914
2915   /* Create IPv4 socket */
2916   eno = EINVAL;
2917   plugin->sockv4 = GNUNET_NETWORK_socket_create (PF_INET, SOCK_DGRAM, 0);
2918   if (NULL == plugin->sockv4)
2919   {
2920     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
2921     LOG (GNUNET_ERROR_TYPE_WARNING, "Disabling IPv4 since it is not supported on this system!\n");
2922     plugin->enable_ipv4 = GNUNET_NO;
2923   }
2924   else
2925   {
2926     memset (&server_addrv4, '\0', sizeof (struct sockaddr_in));
2927 #if HAVE_SOCKADDR_IN_SIN_LEN
2928     server_addrv4.sin_len = sizeof (struct sockaddr_in);
2929 #endif
2930     server_addrv4.sin_family = AF_INET;
2931     if (NULL != bind_v4)
2932       server_addrv4.sin_addr = bind_v4->sin_addr;
2933     else
2934       server_addrv4.sin_addr.s_addr = INADDR_ANY;
2935
2936     if (0 == plugin->port)
2937       /* autodetect */
2938       server_addrv4.sin_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);
2939     else
2940       server_addrv4.sin_port = htons (plugin->port);
2941
2942
2943     addrlen = sizeof (struct sockaddr_in);
2944     server_addr = (struct sockaddr *) &server_addrv4;
2945
2946     tries = 0;
2947     while (tries < 10)
2948     {
2949       LOG (GNUNET_ERROR_TYPE_DEBUG, "Binding to IPv4 `%s'\n",
2950                         GNUNET_a2s (server_addr, addrlen));
2951
2952       /* binding */
2953       if (GNUNET_OK == GNUNET_NETWORK_socket_bind (plugin->sockv4,
2954                                                    server_addr, addrlen))
2955                 break;
2956       eno = errno;
2957       if (0 != plugin->port)
2958       {
2959                 tries = 10; /* fail */
2960                 break; /* bind failed on specific port */
2961       }
2962
2963       /* autodetect */
2964       server_addrv4.sin_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);
2965       tries ++;
2966     }
2967
2968     if (tries >= 10)
2969     {
2970       GNUNET_NETWORK_socket_close (plugin->sockv4);
2971       plugin->enable_ipv4 = GNUNET_NO;
2972       plugin->sockv4 = NULL;
2973     }
2974
2975     if (plugin->sockv4 != NULL)
2976     {
2977       LOG (GNUNET_ERROR_TYPE_DEBUG,
2978                 "IPv4 socket created on port %s\n", GNUNET_a2s (server_addr, addrlen));
2979       addrs[sockets_created] = (struct sockaddr *) &server_addrv4;
2980       addrlens[sockets_created] = sizeof (struct sockaddr_in);
2981       sockets_created++;
2982     }
2983     else
2984     {
2985       LOG (GNUNET_ERROR_TYPE_ERROR,
2986                 "Failed to bind UDP socket to %s: %s\n",
2987                 GNUNET_a2s (server_addr, addrlen), STRERROR (eno));
2988     }
2989   }
2990
2991   if (0 == sockets_created)
2992   {
2993                 LOG (GNUNET_ERROR_TYPE_WARNING, _("Failed to open UDP sockets\n"));
2994                 return 0; /* No sockets created, return */
2995   }
2996
2997   /* Create file descriptors */
2998   if (plugin->enable_ipv4 == GNUNET_YES)
2999   {
3000                         plugin->rs_v4 = GNUNET_NETWORK_fdset_create ();
3001                         plugin->ws_v4 = GNUNET_NETWORK_fdset_create ();
3002                         GNUNET_NETWORK_fdset_zero (plugin->rs_v4);
3003                         GNUNET_NETWORK_fdset_zero (plugin->ws_v4);
3004                         if (NULL != plugin->sockv4)
3005                         {
3006                                 GNUNET_NETWORK_fdset_set (plugin->rs_v4, plugin->sockv4);
3007                                 GNUNET_NETWORK_fdset_set (plugin->ws_v4, plugin->sockv4);
3008                         }
3009   }
3010
3011   if (plugin->enable_ipv6 == GNUNET_YES)
3012   {
3013     plugin->rs_v6 = GNUNET_NETWORK_fdset_create ();
3014     plugin->ws_v6 = GNUNET_NETWORK_fdset_create ();
3015     GNUNET_NETWORK_fdset_zero (plugin->rs_v6);
3016     GNUNET_NETWORK_fdset_zero (plugin->ws_v6);
3017     if (NULL != plugin->sockv6)
3018     {
3019       GNUNET_NETWORK_fdset_set (plugin->rs_v6, plugin->sockv6);
3020       GNUNET_NETWORK_fdset_set (plugin->ws_v6, plugin->sockv6);
3021     }
3022   }
3023
3024   schedule_select (plugin);
3025   plugin->nat = GNUNET_NAT_register (plugin->env->cfg,
3026                            GNUNET_NO, plugin->port,
3027                            sockets_created,
3028                            (const struct sockaddr **) addrs, addrlens,
3029                            &udp_nat_port_map_callback, NULL, plugin);
3030
3031   return sockets_created;
3032 }
3033
3034
3035 /**
3036  * The exported method. Makes the core api available via a global and
3037  * returns the udp transport API.
3038  *
3039  * @param cls our 'struct GNUNET_TRANSPORT_PluginEnvironment'
3040  * @return our 'struct GNUNET_TRANSPORT_PluginFunctions'
3041  */
3042 void *
3043 libgnunet_plugin_transport_udp_init (void *cls)
3044 {
3045   struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
3046   struct GNUNET_TRANSPORT_PluginFunctions *api;
3047   struct Plugin *p;
3048   unsigned long long port;
3049   unsigned long long aport;
3050   unsigned long long udp_max_bps;
3051   unsigned long long enable_v6;
3052   unsigned long long enable_broadcasting;
3053   unsigned long long enable_broadcasting_recv;
3054   char * bind4_address;
3055   char * bind6_address;
3056   char * fancy_interval;
3057   struct GNUNET_TIME_Relative interval;
3058   struct sockaddr_in server_addrv4;
3059   struct sockaddr_in6 server_addrv6;
3060   int res;
3061   int have_bind4;
3062   int have_bind6;
3063
3064   if (NULL == env->receive)
3065   {
3066     /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
3067        initialze the plugin or the API */
3068     api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
3069     api->cls = NULL;
3070     api->address_pretty_printer = &udp_plugin_address_pretty_printer;
3071     api->address_to_string = &udp_address_to_string;
3072     api->string_to_address = &udp_string_to_address;
3073     return api;
3074   }
3075
3076   GNUNET_assert (NULL != env->stats);
3077
3078   /* Get port number: port == 0 : autodetect a port,
3079    * > 0 : use this port, not given : 2086 default */
3080   if (GNUNET_OK !=
3081       GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp", "PORT",
3082                                              &port))
3083     port = 2086;
3084   if (GNUNET_OK !=
3085       GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp",
3086                                              "ADVERTISED_PORT", &aport))
3087     aport = port;
3088   if (port > 65535)
3089   {
3090     LOG (GNUNET_ERROR_TYPE_WARNING,
3091          _("Given `%s' option is out of range: %llu > %u\n"), "PORT", port,
3092          65535);
3093     return NULL;
3094   }
3095
3096   /* Protocols */
3097   if ((GNUNET_YES ==
3098        GNUNET_CONFIGURATION_get_value_yesno (env->cfg, "nat",
3099                                              "DISABLEV6")))
3100     enable_v6 = GNUNET_NO;
3101   else
3102     enable_v6 = GNUNET_YES;
3103
3104   /* Addresses */
3105   have_bind4 = GNUNET_NO;
3106   memset (&server_addrv4, 0, sizeof (server_addrv4));
3107   if (GNUNET_YES ==
3108       GNUNET_CONFIGURATION_get_value_string (env->cfg, "transport-udp",
3109                                              "BINDTO", &bind4_address))
3110   {
3111     LOG (GNUNET_ERROR_TYPE_DEBUG,
3112          "Binding udp plugin to specific address: `%s'\n",
3113          bind4_address);
3114     if (1 != inet_pton (AF_INET, bind4_address, &server_addrv4.sin_addr))
3115     {
3116       GNUNET_free (bind4_address);
3117       return NULL;
3118     }
3119     have_bind4 = GNUNET_YES;
3120   }
3121   GNUNET_free_non_null (bind4_address);
3122   have_bind6 = GNUNET_NO;
3123   memset (&server_addrv6, 0, sizeof (server_addrv6));
3124   if (GNUNET_YES ==
3125       GNUNET_CONFIGURATION_get_value_string (env->cfg, "transport-udp",
3126                                              "BINDTO6", &bind6_address))
3127   {
3128     LOG (GNUNET_ERROR_TYPE_DEBUG,
3129          "Binding udp plugin to specific address: `%s'\n",
3130          bind6_address);
3131     if (1 !=
3132         inet_pton (AF_INET6, bind6_address, &server_addrv6.sin6_addr))
3133     {
3134       LOG (GNUNET_ERROR_TYPE_ERROR, _("Invalid IPv6 address: `%s'\n"),
3135            bind6_address);
3136       GNUNET_free (bind6_address);
3137       return NULL;
3138     }
3139     have_bind6 = GNUNET_YES;
3140   }
3141   GNUNET_free_non_null (bind6_address);
3142
3143   /* Initialize my flags */
3144   myoptions = 0;
3145
3146   /* Enable neighbour discovery */
3147   enable_broadcasting = GNUNET_CONFIGURATION_get_value_yesno (env->cfg, "transport-udp",
3148                                             "BROADCAST");
3149   if (enable_broadcasting == GNUNET_SYSERR)
3150     enable_broadcasting = GNUNET_NO;
3151
3152   enable_broadcasting_recv = GNUNET_CONFIGURATION_get_value_yesno (env->cfg, "transport-udp",
3153                                             "BROADCAST_RECEIVE");
3154   if (enable_broadcasting_recv == GNUNET_SYSERR)
3155     enable_broadcasting_recv = GNUNET_YES;
3156
3157   if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_string (env->cfg, "transport-udp",
3158                                            "BROADCAST_INTERVAL", &fancy_interval))
3159   {
3160     interval = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
3161   }
3162   else
3163   {
3164      if (GNUNET_SYSERR == GNUNET_STRINGS_fancy_time_to_relative(fancy_interval, &interval))
3165      {
3166        interval = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
3167      }
3168      GNUNET_free (fancy_interval);
3169   }
3170
3171   /* Maximum datarate */
3172   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-udp",
3173                                              "MAX_BPS", &udp_max_bps))
3174   {
3175     udp_max_bps = 1024 * 1024 * 50;     /* 50 MB/s == infinity for practical purposes */
3176   }
3177
3178   p = GNUNET_new (struct Plugin);
3179   p->port = port;
3180   p->aport = aport;
3181   p->broadcast_interval = interval;
3182   p->enable_ipv6 = enable_v6;
3183   p->enable_ipv4 = GNUNET_YES; /* default */
3184   p->enable_broadcasting = enable_broadcasting;
3185   p->enable_broadcasting_receiving = enable_broadcasting_recv;
3186   p->env = env;
3187   p->sessions = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
3188   p->defrag_ctxs = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
3189   p->mst = GNUNET_SERVER_mst_create (&process_inbound_tokenized_messages, p);
3190   GNUNET_BANDWIDTH_tracker_init (&p->tracker,
3191       GNUNET_BANDWIDTH_value_init ((uint32_t) udp_max_bps), 30);
3192   plugin = p;
3193
3194   LOG(GNUNET_ERROR_TYPE_DEBUG, "Setting up sockets\n");
3195   res = setup_sockets (p, (GNUNET_YES == have_bind6) ? &server_addrv6 : NULL,
3196       (GNUNET_YES == have_bind4) ? &server_addrv4 : NULL );
3197   if ((res == 0) || ((p->sockv4 == NULL )&& (p->sockv6 == NULL)))
3198   {
3199     LOG (GNUNET_ERROR_TYPE_ERROR,
3200          _("Failed to create network sockets, plugin failed\n"));
3201     GNUNET_CONTAINER_multipeermap_destroy (p->sessions);
3202     GNUNET_CONTAINER_heap_destroy (p->defrag_ctxs);
3203     GNUNET_SERVER_mst_destroy (p->mst);
3204     GNUNET_free (p);
3205     return NULL;
3206   }
3207
3208   /* Setup broadcasting and receiving beacons */
3209   setup_broadcast (p, &server_addrv6, &server_addrv4);
3210
3211   api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
3212   api->cls = p;
3213   api->send = NULL;
3214   api->disconnect_session = &udp_disconnect_session;
3215   api->query_keepalive_factor = &udp_query_keepalive_factor;
3216   api->disconnect_peer = &udp_disconnect;
3217   api->address_pretty_printer = &udp_plugin_address_pretty_printer;
3218   api->address_to_string = &udp_address_to_string;
3219   api->string_to_address = &udp_string_to_address;
3220   api->check_address = &udp_plugin_check_address;
3221   api->get_session = &udp_plugin_get_session;
3222   api->send = &udp_plugin_send;
3223   api->get_network = &udp_get_network;
3224   api->update_session_timeout = &udp_plugin_update_session_timeout;
3225   return api;
3226 }
3227
3228
3229 static int
3230 heap_cleanup_iterator (void *cls,
3231                        struct GNUNET_CONTAINER_HeapNode *node,
3232                        void *element,
3233                        GNUNET_CONTAINER_HeapCostType cost)
3234 {
3235   struct DefragContext * d_ctx = element;
3236
3237   GNUNET_CONTAINER_heap_remove_node (node);
3238   GNUNET_DEFRAGMENT_context_destroy(d_ctx->defrag);
3239   GNUNET_free (d_ctx);
3240
3241   return GNUNET_YES;
3242 }
3243
3244
3245 /**
3246  * The exported method. Makes the core api available via a global and
3247  * returns the udp transport API.
3248  *
3249  * @param cls our 'struct GNUNET_TRANSPORT_PluginEnvironment'
3250  * @return NULL
3251  */
3252 void *
3253 libgnunet_plugin_transport_udp_done (void *cls)
3254 {
3255   struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
3256   struct Plugin *plugin = api->cls;
3257   struct PrettyPrinterContext *cur;
3258   struct PrettyPrinterContext *next;
3259
3260   if (NULL == plugin)
3261   {
3262     GNUNET_free (api);
3263     return NULL;
3264   }
3265
3266   stop_broadcast (plugin);
3267   if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
3268   {
3269     GNUNET_SCHEDULER_cancel (plugin->select_task);
3270     plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
3271   }
3272   if (plugin->select_task_v6 != GNUNET_SCHEDULER_NO_TASK)
3273   {
3274     GNUNET_SCHEDULER_cancel (plugin->select_task_v6);
3275     plugin->select_task_v6 = GNUNET_SCHEDULER_NO_TASK;
3276   }
3277
3278   /* Closing sockets */
3279   if (GNUNET_YES == plugin->enable_ipv4)
3280   {
3281     if (NULL != plugin->sockv4)
3282     {
3283       GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4));
3284       plugin->sockv4 = NULL;
3285     }
3286     GNUNET_NETWORK_fdset_destroy (plugin->rs_v4);
3287     GNUNET_NETWORK_fdset_destroy (plugin->ws_v4);
3288   }
3289   if (GNUNET_YES == plugin->enable_ipv6)
3290   {
3291     if (NULL != plugin->sockv6)
3292     {
3293       GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6));
3294       plugin->sockv6 = NULL;
3295
3296       GNUNET_NETWORK_fdset_destroy (plugin->rs_v6);
3297       GNUNET_NETWORK_fdset_destroy (plugin->ws_v6);
3298     }
3299   }
3300   if (NULL != plugin->nat)
3301   {
3302     GNUNET_NAT_unregister (plugin->nat);
3303     plugin->nat = NULL;
3304   }
3305   if (NULL != plugin->defrag_ctxs)
3306   {
3307     GNUNET_CONTAINER_heap_iterate (plugin->defrag_ctxs,
3308                                    heap_cleanup_iterator, NULL);
3309     GNUNET_CONTAINER_heap_destroy (plugin->defrag_ctxs);
3310     plugin->defrag_ctxs = NULL;
3311   }
3312   if (plugin->mst != NULL)
3313   {
3314     GNUNET_SERVER_mst_destroy(plugin->mst);
3315     plugin->mst = NULL;
3316   }
3317
3318   /* Clean up leftover messages */
3319   struct UDP_MessageWrapper * udpw;
3320   udpw = plugin->ipv4_queue_head;
3321   while (udpw != NULL)
3322   {
3323     struct UDP_MessageWrapper *tmp = udpw->next;
3324     dequeue (plugin, udpw);
3325     call_continuation(udpw, GNUNET_SYSERR);
3326     GNUNET_free (udpw);
3327
3328     udpw = tmp;
3329   }
3330   udpw = plugin->ipv6_queue_head;
3331   while (udpw != NULL)
3332   {
3333     struct UDP_MessageWrapper *tmp = udpw->next;
3334     dequeue (plugin, udpw);
3335     call_continuation(udpw, GNUNET_SYSERR);
3336     GNUNET_free (udpw);
3337
3338     udpw = tmp;
3339   }
3340
3341   /* Clean up sessions */
3342   LOG (GNUNET_ERROR_TYPE_DEBUG,
3343        "Cleaning up sessions\n");
3344   GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions, &disconnect_and_free_it, plugin);
3345   GNUNET_CONTAINER_multipeermap_destroy (plugin->sessions);
3346
3347   next = ppc_dll_head;
3348   for (cur = next; NULL != cur; cur = next)
3349   {
3350     next = cur->next;
3351     GNUNET_CONTAINER_DLL_remove (ppc_dll_head, ppc_dll_tail, cur);
3352     GNUNET_RESOLVER_request_cancel (cur->resolver_handle);
3353     GNUNET_SCHEDULER_cancel (cur->timeout_task);
3354     GNUNET_free (cur);
3355     GNUNET_break (0);
3356   }
3357
3358   plugin->nat = NULL;
3359   GNUNET_free (plugin);
3360   GNUNET_free (api);
3361 #if DEBUG_MALLOC
3362   struct Allocation *allocation;
3363   while (NULL != ahead)
3364   {
3365     allocation = ahead;
3366     GNUNET_CONTAINER_DLL_remove (ahead, atail, allocation);
3367     GNUNET_free (allocation);
3368   }
3369   struct Allocator *allocator;
3370   while (NULL != aehead)
3371   {
3372     allocator = aehead;
3373     GNUNET_CONTAINER_DLL_remove (aehead, aetail, allocator);
3374     GNUNET_free (allocator);
3375   }
3376 #endif
3377   return NULL;
3378 }
3379
3380
3381 /* end of plugin_transport_udp.c */