more code cleanup
[oweals/gnunet.git] / src / transport / plugin_transport_udp.c
index e54479b4fa5d8f8816093da9a9f8389cbbef4db8..791272e1977ff2572dcf0d5178a304767c525a57 100644 (file)
@@ -328,6 +328,23 @@ struct UDP_NAT_Probes
 };
 
 
+/**
+ * Information we keep for each of our listen sockets.
+ */
+struct UDP_Sock_Info
+{
+  /**
+   * The network handle 
+   */
+  struct GNUNET_NETWORK_Handle *desc;
+
+  /**
+   * The port we bound to 
+   */
+  uint16_t port;
+};
+
+
 /**
  * Encapsulation of all of the state of the plugin.
  */
@@ -379,6 +396,16 @@ struct Plugin
    */
   char *internal_address;
 
+  /**
+   * Address we were told to bind to exclusively (IPv4).
+   */
+  char *bind_address;
+
+  /**
+   * Address we were told to bind to exclusively (IPv6).
+   */
+  char *bind6_address;
+
   /**
    * List of our IP addresses.
    */
@@ -404,6 +431,21 @@ struct Plugin
    */
   const struct GNUNET_DISK_FileHandle *server_stdout_handle;
 
+  /**
+   * Probes in flight
+   */
+  struct UDP_NAT_Probes *probes;
+
+  /**
+   * socket that we transmit all IPv4 data with
+   */
+  struct UDP_Sock_Info udp_sockv4;
+
+  /**
+   * socket that we transmit all IPv6 data with
+   */
+  struct UDP_Sock_Info udp_sockv6;
+
   /**
    * ID of select gnunet-nat-server stdout read task
    */
@@ -431,31 +473,9 @@ struct Plugin
    */
   pid_t server_pid;
 
-  /**
-   * Probes in flight
-   */
-  struct UDP_NAT_Probes *probes;
-
 };
 
 
-struct UDP_Sock_Info
-{
-  /* The network handle */
-  struct GNUNET_NETWORK_Handle *desc;
-
-  /* The port we bound to */
-  int port;
-};
-
-/* *********** globals ************* */
-
-/**
- * the socket that we transmit all data with
- */
-static struct UDP_Sock_Info udp_sock;
-
-
 /**
  * Forward declaration.
  */
@@ -490,38 +510,35 @@ static int
 udp_transport_server_stop (void *cls)
 {
   struct Plugin *plugin = cls;
-  int ret;
-  int ok;
 
-  ret = 0;
   if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
     {
       GNUNET_SCHEDULER_cancel (plugin->env->sched, plugin->select_task);
       plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
     }
-
-  ok = GNUNET_NETWORK_socket_close (udp_sock.desc);
-  if (ok == GNUNET_OK)
-    udp_sock.desc = NULL;
-  ret += ok;
-
+  if (plugin->udp_sockv4.desc != NULL)
+    {
+      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->udp_sockv4.desc));
+      plugin->udp_sockv4.desc = NULL;
+    }
+  if (plugin->udp_sockv6.desc != NULL)
+    {
+      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->udp_sockv6.desc));
+      plugin->udp_sockv6.desc = NULL;
+    }
   if (plugin->behind_nat == GNUNET_YES)
     {
       if (0 != PLIBC_KILL (plugin->server_pid, SIGTERM))
-        {
-          GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-        }
+       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
       GNUNET_OS_process_wait (plugin->server_pid);
     }
-
-  if (ret != GNUNET_OK)
-    return GNUNET_SYSERR;
-  return ret;
+  return GNUNET_OK;
 }
 
 
 struct PeerSession *
-find_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *peer)
+find_session (struct Plugin *plugin, 
+             const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerSession *pos;
 
@@ -559,16 +576,16 @@ find_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *peer)
  */
 static ssize_t
 udp_real_send (void *cls,
-                  struct GNUNET_NETWORK_Handle *send_handle,
-                  const struct GNUNET_PeerIdentity *target,
-                  const char *msgbuf,
-                  size_t msgbuf_size,
-                  unsigned int priority,
-                  struct GNUNET_TIME_Relative timeout,
-                  const void *addr,
-                  size_t addrlen,
-                  GNUNET_TRANSPORT_TransmitContinuation cont,
-                  void *cont_cls)
+              struct GNUNET_NETWORK_Handle *send_handle,
+              const struct GNUNET_PeerIdentity *target,
+              const char *msgbuf,
+              size_t msgbuf_size,
+              unsigned int priority,
+              struct GNUNET_TIME_Relative timeout,
+              const void *addr,
+              size_t addrlen,
+              GNUNET_TRANSPORT_TransmitContinuation cont,
+              void *cont_cls)
 {
   struct Plugin *plugin = cls;
   struct UDPMessage *message;
@@ -581,11 +598,18 @@ udp_real_send (void *cls,
   const void *sb;
   size_t sbs;
 
+  if (send_handle == NULL)
+    {
+      /* failed to open send socket for AF */
+      if (cont != NULL)
+        cont (cont_cls, target, GNUNET_SYSERR);
+      return 0;
+    }
   if ((addr == NULL) || (addrlen == 0))
     {
 #if DEBUG_UDP
-  GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp", _
-                   ("udp_real_send called without address, returning!\n"));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "udp_real_send called without address, returning!\n");
 #endif
       if (cont != NULL)
         cont (cont_cls, target, GNUNET_SYSERR);
@@ -642,7 +666,12 @@ udp_real_send (void *cls,
     GNUNET_NETWORK_socket_sendto (send_handle, message, ssize,
                                   sb,
                                   sbs);
-
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+             "UDP transmit %u-byte message to %s (%d: %s)\n",
+             (unsigned int) ssize,
+             GNUNET_a2s (sb, sbs), 
+             (int) sent,
+             (sent < 0) ? STRERROR (errno) : "ok");
   if (cont != NULL)
     {
       if (sent == GNUNET_SYSERR)
@@ -678,7 +707,7 @@ run_gnunet_nat_client (struct Plugin *plugin, const char *addr, size_t addrlen)
   t4 = (struct IPv4UdpAddress *)addr;
 
   if (NULL == inet_ntop (AF_INET,
-                         &t4->u_port,
+                         &t4->ipv4_addr,
                          addr_buf, INET_ADDRSTRLEN))
     {
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
@@ -687,7 +716,7 @@ run_gnunet_nat_client (struct Plugin *plugin, const char *addr, size_t addrlen)
   address_as_string = GNUNET_strdup (addr_buf);
   GNUNET_asprintf(&port_as_string, "%d", plugin->port);
 #if DEBUG_UDP
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Running gnunet-nat-client with arguments: %s %s %d\n"), plugin->external_address, address_as_string, plugin->port);
 #endif
 
@@ -742,6 +771,8 @@ udp_plugin_send (void *cls,
   int other_peer_natd;
   const struct IPv4UdpAddress *t4;
 
+  if (force_address == GNUNET_SYSERR)
+    return GNUNET_SYSERR;
   GNUNET_assert (NULL == session);
 
   other_peer_natd = GNUNET_NO;
@@ -758,7 +789,6 @@ udp_plugin_send (void *cls,
     }
 
   sent = 0;
-
   if ((other_peer_natd == GNUNET_YES) && (plugin->allow_nat == GNUNET_YES))
     {
       peer_session = find_session(plugin, target);
@@ -789,7 +819,7 @@ udp_plugin_send (void *cls,
           peer_session->messages->cont = cont;
           peer_session->messages->cont_cls = cont_cls;
 #if DEBUG_UDP
-          GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                           _("Other peer is NAT'd, set up peer session for peer %s\n"), GNUNET_i2s(target));
 #endif
           run_gnunet_nat_client(plugin, addr, addrlen);
@@ -798,7 +828,13 @@ udp_plugin_send (void *cls,
         {
           if (peer_session->expecting_welcome == GNUNET_NO) /* We are "connected" */
             {
-              sent = udp_real_send(cls, peer_session->sock, target, msgbuf, msgbuf_size, priority, timeout, peer_session->connect_addr, peer_session->connect_alen, cont, cont_cls);
+              sent = udp_real_send(cls,
+                                  peer_session->sock,
+                                  target,
+                                  msgbuf, msgbuf_size,
+                                  priority, timeout,
+                                  peer_session->connect_addr, peer_session->connect_alen, 
+                                  cont, cont_cls);
             }
           else /* Haven't gotten a response from this peer, queue message */
             {
@@ -816,17 +852,23 @@ udp_plugin_send (void *cls,
     }
   else if (other_peer_natd == GNUNET_NO) /* Other peer not behind a NAT, so we can just send the message as is */
     {
-      sent = udp_real_send(cls, udp_sock.desc, target, msgbuf, msgbuf_size, priority, timeout, addr, addrlen, cont, cont_cls);
+      sent = udp_real_send(cls, 
+                          (addrlen == sizeof (struct IPv4UdpAddress)) ? plugin->udp_sockv4.desc : plugin->udp_sockv6.desc, 
+                          target,
+                          msgbuf, msgbuf_size,
+                          priority, timeout, addr, addrlen, 
+                          cont, cont_cls);
     }
   else /* Other peer is NAT'd, but we don't want to play with them (or can't!) */
-    return GNUNET_SYSERR;
+    {
+      return GNUNET_SYSERR;
+    }
 
   /* When GNUNET_SYSERR is returned from udp_real_send, we will still call
    * the callback so must not return GNUNET_SYSERR!
-   * If we do, then transport context get freed twice. */
+   * If we did, then transport context would get freed twice. */
   if (sent == GNUNET_SYSERR)
     return 0;
-
   return sent;
 }
 
@@ -891,12 +933,21 @@ process_interfaces (void *cls,
   void *arg;
   uint16_t args;
   void *addr_nat;
+  char buf[INET6_ADDRSTRLEN];
 
   addr_nat = NULL;
   af = addr->sa_family;
+
+  memset(buf, 0, INET6_ADDRSTRLEN);
   if (af == AF_INET)
     {
       t4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
+      GNUNET_assert(NULL != inet_ntop(AF_INET, &t4.ipv4_addr, &buf[0], INET_ADDRSTRLEN));
+      if ((plugin->bind6_address != NULL) || ((plugin->bind_address != NULL) && (0 != strcmp(buf, plugin->bind_address))))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Not notifying transport of address %s\n", "UDP", GNUNET_a2s (addr, addrlen));
+          return GNUNET_OK;
+        }
       add_to_address_list (plugin, &t4.ipv4_addr, sizeof (uint32_t));
       if ((plugin->behind_nat == GNUNET_YES) && (plugin->only_nat_addresses == GNUNET_YES))
         {
@@ -905,9 +956,9 @@ process_interfaces (void *cls,
       else if (plugin->behind_nat == GNUNET_YES) /* We are behind NAT, but will advertise NAT and normal addresses */
         {
           addr_nat = GNUNET_malloc(sizeof(t4));
+          t4.u_port = htons (DEFAULT_NAT_PORT);
           memcpy(addr_nat, &t4, sizeof(t4));
           t4.u_port = plugin->port;
-          ((struct IPv4UdpAddress *)addr_nat)->u_port = htons(DEFAULT_NAT_PORT);
         }
       else
         {
@@ -926,17 +977,23 @@ process_interfaces (void *cls,
       memcpy (&t6.ipv6_addr,
               &((struct sockaddr_in6 *) addr)->sin6_addr,
               sizeof (struct in6_addr));
+      GNUNET_assert(NULL != inet_ntop(AF_INET6, &t6.ipv6_addr, &buf[0], INET6_ADDRSTRLEN));
+      if ((plugin->bind_address != NULL) || ((plugin->bind6_address != NULL) && (0 != strcmp(buf, plugin->bind_address))))
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s: Not notifying transport of address %s\n", "UDP", GNUNET_a2s (addr, addrlen));
+          return GNUNET_OK;
+        }
       add_to_address_list (plugin, &t6.ipv6_addr, sizeof (struct in6_addr));
       if ((plugin->behind_nat == GNUNET_YES) && (plugin->only_nat_addresses == GNUNET_YES))
         {
-          t6.u6_port = htons (0);
+          t6.u6_port = htons (DEFAULT_NAT_PORT);
         }
       else if (plugin->behind_nat == GNUNET_YES)
         {
           addr_nat = GNUNET_malloc(sizeof(t6));
+          t6.u6_port = htons (DEFAULT_NAT_PORT);
           memcpy(addr_nat, &t6, sizeof(t6));
           t6.u6_port = plugin->port;
-          ((struct IPv6UdpAddress *)addr_nat)->u6_port = htons(DEFAULT_NAT_PORT);
         }
       else
         {
@@ -968,7 +1025,7 @@ process_interfaces (void *cls,
                  GNUNET_a2s (addr_nat, args), name);
       GNUNET_free(addr_nat);
     }
-  
+
   plugin->env->notify_address (plugin->env->cls,
                               "udp",
                               arg, args, GNUNET_TIME_UNIT_FOREVER_REL);
@@ -1011,30 +1068,28 @@ static void
 send_udp_probe_message (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct UDP_NAT_Probes *probe = cls;
-  struct UDP_NAT_ProbeMessage *message;
+  struct UDP_NAT_ProbeMessage message;
   struct Plugin *plugin = probe->plugin;
 
-  message = GNUNET_malloc(sizeof(struct UDP_NAT_ProbeMessage));
-  message->header.size = htons(sizeof(struct UDP_NAT_ProbeMessage));
-  message->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE);
+  memset (&message, 0, sizeof (message));
+  message.header.size = htons(sizeof(struct UDP_NAT_ProbeMessage));
+  message.header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE);
   /* If they gave us a port, use that.  If not, try our port. */
   if (ntohs(probe->addr.u_port) == 0)
     probe->addr.u_port = htons(plugin->port);
 
 #if DEBUG_UDP
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                       _("Sending a probe to port %d\n"), ntohs(probe->addr.u_port));
 #endif
-
   probe->count++;
-
-  udp_real_send(plugin, udp_sock.desc, NULL,
-                   (char *)message, ntohs(message->header.size), 0, 
-                   GNUNET_TIME_relative_get_unit(), 
-                   &probe->addr, sizeof(probe->addr),
-                   &udp_probe_continuation, probe);
-
-  GNUNET_free(message);
+  udp_real_send(plugin, 
+               plugin->udp_sockv4.desc, 
+               NULL,
+               (char *)&message, ntohs(message.header.size), 0, 
+               GNUNET_TIME_relative_get_unit(), 
+               &probe->addr, sizeof(struct IPv4UdpAddress),
+               &udp_probe_continuation, probe);
 }
 
 
@@ -1052,7 +1107,7 @@ udp_probe_continuation (void *cls, const struct GNUNET_PeerIdentity *target, int
   if ((result == GNUNET_OK) && (probe->count < MAX_PROBES))
     {
 #if DEBUG_UDP
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                        _("Scheduling next probe for 10000 milliseconds\n"));
 #endif
       probe->task = GNUNET_SCHEDULER_add_delayed(plugin->env->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 10000), &send_udp_probe_message, probe);
@@ -1060,7 +1115,7 @@ udp_probe_continuation (void *cls, const struct GNUNET_PeerIdentity *target, int
   else /* Destroy the probe context. */
     {
 #if DEBUG_UDP
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                       _("Sending probe didn't go well...\n"));
 #endif
     }
@@ -1116,7 +1171,7 @@ udp_plugin_server_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc
   if (bytes < 1)
     {
 #if DEBUG_UDP
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                       _("Finished reading from server stdout with code: %d\n"), bytes);
 #endif
       return;
@@ -1148,7 +1203,7 @@ udp_plugin_server_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc
     }
 
 #if DEBUG_UDP
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("nat-server-read read: %s port %d\n"), &mybuf, port);
 #endif
 
@@ -1159,7 +1214,7 @@ udp_plugin_server_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc
   if (inet_pton(AF_INET, &mybuf[0], &a4.ipv4_addr) != 1)
     {
 
-      GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, "udp",
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                   _("nat-server-read malformed address\n"), &mybuf, port);
 
       plugin->server_read_task =
@@ -1246,8 +1301,9 @@ udp_demultiplexer(struct Plugin *plugin, struct GNUNET_PeerIdentity *sender,
       outgoing_probe_reply->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_REPLY);
 
 #if DEBUG_UDP
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
-                      _("Received a probe on listen port %d, sent_from port %d\n"), sockinfo->port, incoming_port);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  _("Received a probe on listen port %d, sent_from port %d\n"),
+                   sockinfo->port, incoming_port);
 #endif
 
       udp_real_send(plugin, sockinfo->desc, NULL,
@@ -1258,18 +1314,19 @@ udp_demultiplexer(struct Plugin *plugin, struct GNUNET_PeerIdentity *sender,
                     NULL, NULL);
 
 #if DEBUG_UDP
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
-                      _("Sent PROBE REPLY to port %d on outgoing port %d\n"), incoming_port, sockinfo->port);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  _("Sent PROBE REPLY to port %d on outgoing port %d\n"),
+                   incoming_port, sockinfo->port);
 #endif
       GNUNET_free(outgoing_probe_reply);
       break;
     case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_REPLY:
       /* Check for existing probe, check ports returned, send confirmation if all is well */
 #if DEBUG_UDP
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
-                      _("Received PROBE REPLY from port %d on incoming port %d\n"), incoming_port, sockinfo->port);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  _("Received PROBE REPLY from port %d on incoming port %d\n"), incoming_port, sockinfo->port);
 #endif
-      if (sizeof(sender_addr) == sizeof(struct IPv4UdpAddress))
+      if (fromlen == sizeof(struct IPv4UdpAddress))
         {
           memset(&addr_buf, 0, sizeof(addr_buf));
           if (NULL == inet_ntop (AF_INET, 
@@ -1283,14 +1340,17 @@ udp_demultiplexer(struct Plugin *plugin, struct GNUNET_PeerIdentity *sender,
           if (outgoing_probe != NULL)
             {
 #if DEBUG_UDP
-              GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
-                              _("Sending confirmation that we were reached!\n"));
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          _("Sending confirmation that we were reached!\n"));
 #endif
               outgoing_probe_confirmation = GNUNET_malloc(sizeof(struct UDP_NAT_ProbeMessageConfirmation));
               outgoing_probe_confirmation->header.size = htons(sizeof(struct UDP_NAT_ProbeMessageConfirmation));
               outgoing_probe_confirmation->header.type = htons(GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_CONFIRM);
-
-              udp_real_send(plugin, sockinfo->desc, NULL, (char *)outgoing_probe_confirmation, ntohs(outgoing_probe_confirmation->header.size), 0, GNUNET_TIME_relative_get_unit(), sender_addr, fromlen, NULL, NULL);
+              udp_real_send(plugin, sockinfo->desc, NULL, 
+                           (char *)outgoing_probe_confirmation, 
+                           ntohs(outgoing_probe_confirmation->header.size), 0, 
+                           GNUNET_TIME_relative_get_unit(), 
+                           sender_addr, fromlen, NULL, NULL);
 
               if (outgoing_probe->task != GNUNET_SCHEDULER_NO_TASK)
                 {
@@ -1303,23 +1363,30 @@ udp_demultiplexer(struct Plugin *plugin, struct GNUNET_PeerIdentity *sender,
           else
             {
 #if DEBUG_UDP
-              GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp",
-                              _("Received a probe reply, but have no record of a sent probe!\n"));
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          _("Received a probe reply, but have no record of a sent probe!\n"));
 #endif
             }
         }
+      else
+        {
+#if DEBUG_UDP
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      _("Received a probe reply, but sender address size is WRONG (should be %d, is %d)!\n"), sizeof(struct IPv4UdpAddress), fromlen);
+#endif
+        }
       break;
     case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_NAT_PROBE_CONFIRM:
       peer_session = find_session(plugin, sender);
 #if DEBUG_UDP
-          GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
-                          _("Looking up peer session for peer %s\n"), GNUNET_i2s(sender));
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      _("Looking up peer session for peer %s\n"), GNUNET_i2s(sender));
 #endif
       if (peer_session == NULL) /* Shouldn't this NOT happen? */
         {
 #if DEBUG_UDP
-          GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp",
-                          _("Peer not in list, adding (THIS MAY BE A MISTAKE) %s\n"), GNUNET_i2s(sender));
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      _("Peer not in list, adding (THIS MAY BE A MISTAKE) %s\n"), GNUNET_i2s(sender));
 #endif
           peer_session = GNUNET_malloc(sizeof(struct PeerSession));
           peer_session->connect_addr = GNUNET_malloc(fromlen);
@@ -1349,22 +1416,22 @@ udp_demultiplexer(struct Plugin *plugin, struct GNUNET_PeerIdentity *sender,
             }
 
 #if DEBUG_UDP
-              GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp",
-                              _("Received a probe confirmation, will send to peer on port %d\n"), incoming_port);
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          _("Received a probe confirmation, will send to peer on port %d\n"), incoming_port);
 #endif
           if (peer_session->messages != NULL)
             {
 #if DEBUG_UDP
-              GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp",
-                              _("Received a probe confirmation, sending queued messages.\n"));
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          _("Received a probe confirmation, sending queued messages.\n"));
 #endif
               pending_message = peer_session->messages;
               int count = 0;
               while (pending_message != NULL)
                 {
 #if DEBUG_UDP
-                  GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp",
-                                  _("sending queued message %d\n"), count);
+                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                              _("sending queued message %d\n"), count);
 #endif
                   udp_real_send(plugin,
                                 peer_session->sock,
@@ -1382,8 +1449,8 @@ udp_demultiplexer(struct Plugin *plugin, struct GNUNET_PeerIdentity *sender,
                   GNUNET_free(pending_message_temp->msgbuf);
                   GNUNET_free(pending_message_temp);
 #if DEBUG_UDP
-                  GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp",
-                                  _("finished sending queued message %d\n"), count);
+                  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                              _("finished sending queued message %d\n"), count);
 #endif
                   count++;
                 }
@@ -1393,8 +1460,8 @@ udp_demultiplexer(struct Plugin *plugin, struct GNUNET_PeerIdentity *sender,
       else
         {
 #if DEBUG_UDP
-          GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "udp",
-                          _("Received probe confirmation for already confirmed peer!\n"));
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      _("Received probe confirmation for already confirmed peer!\n"));
 #endif
         }
       /* Received confirmation, add peer with address/port specified */
@@ -1406,7 +1473,8 @@ udp_demultiplexer(struct Plugin *plugin, struct GNUNET_PeerIdentity *sender,
     default:
 #if DEBUG_UDP
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                       _("Sending message type %d to transport!\n"), ntohs(currhdr->type));
+                  "Sending message type %d to transport!\n",
+                  ntohs(currhdr->type));
 #endif
       plugin->env->receive (plugin->env->cls, sender, currhdr, UDP_DIRECT_DISTANCE, 
                            NULL, sender_addr, fromlen);
@@ -1425,13 +1493,13 @@ udp_demultiplexer(struct Plugin *plugin, struct GNUNET_PeerIdentity *sender,
  *
  */
 static void
-udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+udp_plugin_select (void *cls,
+                  const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
-  char *buf;
+  char buf[65536];
   struct UDPMessage *msg;
-  struct GNUNET_PeerIdentity *sender;
-  unsigned int buflen;
+  struct GNUNET_PeerIdentity sender;
   socklen_t fromlen;
   char addr[32];
   ssize_t ret;
@@ -1446,26 +1514,27 @@ udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   const struct sockaddr_in6 *s6;
   const void *ca;
   size_t calen;
-
+  struct UDP_Sock_Info *udp_sock;
 
   plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
-
   if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
     return;
-
-  buf = NULL;
-  sender = NULL;
-
-  buflen = GNUNET_NETWORK_socket_recvfrom_amount (udp_sock.desc);
-
-  if (buflen == GNUNET_NO)
-    return;
-
-  buf = GNUNET_malloc (buflen);
+  udp_sock = NULL;
+  if (GNUNET_NETWORK_fdset_isset (tc->read_ready,
+                                 plugin->udp_sockv4.desc))
+    udp_sock = &plugin->udp_sockv4;
+  else if (GNUNET_NETWORK_fdset_isset (tc->read_ready,
+                                      plugin->udp_sockv6.desc))
+    udp_sock = &plugin->udp_sockv6;
+  if (NULL == udp_sock)
+    {
+      GNUNET_break (0);
+      return;
+    }
   fromlen = sizeof (addr);
   memset (&addr, 0, sizeof(addr));
   ret =
-    GNUNET_NETWORK_socket_recvfrom (udp_sock.desc, buf, buflen,
+    GNUNET_NETWORK_socket_recvfrom (udp_sock->desc, buf, sizeof (buf),
                                     (struct sockaddr *)&addr, &fromlen);
 
   if (AF_INET == ((struct sockaddr *)addr)->sa_family)
@@ -1492,39 +1561,41 @@ udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       ca = NULL;
       calen = 0;
     }
-
-  if (ret <= 0)
+  if (ret < sizeof (struct UDPMessage))
     {
-      GNUNET_free (buf);
+      GNUNET_break_op (0);
+      plugin->select_task =
+       GNUNET_SCHEDULER_add_select (plugin->env->sched,
+                                    GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                    GNUNET_SCHEDULER_NO_TASK,
+                                    GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                    NULL, &udp_plugin_select, plugin);
       return;
     }
   msg = (struct UDPMessage *) buf;
-
   if (ntohs (msg->header.size) < sizeof (struct UDPMessage))
     {
-      GNUNET_free (buf);
+      GNUNET_break_op (0);
+      plugin->select_task =
+       GNUNET_SCHEDULER_add_select (plugin->env->sched,
+                                    GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                    GNUNET_SCHEDULER_NO_TASK,
+                                    GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                    NULL, &udp_plugin_select, plugin);
       return;
     }
-
   msgbuf = (char *)&msg[1];
-  sender = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
-  memcpy (sender, &msg->sender, sizeof (struct GNUNET_PeerIdentity));
-
+  memcpy (&sender, &msg->sender, sizeof (struct GNUNET_PeerIdentity));
   offset = 0;
   count = 0;
   tsize = ntohs (msg->header.size) - sizeof(struct UDPMessage);
-
   while (offset < tsize)
     {
       currhdr = (struct GNUNET_MessageHeader *)&msgbuf[offset];
-      udp_demultiplexer(plugin, sender, currhdr, ca, calen, &udp_sock);
+      udp_demultiplexer(plugin, &sender, currhdr, ca, calen, udp_sock);
       offset += ntohs(currhdr->size);
       count++;
     }
-  GNUNET_free_non_null (buf);
-  GNUNET_free_non_null (sender);
-
-
   plugin->select_task =
     GNUNET_SCHEDULER_add_select (plugin->env->sched,
                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT,
@@ -1535,13 +1606,11 @@ udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 }
 
 /**
- * Create a slew of UDP sockets.  If possible, use IPv6, otherwise
- * try IPv4.
+ * Create a slew of UDP sockets.  If possible, use IPv6 and IPv4.
  *
  * @param cls closure for server start, should be a struct Plugin *
- *
  * @return number of sockets created or GNUNET_SYSERR on error
- */
+*/
 static int
 udp_transport_server_start (void *cls)
 {
@@ -1551,9 +1620,10 @@ udp_transport_server_start (void *cls)
   struct sockaddr *serverAddr;
   socklen_t addrlen;
   int sockets_created;
+  int tries;
 
-  sockets_created = 0;
 
+  sockets_created = 0;
   if (plugin->behind_nat == GNUNET_YES)
     {
       /* Pipe to read from started processes stdout (on read end) */
@@ -1561,97 +1631,152 @@ udp_transport_server_start (void *cls)
       if (plugin->server_stdout == NULL)
         return sockets_created;
 #if DEBUG_UDP
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "udp",
-                   "Starting gnunet-nat-server process cmd: %s %s\n", "gnunet-nat-server", plugin->internal_address);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Starting gnunet-nat-server process cmd: %s %s\n",
+                  "gnunet-nat-server",
+                  plugin->internal_address);
 #endif
       /* Start the server process */
-      plugin->server_pid = GNUNET_OS_start_process(NULL, plugin->server_stdout, "gnunet-nat-server", "gnunet-nat-server", plugin->internal_address, NULL);
+      plugin->server_pid = GNUNET_OS_start_process(NULL, 
+                                                  plugin->server_stdout, 
+                                                  "gnunet-nat-server", 
+                                                  "gnunet-nat-server", 
+                                                  plugin->internal_address, NULL);
       if (plugin->server_pid == GNUNET_SYSERR)
         {
 #if DEBUG_UDP
-          GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                           "udp",
-                           "Failed to start gnunet-nat-server process\n");
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Failed to start gnunet-nat-server process\n");
 #endif
           return GNUNET_SYSERR;
         }
       /* Close the write end of the read pipe */
       GNUNET_DISK_pipe_close_end(plugin->server_stdout, GNUNET_DISK_PIPE_END_WRITE);
-
+      
       plugin->server_stdout_handle = GNUNET_DISK_pipe_handle(plugin->server_stdout, GNUNET_DISK_PIPE_END_READ);
       plugin->server_read_task =
-          GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
-                                          GNUNET_TIME_UNIT_FOREVER_REL,
-                                          plugin->server_stdout_handle, &udp_plugin_server_read, plugin);
+       GNUNET_SCHEDULER_add_read_file (plugin->env->sched,
+                                       GNUNET_TIME_UNIT_FOREVER_REL,
+                                       plugin->server_stdout_handle, &udp_plugin_server_read, plugin);
     }
 
-    udp_sock.desc = NULL;
-
-
-    udp_sock.desc = GNUNET_NETWORK_socket_create (PF_INET, SOCK_DGRAM, 17);
-    if (NULL == udp_sock.desc)
-      {
-        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", "socket");
-        return sockets_created;
-      }
-    else
-      {
-        memset (&serverAddrv4, 0, sizeof (serverAddrv4));
-#if HAVE_SOCKADDR_IN_SIN_LEN
-        serverAddrv4.sin_len = sizeof (serverAddrv4);
-#endif
-        serverAddrv4.sin_family = AF_INET;
-        serverAddrv4.sin_addr.s_addr = INADDR_ANY;
-        serverAddrv4.sin_port = htons (plugin->port);
-        addrlen = sizeof (serverAddrv4);
-        serverAddr = (struct sockaddr *) &serverAddrv4;
-#if DEBUG_UDP
-        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                         "udp",
-                         "Binding to port %d\n", ntohs(serverAddrv4.sin_port));
-#endif
-        while (GNUNET_NETWORK_socket_bind (udp_sock.desc, serverAddr, addrlen) !=
-                       GNUNET_OK)
-          {
-            serverAddrv4.sin_port = htons (GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); /* Find a good, non-root port */
-#if DEBUG_UDP
-        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                        "udp",
-                        "Binding failed, trying new port %d\n", ntohs(serverAddrv4.sin_port));
-#endif
-          }
-        udp_sock.port = ntohs(serverAddrv4.sin_port);
-        sockets_created++;
-      }
-
-
-  if ((udp_sock.desc == NULL) && (GNUNET_YES !=
-      GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg, "GNUNETD",
-                                            "DISABLE-IPV6")))
+  if ( (GNUNET_YES !=
+       GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg, "transport-udp",
+                                             "DISABLEV6")))
     {
-      udp_sock.desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 17);
-      if (udp_sock.desc != NULL)
-        {
+      plugin->udp_sockv6.desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 0);
+      if (NULL == plugin->udp_sockv6.desc)
+       {
+         GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "udp", "socket");
+       }
+      else
+       {
           memset (&serverAddrv6, 0, sizeof (serverAddrv6));
 #if HAVE_SOCKADDR_IN_SIN_LEN
           serverAddrv6.sin6_len = sizeof (serverAddrv6);
 #endif
+
           serverAddrv6.sin6_family = AF_INET6;
           serverAddrv6.sin6_addr = in6addr_any;
+          if (plugin->bind6_address != NULL)
+            {
+              if (1 != inet_pton(AF_INET6, plugin->bind6_address, &serverAddrv6.sin6_addr))
+                return 0;
+            }
+
           serverAddrv6.sin6_port = htons (plugin->port);
           addrlen = sizeof (serverAddrv6);
           serverAddr = (struct sockaddr *) &serverAddrv6;
-          sockets_created++;
+#if DEBUG_UDP
+         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Binding to IPv6 port %d\n", 
+                          ntohs(serverAddrv6.sin6_port));
+#endif
+         tries = 0;
+         while (GNUNET_NETWORK_socket_bind (plugin->udp_sockv6.desc, serverAddr, addrlen) !=
+                GNUNET_OK)
+           {
+             serverAddrv6.sin6_port = htons (GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); /* Find a good, non-root port */
+#if DEBUG_UDP
+             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                              "IPv6 Binding failed, trying new port %d\n", 
+                              ntohs(serverAddrv6.sin6_port));
+#endif
+             tries++;
+             if (tries > 10)
+               {
+                 GNUNET_NETWORK_socket_close (plugin->udp_sockv6.desc);
+                 plugin->udp_sockv6.desc = NULL;
+                 break;
+               }             
+           }
+         if (plugin->udp_sockv6.desc != NULL)
+           {
+             plugin->udp_sockv6.port = ntohs(serverAddrv6.sin6_port);
+             sockets_created++;
+           }
+       }
+    }
+
+  plugin->udp_sockv4.desc = GNUNET_NETWORK_socket_create (PF_INET, SOCK_DGRAM, 0);
+  if (NULL == plugin->udp_sockv4.desc)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "socket");
+    }
+  else
+    {
+      memset (&serverAddrv4, 0, sizeof (serverAddrv4));
+#if HAVE_SOCKADDR_IN_SIN_LEN
+      serverAddrv4.sin_len = sizeof (serverAddrv4);
+#endif
+      serverAddrv4.sin_family = AF_INET;
+      serverAddrv4.sin_addr.s_addr = INADDR_ANY;
+      if (plugin->bind_address != NULL)
+        {
+          if (1 != inet_pton(AF_INET, plugin->bind_address, &serverAddrv4.sin_addr))
+            return 0;
         }
+      serverAddrv4.sin_port = htons (plugin->port);
+      addrlen = sizeof (serverAddrv4);
+      serverAddr = (struct sockaddr *) &serverAddrv4;
+#if DEBUG_UDP
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Binding to IPv4 port %d\n", 
+                      ntohs(serverAddrv4.sin_port));
+#endif
+      tries = 0;
+      while (GNUNET_NETWORK_socket_bind (plugin->udp_sockv4.desc, serverAddr, addrlen) !=
+            GNUNET_OK)
+       {
+         serverAddrv4.sin_port = htons (GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); /* Find a good, non-root port */
+#if DEBUG_UDP
+         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "IPv4 Binding failed, trying new port %d\n", 
+                          ntohs(serverAddrv4.sin_port));
+#endif
+         tries++;
+         if (tries > 10)
+           {
+             GNUNET_NETWORK_socket_close (plugin->udp_sockv4.desc);
+             plugin->udp_sockv4.desc = NULL;
+             break;
+           }         
+       }
+      if (plugin->udp_sockv4.desc != NULL)
+       {
+         plugin->udp_sockv4.port = ntohs(serverAddrv4.sin_port);
+         sockets_created++;
+       }
     }
 
   plugin->rs = GNUNET_NETWORK_fdset_create ();
-
   GNUNET_NETWORK_fdset_zero (plugin->rs);
-
-
-  GNUNET_NETWORK_fdset_set (plugin->rs, udp_sock.desc);
+  if (NULL != plugin->udp_sockv4.desc)
+    GNUNET_NETWORK_fdset_set (plugin->rs, 
+                             plugin->udp_sockv4.desc);
+  if (NULL != plugin->udp_sockv6.desc)
+    GNUNET_NETWORK_fdset_set (plugin->rs, 
+                             plugin->udp_sockv6.desc);
 
   plugin->select_task =
     GNUNET_SCHEDULER_add_select (plugin->env->sched,
@@ -1659,7 +1784,6 @@ udp_transport_server_start (void *cls)
                                  GNUNET_SCHEDULER_NO_TASK,
                                  GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
                                  NULL, &udp_plugin_select, plugin);
-
   return sockets_created;
 }
 
@@ -1765,8 +1889,7 @@ udp_check_address (void *cls,
   inet_ntop (af, sb, buf, INET6_ADDRSTRLEN);
 
 #if DEBUG_UDP
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "udp",
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Informing transport service about my address `%s:%u'\n",
                    buf,
                    port);
@@ -2003,7 +2126,7 @@ libgnunet_plugin_transport_udp_init (void *cls)
   service = GNUNET_SERVICE_start ("transport-udp", env->sched, env->cfg);
   if (service == NULL)
     {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, "udp", _
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _
                        ("Failed to start service for `%s' transport plugin.\n"),
                        "udp");
       return NULL;
@@ -2019,7 +2142,7 @@ libgnunet_plugin_transport_udp_init (void *cls)
       else
         {
           behind_nat = GNUNET_NO;
-          GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, "udp", "Configuration specified you are behind a NAT, but gnunet-nat-server is not installed properly (suid bit not set)!\n");
+          GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Configuration specified you are behind a NAT, but gnunet-nat-server is not installed properly (suid bit not set)!\n");
         }
     }
   else
@@ -2034,7 +2157,7 @@ libgnunet_plugin_transport_udp_init (void *cls)
       else
       {
         allow_nat = GNUNET_NO;
-        GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, "udp", "Configuration specified you want to connect to NAT'd peers, but gnunet-nat-client is not installed properly (suid bit not set)!\n");
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Configuration specified you want to connect to NAT'd peers, but gnunet-nat-client is not installed properly (suid bit not set)!\n");
       }
 
     }
@@ -2055,18 +2178,16 @@ libgnunet_plugin_transport_udp_init (void *cls)
                                                 "EXTERNAL_ADDRESS",
                                                 &external_address)))
     {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                       "udp",
-                       _
-                       ("Require EXTERNAL_ADDRESS for service `%s' in configuration (either BEHIND_NAT or ALLOW_NAT set to YES)!\n"),
-                       "transport-udp");
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Require EXTERNAL_ADDRESS for service `%s' in configuration (either BEHIND_NAT or ALLOW_NAT set to YES)!\n"),
+                  "transport-udp");
       GNUNET_SERVICE_stop (service);
       return NULL;
     }
 
   if ((external_address != NULL) && (inet_pton(AF_INET, external_address, &v4_address.ipv4_addr) != 1))
     {
-      GNUNET_log_from(GNUNET_ERROR_TYPE_WARNING, "udp", "Malformed EXTERNAL_ADDRESS %s given in configuration!\n", external_address);
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Malformed EXTERNAL_ADDRESS %s given in configuration!\n", external_address);
     }
 
   internal_address = NULL;
@@ -2076,10 +2197,8 @@ libgnunet_plugin_transport_udp_init (void *cls)
                                                 "INTERNAL_ADDRESS",
                                                 &internal_address)))
     {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                       "udp",
-                       _
-                       ("Require INTERNAL_ADDRESS for service `%s' in configuration!\n"),
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                       _("Require INTERNAL_ADDRESS for service `%s' in configuration!\n"),
                        "transport-udp");
       GNUNET_SERVICE_stop (service);
       GNUNET_free_non_null(external_address);
@@ -2088,7 +2207,7 @@ libgnunet_plugin_transport_udp_init (void *cls)
 
   if ((internal_address != NULL) && (inet_pton(AF_INET, internal_address, &v4_address.ipv4_addr) != 1))
     {
-      GNUNET_log_from(GNUNET_ERROR_TYPE_WARNING, "udp", "Malformed INTERNAL_ADDRESS %s given in configuration!\n", internal_address);
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Malformed INTERNAL_ADDRESS %s given in configuration!\n", internal_address);
     }
 
   if (GNUNET_OK !=
@@ -2099,12 +2218,11 @@ libgnunet_plugin_transport_udp_init (void *cls)
     port = UDP_NAT_DEFAULT_PORT;
   else if (port > 65535)
     {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
-                      "udp",
-                      _("Given `%s' option is out of range: %llu > %u\n"),
-                      "PORT",
-                      port,
-                      65535);
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("Given `%s' option is out of range: %llu > %u\n"),
+                  "PORT",
+                  port,
+                  65535);
       GNUNET_SERVICE_stop (service);
       GNUNET_free_non_null(external_address);
       GNUNET_free_non_null(internal_address);
@@ -2113,10 +2231,9 @@ libgnunet_plugin_transport_udp_init (void *cls)
 
   mtu = 1240;
   if (mtu < 1200)
-    GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
-                     "udp",
-                     _("MTU %llu for `%s' is probably too low!\n"), mtu,
-                     "UDP");
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _("MTU %llu for `%s' is probably too low!\n"), mtu,
+                "UDP");
 
   plugin = GNUNET_malloc (sizeof (struct Plugin));
   plugin->external_address = external_address;
@@ -2138,6 +2255,10 @@ libgnunet_plugin_transport_udp_init (void *cls)
 
   plugin->service = service;
 
+  GNUNET_CONFIGURATION_get_value_string(env->cfg, "transport-udp", "BINDTO", &plugin->bind_address);
+
+  GNUNET_CONFIGURATION_get_value_string(env->cfg, "transport-udp", "BINDTO6", &plugin->bind6_address);
+
   if (plugin->behind_nat == GNUNET_NO)
     {
       GNUNET_OS_network_interfaces_list (&process_interfaces, plugin);
@@ -2156,6 +2277,8 @@ libgnunet_plugin_transport_udp_init (void *cls)
       plugin->env->notify_address (plugin->env->cls,
                                   "udp",
                                   &v4_address, sizeof(v4_address), GNUNET_TIME_UNIT_FOREVER_REL);
+      add_to_address_list (plugin, &v4_address.ipv4_addr, sizeof (uint32_t));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Notifying plugin of address %s:0\n", plugin->external_address);
     }
   else if ((plugin->external_address != NULL) && (inet_pton(AF_INET, plugin->external_address, &v4_address.ipv4_addr) == 1))
     {
@@ -2163,12 +2286,13 @@ libgnunet_plugin_transport_udp_init (void *cls)
       plugin->env->notify_address (plugin->env->cls,
                                   "udp",
                                   &v4_address, sizeof(v4_address), GNUNET_TIME_UNIT_FOREVER_REL);
+      add_to_address_list (plugin, &v4_address.ipv4_addr, sizeof (uint32_t));
     }
 
   sockets_created = udp_transport_server_start (plugin);
-
-  GNUNET_assert (sockets_created == 1);
-
+  if (sockets_created == 0)
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+               _("Failed to open UDP sockets\n"));
   return api;
 }