-indentation
[oweals/gnunet.git] / src / transport / plugin_transport_unix.c
index 6efb423fbddb39546aed5b24d3bd1b18e4b47ad5..03c38f4e163a07676804c89f8187382734c53fa6 100644 (file)
@@ -27,8 +27,8 @@
  * @author Nathan Evans
  */
 #include "platform.h"
-#include "gnunet_hello_lib.h"
 #include "gnunet_util_lib.h"
+#include "gnunet_hello_lib.h"
 #include "gnunet_protocols.h"
 #include "gnunet_statistics_service.h"
 #include "gnunet_transport_service.h"
 
 #define PLUGIN_NAME "unix"
 
+enum UNIX_ADDRESS_OPTIONS
+{
+  UNIX_OPTIONS_NONE = 0,
+  UNIX_OPTIONS_USE_ABSTRACT_SOCKETS = 1
+};
+
+
 /**
  * How long until we give up on transmitting the welcome message?
  */
 #define HOSTNAME_RESOLVE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
 
-/**
- * Default "port" to use, if configuration does not specify.
- * Essentially just a number appended to the UNIX path.
- */
-#define UNIX_NAT_DEFAULT_PORT 22086
-
-
 #define LOG(kind,...) GNUNET_log_from (kind, "transport-unix",__VA_ARGS__)
 
 
@@ -64,9 +64,9 @@ GNUNET_NETWORK_STRUCT_BEGIN
 
 struct UnixAddress
 {
-       uint32_t options GNUNET_PACKED;
+  uint32_t options GNUNET_PACKED;
 
-       uint32_t addrlen GNUNET_PACKED;
+  uint32_t addrlen GNUNET_PACKED;
 };
 
 
@@ -88,12 +88,6 @@ struct UNIXMessage
 };
 
 GNUNET_NETWORK_STRUCT_END
-
-/**
- * Address options
- */
-static uint32_t myoptions;
-
 /**
  * Handle for a session.
  */
@@ -103,9 +97,7 @@ struct Session
 
   struct Plugin * plugin;
 
-  struct UnixAddress *addr;
-
-  size_t addrlen;
+  struct GNUNET_HELLO_Address *address;
 
   /**
    * Session timeout task
@@ -274,7 +266,7 @@ struct Plugin
   /**
    * Sessions
    */
-  struct GNUNET_CONTAINER_MultiHashMap *session_map;
+  struct GNUNET_CONTAINER_MultiPeerMap *session_map;
 
   /**
    * FD Read set
@@ -306,6 +298,12 @@ struct Plugin
    */
   struct UNIX_Sock_Info unix_sock;
 
+  /**
+   * Address options in HBO
+   */
+  uint32_t myoptions;
+
+
   /**
    * ATS network
    */
@@ -318,11 +316,7 @@ struct Plugin
    */
   int with_ws;
 
-  /**
-   * Integer to append to unix domain socket.
-   */
-  uint16_t port;
-
+  int abstract;
 };
 
 
@@ -346,6 +340,31 @@ reschedule_session_timeout (struct Session *s);
 static void
 unix_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
+
+static struct sockaddr_un *
+unix_address_to_sockaddr (const char *unixpath,
+                          socklen_t *sock_len)
+{
+  struct sockaddr_un *un;
+  size_t slen;
+
+  GNUNET_assert (0 < strlen (unixpath));        /* sanity check */
+  un = GNUNET_new (struct sockaddr_un);
+  un->sun_family = AF_UNIX;
+  slen = strlen (unixpath);
+  if (slen >= sizeof (un->sun_path))
+    slen = sizeof (un->sun_path) - 1;
+  memcpy (un->sun_path, unixpath, slen);
+  un->sun_path[slen] = '\0';
+  slen = sizeof (struct sockaddr_un);
+#if HAVE_SOCKADDR_IN_SIN_LEN
+  un->sun_len = (u_char) slen;
+#endif
+  (*sock_len) = slen;
+  return un;
+}
+
+
 /**
  * Function called for a quick conversion of the binary address to
  * a numeric address.  Note that the caller must not free the
@@ -354,11 +373,60 @@ unix_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
  *
  * @param cls closure
  * @param addr binary address
- * @param addrlen length of the address
+ * @param addrlen length of the @a addr
  * @return string representing the same address
  */
 static const char *
-unix_address_to_string (void *cls, const void *addr, size_t addrlen);
+unix_address_to_string (void *cls,
+                        const void *addr,
+                        size_t addrlen)
+{
+  static char rbuf[1024];
+  struct UnixAddress *ua = (struct UnixAddress *) addr;
+  char *addrstr;
+  size_t addr_str_len;
+  unsigned int off;
+
+  if ((NULL == addr) || (sizeof (struct UnixAddress) > addrlen))
+  {
+    GNUNET_break(0);
+    return NULL;
+  }
+  addrstr = (char *) &ua[1];
+  addr_str_len = ntohl (ua->addrlen);
+
+  if (addr_str_len != addrlen - sizeof(struct UnixAddress))
+  {
+    GNUNET_break(0);
+    return NULL;
+  }
+
+  if ('\0' != addrstr[addr_str_len - 1])
+  {
+    GNUNET_break(0);
+    return NULL;
+  }
+  if (strlen (addrstr) + 1 != addr_str_len)
+  {
+    GNUNET_break(0);
+    return NULL;
+  }
+
+  off = 0;
+  if ('\0' == addrstr[0])
+    off++;
+  memset (rbuf, 0, sizeof (rbuf));
+  GNUNET_snprintf (rbuf,
+                   sizeof (rbuf) - 1,
+                   "%s.%u.%s%.*s",
+                   PLUGIN_NAME,
+                   ntohl (ua->options),
+                   (off == 1) ? "@" : "",
+                   (int) (addr_str_len - off),
+                   &addrstr[off]);
+  return rbuf;
+}
+
 
 /**
  * Re-schedule the main 'select' callback (unix_plugin_select)
@@ -398,21 +466,16 @@ reschedule_select (struct Plugin * plugin)
 
 
 /**
- * Closure to 'lookup_session_it'.
+ * Closure to #lookup_session_it.
  */
 struct LookupCtx
 {
   /**
    * Location to store the session, if found.
    */
-  struct Session *s;
-
-  /**
-   * Address we are looking for.
-   */
-  const struct UnixAddress *ua;
+  struct Session *res;
 
-  size_t ua_len;
+  struct GNUNET_HELLO_Address *address;
 };
 
 
@@ -422,22 +485,19 @@ struct LookupCtx
  * @param cls the 'struct LookupCtx'
  * @param key peer we are looking for (unused)
  * @param value a session
- * @return GNUNET_YES if not found (continue looking), GNUNET_NO on success
+ * @return #GNUNET_YES if not found (continue looking), #GNUNET_NO on success
  */
-static int 
+static int
 lookup_session_it (void *cls,
-                  const struct GNUNET_HashCode * key,
+                  const struct GNUNET_PeerIdentity * key,
                   void *value)
 {
   struct LookupCtx *lctx = cls;
-  struct Session *t = value;
-
-  if (t->addrlen != lctx->ua_len)
-    return GNUNET_YES;
+  struct Session *s = value;
 
-  if (0 == memcmp (&t->addr, lctx->ua, lctx->ua_len))
+  if (0 == GNUNET_HELLO_address_cmp (lctx->address, s->address))
   {
-    lctx->s = t;
+    lctx->res = s;
     return GNUNET_NO;
   }
   return GNUNET_YES;
@@ -448,28 +508,21 @@ lookup_session_it (void *cls,
  * Find an existing session by address.
  *
  * @param plugin the plugin
- * @param sender for which peer should the session be?
- * @param ua address to look for
- * @param ua_len length of the address
+ * @param address the address to find
  * @return NULL if session was not found
  */
 static struct Session *
-lookup_session (struct Plugin *plugin, 
-               const struct GNUNET_PeerIdentity *sender, 
-               const struct UnixAddress *ua, size_t ua_len)
+lookup_session (struct Plugin *plugin,
+                struct GNUNET_HELLO_Address *address)
 {
   struct LookupCtx lctx;
 
-  GNUNET_assert (NULL != plugin);
-  GNUNET_assert (NULL != sender);
-  GNUNET_assert (NULL != ua);
-  lctx.s = NULL;
-  lctx.ua = ua;
-  lctx.ua_len = ua_len;
-  GNUNET_CONTAINER_multihashmap_get_multiple (plugin->session_map, 
-                                             &sender->hashPubKey,
+  lctx.address = address;
+  lctx.res = NULL;
+  GNUNET_CONTAINER_multipeermap_get_multiple (plugin->session_map,
+                                             &address->peer,
                                              &lookup_session_it, &lctx);
-  return lctx.s;
+  return lctx.res;
 }
 
 
@@ -478,21 +531,26 @@ lookup_session (struct Plugin *plugin,
  * to close a session due to a disconnect or failure to
  * establish a connection.
  *
+ * @param cls closure with the `struct Plugin`
  * @param s session to close down
+ * @return #GNUNET_OK on success
  */
-static void
-disconnect_session (struct Session *s)
+static int
+unix_session_disconnect (void *cls,
+                         struct Session *s)
 {
-  struct Plugin *plugin = s->plugin;
+  struct Plugin *plugin = cls;
   struct UNIXMessageWrapper *msgw;
   struct UNIXMessageWrapper *next;
   int removed;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, 
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Disconnecting session for peer `%s' `%s'\n",
-       GNUNET_i2s (&s->target), 
-       s->addr);
-  plugin->env->session_end (plugin->env->cls, &s->target, s);
+       GNUNET_i2s (&s->target),
+       unix_address_to_string (NULL,
+                               s->address->address,
+                               s->address->address_length));
+  plugin->env->session_end (plugin->env->cls, s->address, s);
   removed = GNUNET_NO;
   next = plugin->msg_head;
   while (NULL != next)
@@ -507,15 +565,15 @@ disconnect_session (struct Session *s)
                   msgw->payload, 0);
     GNUNET_free (msgw->msg);
     GNUNET_free (msgw);
-    removed = GNUNET_YES;    
+    removed = GNUNET_YES;
   }
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (plugin->session_map, 
-                                                      &s->target.hashPubKey, 
+                 GNUNET_CONTAINER_multipeermap_remove (plugin->session_map,
+                                                      &s->target,
                                                       s));
   GNUNET_STATISTICS_set (plugin->env->stats,
                         "# UNIX sessions active",
-                        GNUNET_CONTAINER_multihashmap_size (plugin->session_map),
+                        GNUNET_CONTAINER_multipeermap_size (plugin->session_map),
                         GNUNET_NO);
   if ((GNUNET_YES == removed) && (NULL == plugin->msg_head))
     reschedule_select (plugin);
@@ -524,7 +582,24 @@ disconnect_session (struct Session *s)
     GNUNET_SCHEDULER_cancel (s->timeout_task);
     s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
   }
+  GNUNET_HELLO_address_free (s->address);
   GNUNET_free (s);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function that is called to get the keepalive factor.
+ * GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to
+ * calculate the interval between keepalive packets.
+ *
+ * @param cls closure with the `struct Plugin`
+ * @return keepalive factor
+ */
+static unsigned int
+unix_query_keepalive_factor (void *cls)
+{
+  return 3;
 }
 
 
@@ -540,13 +615,13 @@ disconnect_session (struct Session *s)
  * @param priority how important is the message (ignored by UNIX)
  * @param timeout when should we time out (give up) if we can not transmit?
  * @param addr the addr to send the message to, needs to be a sockaddr for us
- * @param addrlen the len of addr
+ * @param addrlen the len of @a addr
  * @param payload bytes payload to send
  * @param cont continuation to call once the message has
  *        been transmitted (or if the transport is ready
  *        for the next transmission call; or if the
  *        peer disconnected...)
- * @param cont_cls closure for cont
+ * @param cont_cls closure for @a cont
  * @return on success the number of bytes written, RETRY for retry, -1 on errors
  */
 static ssize_t
@@ -563,12 +638,9 @@ unix_real_send (void *cls,
 {
   struct Plugin *plugin = cls;
   ssize_t sent;
-  const void *sb;
-  size_t sbs;
-  struct sockaddr_un un;
-  size_t slen;
-  const char *unix_path;
-
+  struct sockaddr_un *un;
+  socklen_t un_len;
+  const char *unixpath;
 
   GNUNET_assert (NULL != plugin);
   if (NULL == send_handle)
@@ -583,35 +655,31 @@ unix_real_send (void *cls,
   }
 
   /* Prepare address */
-  unix_path = (const char *)  &addr[1];
-  memset (&un, 0, sizeof (un));
-  un.sun_family = AF_UNIX;
-  slen =  strlen (unix_path);
-  if (slen >= sizeof (un.sun_path))
-    slen = sizeof (un.sun_path) - 1;
-  GNUNET_assert (slen < sizeof (un.sun_path));
-  memcpy (un.sun_path, unix_path, slen);
-  un.sun_path[slen] = '\0';
-  slen = sizeof (struct sockaddr_un);
-#if LINUX
-  un.sun_path[0] = '\0';
-#endif
-#if HAVE_SOCKADDR_IN_SIN_LEN
-  un.sun_len = (u_char) slen;
-#endif
-  sb = (struct sockaddr *) &un;
-  sbs = slen;
+  unixpath = (const char *)  &addr[1];
+  if (NULL == (un = unix_address_to_sockaddr (unixpath,
+                                              &un_len)))
+  {
+    GNUNET_break (0);
+    return -1;
+  }
 
+  if ((GNUNET_YES == plugin->abstract) &&
+      (0 != (UNIX_OPTIONS_USE_ABSTRACT_SOCKETS & ntohl(addr->options) )) )
+  {
+    un->sun_path[0] = '\0';
+  }
 resend:
   /* Send the data */
-  sent = 0;
-  sent = GNUNET_NETWORK_socket_sendto (send_handle, msgbuf, msgbuf_size, sb, sbs);
-
+  sent = GNUNET_NETWORK_socket_sendto (send_handle, msgbuf, msgbuf_size,
+      (const struct sockaddr *) un, un_len);
   if (GNUNET_SYSERR == sent)
   {
     if ( (EAGAIN == errno) ||
         (ENOBUFS == errno) )
+    {
+      GNUNET_free (un);
       return RETRY; /* We have to retry later  */
+    }
     if (EMSGSIZE == errno)
     {
       socklen_t size = 0;
@@ -634,6 +702,7 @@ resend:
         {
           /* Could not increase buffer size: error, no retry */
           GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsockopt");
+          GNUNET_free (un);
           return GNUNET_SYSERR;
         }
       }
@@ -642,6 +711,7 @@ resend:
         /* Buffer is bigger than message:  error, no retry
          * This should never happen!*/
         GNUNET_break (0);
+        GNUNET_free (un);
         return GNUNET_SYSERR;
       }
     }
@@ -649,10 +719,11 @@ resend:
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "UNIX transmit %u-byte message to %s (%d: %s)\n",
-       (unsigned int) msgbuf_size, 
-       GNUNET_a2s (sb, sbs), 
+       (unsigned int) msgbuf_size,
+       GNUNET_a2s ((const struct sockaddr *)un, un_len),
        (int) sent,
        (sent < 0) ? STRERROR (errno) : "ok");
+  GNUNET_free (un);
   return sent;
 }
 
@@ -661,7 +732,7 @@ resend:
  * Closure for 'get_session_it'.
  */
 struct GetSessionIteratorContext
-{ 
+{
   /**
    * Location to store the session, if found.
    */
@@ -670,12 +741,7 @@ struct GetSessionIteratorContext
   /**
    * Address information.
    */
-  const char *address;
-
-  /**
-   * Number of bytes in 'address'
-   */
-  size_t addrlen;
+  const struct GNUNET_HELLO_Address *address;
 };
 
 
@@ -685,18 +751,17 @@ struct GetSessionIteratorContext
  * @param cls the 'struct LookupCtx'
  * @param key peer we are looking for (unused)
  * @param value a session
- * @return GNUNET_YES if not found (continue looking), GNUNET_NO on success
+ * @return #GNUNET_YES if not found (continue looking), #GNUNET_NO on success
  */
 static int
-get_session_it (void *cls, 
-               const struct GNUNET_HashCode *key, 
+get_session_it (void *cls,
+               const struct GNUNET_PeerIdentity *key,
                void *value)
 {
   struct GetSessionIteratorContext *gsi = cls;
   struct Session *s = value;
 
-  if ( (gsi->addrlen == s->addrlen) &&
-       (0 == memcmp (gsi->address, s->addr, s->addrlen)) )
+  if (0 == GNUNET_HELLO_address_cmp(s->address, gsi->address))
   {
     gsi->res = s;
     return GNUNET_NO;
@@ -712,32 +777,34 @@ get_session_it (void *cls,
  * @param tc scheduler context
  */
 static void
-session_timeout (void *cls, 
+session_timeout (void *cls,
                 const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Session *s = cls;
-  
+
   s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Session %p was idle for %s, disconnecting\n",
        s,
        GNUNET_STRINGS_relative_time_to_string (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
                                               GNUNET_YES));
-  disconnect_session (s);
+  unix_session_disconnect (s->plugin, s);
 }
 
+
 /**
  * Function obtain the network type for a session
  *
  * @param cls closure ('struct Plugin*')
  * @param session the session
- * @return the network type in HBO or GNUNET_SYSERR
+ * @return the network type in HBO or #GNUNET_SYSERR
  */
-int unix_get_network (void *cls,
-                     void *session)
+static enum GNUNET_ATS_Network_Type
+unix_get_network (void *cls,
+                 struct Session *session)
 {
-       GNUNET_assert (NULL != session);
-       return GNUNET_ATS_NET_LOOPBACK;
+  GNUNET_assert (NULL != session);
+  return GNUNET_ATS_NET_LOOPBACK;
 }
 
 
@@ -759,6 +826,7 @@ unix_plugin_get_session (void *cls,
   struct UnixAddress *ua;
   char * addrstr;
   uint32_t addr_str_len;
+  uint32_t addr_option;
 
   GNUNET_assert (NULL != plugin);
   GNUNET_assert (NULL != address);
@@ -770,14 +838,21 @@ unix_plugin_get_session (void *cls,
     GNUNET_break (0);
     return NULL;
   }
-       addrstr = (char *) &ua[1];
-       addr_str_len = ntohl (ua->addrlen);
-       if (addr_str_len != address->address_length - sizeof (struct UnixAddress))
+  addrstr = (char *) &ua[1];
+  addr_str_len = ntohl (ua->addrlen);
+  addr_option = ntohl (ua->options);
+
+  if ( (0 != (UNIX_OPTIONS_USE_ABSTRACT_SOCKETS & addr_option)) &&
+    (GNUNET_NO == plugin->abstract))
   {
-               /* This can be a legacy address */
     return NULL;
   }
 
+  if (addr_str_len != address->address_length - sizeof (struct UnixAddress))
+  {
+    return NULL; /* This can be a legacy address */
+  }
+
   if ('\0' != addrstr[addr_str_len - 1])
   {
     GNUNET_break (0);
@@ -790,43 +865,59 @@ unix_plugin_get_session (void *cls,
   }
 
   /* Check if already existing */
-  gsi.address = (const char *) address->address;
-  gsi.addrlen = address->address_length;
+  gsi.address = address;
   gsi.res = NULL;
-  GNUNET_CONTAINER_multihashmap_get_multiple (plugin->session_map, 
-                                             &address->peer.hashPubKey, 
+  GNUNET_CONTAINER_multipeermap_get_multiple (plugin->session_map,
+                                             &address->peer,
                                              &get_session_it, &gsi);
   if (NULL != gsi.res)
   {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, 
-        "Found existing session\n");
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Found existing session %p for address `%s'\n",
+        gsi.res,
+        unix_address_to_string (NULL, address->address, address->address_length));
     return gsi.res;
   }
 
   /* create a new session */
-  s = GNUNET_malloc (sizeof (struct Session) + address->address_length);
-  s->addr = (struct UnixAddress *) &s[1];
-  s->addrlen = address->address_length;
+  s = GNUNET_new (struct Session);
+  s->target = address->peer;
+  s->address = GNUNET_HELLO_address_copy (address);
   s->plugin = plugin;
-  memcpy (s->addr, address->address, address->address_length);
-  memcpy (&s->target, &address->peer, sizeof (struct GNUNET_PeerIdentity));
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == s->timeout_task);
   s->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
                                                  &session_timeout,
                                                  s);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Creating a new session %p for address `%s'\n",
-       s,  unix_address_to_string (NULL, address->address, address->address_length));
-  (void) GNUNET_CONTAINER_multihashmap_put (plugin->session_map,
-                                           &address->peer.hashPubKey, s,
+       s,
+       unix_address_to_string (NULL,
+                               address->address,
+                               address->address_length));
+  (void) GNUNET_CONTAINER_multipeermap_put (plugin->session_map,
+                                           &address->peer, s,
                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
   GNUNET_STATISTICS_set (plugin->env->stats,
                         "# UNIX sessions active",
-                        GNUNET_CONTAINER_multihashmap_size (plugin->session_map),
+                        GNUNET_CONTAINER_multipeermap_size (plugin->session_map),
                         GNUNET_NO);
   return s;
 }
 
+static void
+unix_plugin_update_session_timeout (void *cls,
+                                  const struct GNUNET_PeerIdentity *peer,
+                                  struct Session *session)
+{
+  struct Plugin *plugin = cls;
+
+  if (GNUNET_OK !=
+      GNUNET_CONTAINER_multipeermap_contains_value (plugin->session_map,
+                                                    &session->target,
+                                                    session))
+    return;
+  reschedule_session_timeout (session);
+}
 
 /**
  * Function that can be used by the transport service to transmit
@@ -839,7 +930,7 @@ unix_plugin_get_session (void *cls,
  * @param cls closure
  * @param session which session must be used
  * @param msgbuf the message to transmit
- * @param msgbuf_size number of bytes in 'msgbuf'
+ * @param msgbuf_size number of bytes in @a msgbuf
  * @param priority how important is the message (most plugins will
  *                 ignore message priority and just FIFO)
  * @param to how long to wait at most for the transmission (does not
@@ -850,7 +941,7 @@ unix_plugin_get_session (void *cls,
  *        been transmitted (or if the transport is ready
  *        for the next transmission call; or if the
  *        peer disconnected...); can be NULL
- * @param cont_cls closure for cont
+ * @param cont_cls closure for @a cont
  * @return number of bytes used (on the physical network, with overheads);
  *         -1 on hard errors (i.e. address invalid); 0 is a legal value
  *         and does NOT mean that the message was not transmitted (DV)
@@ -867,27 +958,28 @@ unix_plugin_send (void *cls,
   struct UNIXMessageWrapper *wrapper;
   struct UNIXMessage *message;
   int ssize;
-  
-  GNUNET_assert (NULL != plugin);
-  GNUNET_assert (NULL != session);
 
-  if (GNUNET_OK != 
-      GNUNET_CONTAINER_multihashmap_contains_value (plugin->session_map,
-                                                   &session->target.hashPubKey,
+  if (GNUNET_OK !=
+      GNUNET_CONTAINER_multipeermap_contains_value (plugin->session_map,
+                                                   &session->target,
                                                    session))
   {
-    LOG (GNUNET_ERROR_TYPE_ERROR, 
+    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Invalid session for peer `%s' `%s'\n",
         GNUNET_i2s (&session->target),
-        (const char *) session->addr);
+        unix_address_to_string(NULL,
+                                session->address->address,
+                                session->address->address_length));
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
-  LOG (GNUNET_ERROR_TYPE_DEBUG, 
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Sending %u bytes with session for peer `%s' `%s'\n",
        msgbuf_size,
        GNUNET_i2s (&session->target),
-       (const char *) session->addr);
+       unix_address_to_string (NULL,
+                               session->address->address,
+                               session->address->address_length));
   ssize = sizeof (struct UNIXMessage) + msgbuf_size;
   message = GNUNET_malloc (sizeof (struct UNIXMessage) + msgbuf_size);
   message->header.size = htons (ssize);
@@ -895,8 +987,8 @@ unix_plugin_send (void *cls,
   memcpy (&message->sender, plugin->env->my_identity,
           sizeof (struct GNUNET_PeerIdentity));
   memcpy (&message[1], msgbuf, msgbuf_size);
-  reschedule_session_timeout (session);
-  wrapper = GNUNET_malloc (sizeof (struct UNIXMessageWrapper));
+
+  wrapper = GNUNET_new (struct UNIXMessageWrapper);
   wrapper->msg = message;
   wrapper->msgsize = ssize;
   wrapper->payload = msgbuf_size;
@@ -905,13 +997,13 @@ unix_plugin_send (void *cls,
   wrapper->cont = cont;
   wrapper->cont_cls = cont_cls;
   wrapper->session = session;
-  GNUNET_CONTAINER_DLL_insert (plugin->msg_head, 
+  GNUNET_CONTAINER_DLL_insert (plugin->msg_head,
                               plugin->msg_tail,
                               wrapper);
   plugin->bytes_in_queue += ssize;
   GNUNET_STATISTICS_set (plugin->env->stats,
                         "# bytes currently in UNIX buffers",
-                        plugin->bytes_in_queue, 
+                        plugin->bytes_in_queue,
                         GNUNET_NO);
   if (GNUNET_NO == plugin->with_ws)
     reschedule_select (plugin);
@@ -926,7 +1018,7 @@ unix_plugin_send (void *cls,
  * @param sender from which peer the message was received
  * @param currhdr pointer to the header of the message
  * @param ua address to look for
- * @param ua_len length of the address
+ * @param ua_len length of the address @a ua
  */
 static void
 unix_demultiplexer (struct Plugin *plugin, struct GNUNET_PeerIdentity *sender,
@@ -934,44 +1026,35 @@ unix_demultiplexer (struct Plugin *plugin, struct GNUNET_PeerIdentity *sender,
                     const struct UnixAddress *ua, size_t ua_len)
 {
   struct Session *s = NULL;
-  struct GNUNET_HELLO_Address * addr;
+  struct GNUNET_HELLO_Address *address;
 
   GNUNET_break (ntohl(plugin->ats_network.value) != GNUNET_ATS_NET_UNSPECIFIED);
-
   GNUNET_assert (ua_len >= sizeof (struct UnixAddress));
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG, 
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Received message from %s\n",
-       unix_address_to_string(NULL, ua, ua_len));
+       unix_address_to_string (NULL, ua, ua_len));
   GNUNET_STATISTICS_update (plugin->env->stats,
                            "# bytes received via UNIX",
                            ntohs (currhdr->size),
                            GNUNET_NO);
 
-  addr = GNUNET_HELLO_address_allocate (sender,
-                                       "unix",
-                                       ua,
-                                       ua_len);
-  s = lookup_session (plugin, sender, ua, ua_len);
+  /* Look for existing session */
+  address = GNUNET_HELLO_address_allocate (sender, PLUGIN_NAME, ua, ua_len,
+      GNUNET_HELLO_ADDRESS_INFO_NONE); /* UNIX does not have "inbound" sessions */
+  s = lookup_session (plugin, address);
+
   if (NULL == s)
   {
-    s = unix_plugin_get_session (plugin, addr);
-    /* Notify transport and ATS about new session */
-    plugin->env->session_start (NULL, sender,
-               PLUGIN_NAME, ua, ua_len, s, &plugin->ats_network, 1);
+    s = unix_plugin_get_session (plugin, address);
+    /* Notify transport and ATS about new inbound session */
+    plugin->env->session_start (NULL, s->address, s, &plugin->ats_network, 1);
   }
+  GNUNET_HELLO_address_free (address);
   reschedule_session_timeout (s);
 
-  plugin->env->receive (plugin->env->cls, sender, currhdr,
-                        s, (const char *) ua, ua_len);
-
-  plugin->env->update_address_metrics (plugin->env->cls,
-                                      sender,
-                                      (const char *) ua, ua_len,
-                                      s,
+  plugin->env->receive (plugin->env->cls, s->address, s, currhdr);
+  plugin->env->update_address_metrics (plugin->env->cls, s->address, s,
                                       &plugin->ats_network, 1);
-
-  GNUNET_free (addr);
 }
 
 
@@ -992,6 +1075,7 @@ unix_plugin_select_read (struct Plugin *plugin)
   ssize_t ret;
   int offset;
   int tsize;
+  int is_abstract;
   char *msgbuf;
   const struct GNUNET_MessageHeader *currhdr;
   uint16_t csize;
@@ -1014,25 +1098,35 @@ unix_plugin_select_read (struct Plugin *plugin)
   }
   else
   {
-#if LINUX
-    un.sun_path[0] = '/';
-#endif
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Read %d bytes from socket %s\n", ret,
-                &un.sun_path[0]);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+        "Read %d bytes from socket %s\n",
+        (int) ret,
+        un.sun_path);
   }
 
   GNUNET_assert (AF_UNIX == (un.sun_family));
-  ua_len = sizeof (struct UnixAddress) + strlen (&un.sun_path[0]) +1;
+  is_abstract = GNUNET_NO;
+  if ('\0' == un.sun_path[0])
+  {
+    un.sun_path[0] = '@';
+    is_abstract = GNUNET_YES;
+  }
+
+  ua_len = sizeof (struct UnixAddress) + strlen (un.sun_path) + 1;
   ua = GNUNET_malloc (ua_len);
   ua->addrlen = htonl (strlen (&un.sun_path[0]) +1);
-  ua->options = htonl (0);
-  memcpy (&ua[1], &un.sun_path[0], strlen (&un.sun_path[0]) +1);
+  memcpy (&ua[1], &un.sun_path[0], strlen (un.sun_path) + 1);
+  if (is_abstract)
+    ua->options = htonl(UNIX_OPTIONS_USE_ABSTRACT_SOCKETS);
+  else
+    ua->options = htonl(UNIX_OPTIONS_NONE);
 
   msg = (struct UNIXMessage *) buf;
   csize = ntohs (msg->header.size);
   if ((csize < sizeof (struct UNIXMessage)) || (csize > ret))
   {
     GNUNET_break_op (0);
+    GNUNET_free (ua);
     return;
   }
   msgbuf = (char *) &msg[1];
@@ -1069,29 +1163,29 @@ unix_plugin_select_write (struct Plugin *plugin)
 
   while (NULL != (msgw = plugin->msg_tail))
   {
-    if (GNUNET_TIME_absolute_get_remaining (msgw->timeout).rel_value > 0)
+    if (GNUNET_TIME_absolute_get_remaining (msgw->timeout).rel_value_us > 0)
       break; /* Message is ready for sending */
     /* Message has a timeout */
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-        "Timeout for message with %u bytes \n", 
+        "Timeout for message with %u bytes \n",
         (unsigned int) msgw->msgsize);
     GNUNET_CONTAINER_DLL_remove (plugin->msg_head, plugin->msg_tail, msgw);
     plugin->bytes_in_queue -= msgw->msgsize;
-    GNUNET_STATISTICS_set (plugin->env->stats, 
+    GNUNET_STATISTICS_set (plugin->env->stats,
                           "# bytes currently in UNIX buffers",
-                          plugin->bytes_in_queue, GNUNET_NO);    
+                          plugin->bytes_in_queue, GNUNET_NO);
     GNUNET_STATISTICS_update (plugin->env->stats,
                              "# UNIX bytes discarded",
                              msgw->msgsize,
                              GNUNET_NO);
     if (NULL != msgw->cont)
       msgw->cont (msgw->cont_cls,
-                 &msgw->session->target, 
-                 GNUNET_SYSERR, 
-                 msgw->payload, 
-                 0);    
+                 &msgw->session->target,
+                 GNUNET_SYSERR,
+                 msgw->payload,
+                 0);
     GNUNET_free (msgw->msg);
-    GNUNET_free (msgw);  
+    GNUNET_free (msgw);
   }
   if (NULL == msgw)
     return; /* Nothing to send at the moment */
@@ -1103,8 +1197,8 @@ unix_plugin_select_write (struct Plugin *plugin)
                          msgw->msgsize,
                          msgw->priority,
                          msgw->timeout,
-                         msgw->session->addr,
-                         msgw->session->addrlen,
+                         msgw->session->address->address,
+                         msgw->session->address->address_length,
                          msgw->payload,
                          msgw->cont, msgw->cont_cls);
 
@@ -1125,7 +1219,7 @@ unix_plugin_select_write (struct Plugin *plugin)
 
     GNUNET_assert (plugin->bytes_in_queue >= msgw->msgsize);
     plugin->bytes_in_queue -= msgw->msgsize;
-    GNUNET_STATISTICS_set (plugin->env->stats, 
+    GNUNET_STATISTICS_set (plugin->env->stats,
                           "# bytes currently in UNIX buffers",
                           plugin->bytes_in_queue, GNUNET_NO);
     GNUNET_STATISTICS_update (plugin->env->stats,
@@ -1139,9 +1233,9 @@ unix_plugin_select_write (struct Plugin *plugin)
   }
   /* successfully sent bytes */
   GNUNET_break (sent > 0);
-  GNUNET_CONTAINER_DLL_remove (plugin->msg_head, 
-                              plugin->msg_tail, 
-                              msgw); 
+  GNUNET_CONTAINER_DLL_remove (plugin->msg_head,
+                              plugin->msg_tail,
+                              msgw);
   GNUNET_assert (plugin->bytes_in_queue >= msgw->msgsize);
   plugin->bytes_in_queue -= msgw->msgsize;
   GNUNET_STATISTICS_set (plugin->env->stats,
@@ -1151,12 +1245,12 @@ unix_plugin_select_write (struct Plugin *plugin)
   GNUNET_STATISTICS_update (plugin->env->stats,
                            "# bytes transmitted via UNIX",
                            msgw->msgsize,
-                           GNUNET_NO);  
+                           GNUNET_NO);
   if (NULL != msgw->cont)
-    msgw->cont (msgw->cont_cls, &msgw->session->target, 
+    msgw->cont (msgw->cont_cls, &msgw->session->target,
                GNUNET_OK,
-               msgw->payload, 
-               msgw->msgsize);  
+               msgw->payload,
+               msgw->msgsize);
   GNUNET_free (msgw->msg);
   GNUNET_free (msgw);
 }
@@ -1204,36 +1298,23 @@ unix_plugin_select (void *cls,
  * Create a slew of UNIX 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
+ * @return number of sockets created or #GNUNET_SYSERR on error
  */
 static int
 unix_transport_server_start (void *cls)
 {
   struct Plugin *plugin = cls;
-  struct sockaddr *serverAddr;
-  socklen_t addrlen;
-  struct sockaddr_un un;
-  size_t slen;
+  struct sockaddr_un *un;
+  socklen_t un_len;
 
-  memset (&un, 0, sizeof (un));
-  un.sun_family = AF_UNIX;
-  slen = strlen (plugin->unix_socket_path) + 1;
-  if (slen >= sizeof (un.sun_path))
-    slen = sizeof (un.sun_path) - 1;
-
-  memcpy (un.sun_path, plugin->unix_socket_path, slen);
-  un.sun_path[slen] = '\0';
-  slen = sizeof (struct sockaddr_un);
-#if HAVE_SOCKADDR_IN_SIN_LEN
-  un.sun_len = (u_char) slen;
-#endif
-
-  serverAddr = (struct sockaddr *) &un;
-  addrlen = slen;
-#if LINUX
-  un.sun_path[0] = '\0';
-#endif
-  plugin->ats_network = plugin->env->get_address_type (plugin->env->cls, serverAddr, addrlen);
+  un = unix_address_to_sockaddr (plugin->unix_socket_path,
+                                 &un_len);
+  if (GNUNET_YES == plugin->abstract)
+  {
+    plugin->unix_socket_path[0] = '@';
+    un->sun_path[0] = '\0';
+  }
+  plugin->ats_network = plugin->env->get_address_type (plugin->env->cls, (const struct sockaddr *) un, un_len);
   plugin->unix_sock.desc =
       GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_DGRAM, 0);
   if (NULL == plugin->unix_sock.desc)
@@ -1241,12 +1322,25 @@ unix_transport_server_start (void *cls)
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
     return GNUNET_SYSERR;
   }
-  if (GNUNET_NETWORK_socket_bind (plugin->unix_sock.desc, serverAddr, addrlen, 0)
-      != GNUNET_OK)
+  if ('\0' != un->sun_path[0])
+  {
+    if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (un->sun_path))
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR, _("Cannot create path to `%s'\n"),
+          un->sun_path);
+      GNUNET_NETWORK_socket_close (plugin->unix_sock.desc);
+      plugin->unix_sock.desc = NULL;
+      GNUNET_free (un);
+      return GNUNET_SYSERR;
+    }
+  }
+  if (GNUNET_OK !=
+      GNUNET_NETWORK_socket_bind (plugin->unix_sock.desc, (const struct sockaddr *)  un, un_len))
   {
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
     GNUNET_NETWORK_socket_close (plugin->unix_sock.desc);
     plugin->unix_sock.desc = NULL;
+    GNUNET_free (un);
     return GNUNET_SYSERR;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Bound to `%s'\n", plugin->unix_socket_path);
@@ -1258,62 +1352,11 @@ unix_transport_server_start (void *cls)
   GNUNET_NETWORK_fdset_set (plugin->ws, plugin->unix_sock.desc);
 
   reschedule_select (plugin);
-
+  GNUNET_free (un);
   return 1;
 }
 
 
-/**
- * Function called for a quick conversion of the binary address to
- * a numeric address.  Note that the caller must not free the
- * address and that the next call to this function is allowed
- * to override the address again.
- *
- * @param cls closure
- * @param addr binary address
- * @param addrlen length of the address
- * @return string representing the same address
- */
-static const char *
-unix_address_to_string (void *cls, const void *addr, size_t addrlen)
-{
-  static char rbuf[1024];
-       struct UnixAddress *ua = (struct UnixAddress *) addr;
-       char *addrstr;
-       char *tmp;
-       size_t addr_str_len;
-
-  if ((NULL == addr) || (0 == addrlen) || (sizeof (struct UnixAddress) > addrlen))
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-       addrstr = (char *) &ua[1];
-       addr_str_len = ntohl (ua->addrlen);
-
-       if (addr_str_len != addrlen - sizeof (struct UnixAddress))
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-
-  if ('\0' != addrstr[addr_str_len - 1])
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  if (strlen (addrstr) + 1 != addr_str_len)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-
-  GNUNET_asprintf(&tmp, "%s.%u.%s", PLUGIN_NAME, ntohl (ua->options), addrstr);
-  memcpy (rbuf, tmp, strlen (tmp) + 1);
-  GNUNET_free (tmp);
-  return rbuf;
-}
-
 /**
  * Function that will be called to check if a binary address for this
  * plugin is well-formed and corresponds to an address for THIS peer
@@ -1333,10 +1376,10 @@ unix_address_to_string (void *cls, const void *addr, size_t addrlen)
 static int
 unix_check_address (void *cls, const void *addr, size_t addrlen)
 {
-       struct Plugin* plugin = cls;
-       struct UnixAddress *ua = (struct UnixAddress *) addr;
-       char *addrstr;
-       size_t addr_str_len;
+  struct Plugin* plugin = cls;
+  struct UnixAddress *ua = (struct UnixAddress *) addr;
+  char *addrstr;
+  size_t addr_str_len;
 
   if ((NULL == addr) || (0 == addrlen) || (sizeof (struct UnixAddress) > addrlen))
   {
@@ -1370,11 +1413,11 @@ unix_check_address (void *cls, const void *addr, size_t addrlen)
  * @param type name of the transport that generated the address
  * @param addr one of the addresses of the host, NULL for the last address
  *        the specific address format depends on the transport
- * @param addrlen length of the address
+ * @param addrlen length of the @a addr
  * @param numeric should (IP) addresses be displayed in numeric form?
  * @param timeout after how long should we give up?
  * @param asc function to call on each string
- * @param asc_cls closure for asc
+ * @param asc_cls closure for @a asc
  */
 static void
 unix_plugin_address_pretty_printer (void *cls, const char *type,
@@ -1384,16 +1427,18 @@ unix_plugin_address_pretty_printer (void *cls, const char *type,
                                     GNUNET_TRANSPORT_AddressStringCallback asc,
                                     void *asc_cls)
 {
-  if ((NULL != addr) && (addrlen > 0))
-  {
-    asc (asc_cls, unix_address_to_string (NULL, addr, addrlen));
-  }
+  const char *ret;
+
+  if ( (NULL != addr) && (addrlen > 0))
+    ret = unix_address_to_string (NULL,
+                                  addr,
+                                  addrlen);
   else
-  {
-    GNUNET_break (0);
-    asc (asc_cls, "<invalid UNIX address>");
-  }
-  asc (asc_cls, NULL);
+    ret = NULL;
+  asc (asc_cls,
+       ret,
+       (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
+  asc (asc_cls, NULL, GNUNET_OK);
 }
 
 
@@ -1401,19 +1446,20 @@ unix_plugin_address_pretty_printer (void *cls, const char *type,
  * Function called to convert a string address to
  * a binary address.
  *
- * @param cls closure ('struct Plugin*')
+ * @param cls closure (`struct Plugin *`)
  * @param addr string address
- * @param addrlen length of the address (strlen(addr) + '\0')
+ * @param addrlen length of the @a addr (strlen(addr) + '\0')
  * @param buf location to store the buffer
- *        If the function returns GNUNET_SYSERR, its contents are undefined.
+ *        If the function returns #GNUNET_SYSERR, its contents are undefined.
  * @param added length of created address
- * @return GNUNET_OK on success, GNUNET_SYSERR on failure
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 static int
-unix_string_to_address (void *cls, const char *addr, uint16_t addrlen,
-    void **buf, size_t *added)
+unix_string_to_address (void *cls,
+                        const char *addr, uint16_t addrlen,
+                        void **buf, size_t *added)
 {
-       struct UnixAddress *ua;
+  struct UnixAddress *ua;
   char *address;
   char *plugin;
   char *optionstr;
@@ -1424,7 +1470,7 @@ unix_string_to_address (void *cls, const char *addr, uint16_t addrlen,
   address = NULL;
   plugin = NULL;
   optionstr = NULL;
-  options = 0;
+
   if ((NULL == addr) || (addrlen == 0))
   {
     GNUNET_break (0);
@@ -1449,7 +1495,7 @@ unix_string_to_address (void *cls, const char *addr, uint16_t addrlen,
     return GNUNET_SYSERR;
   }
   optionstr[0] = '\0';
-  optionstr ++;
+  optionstr++;
   options = atol (optionstr);
   address = strchr (optionstr, '.');
   if (NULL == address)
@@ -1459,7 +1505,7 @@ unix_string_to_address (void *cls, const char *addr, uint16_t addrlen,
     return GNUNET_SYSERR;
   }
   address[0] = '\0';
-  address ++;
+  address++;
   if (0 != strcmp(plugin, PLUGIN_NAME))
   {
     GNUNET_break (0);
@@ -1491,26 +1537,32 @@ address_notification (void *cls,
                      const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
+  struct GNUNET_HELLO_Address *address;
   size_t len;
   struct UnixAddress *ua;
+  char *unix_path;
 
   len = sizeof (struct UnixAddress) + strlen (plugin->unix_socket_path) + 1;
   ua = GNUNET_malloc (len);
-  ua->options = htonl (myoptions);
+  ua->options = htonl (plugin->myoptions);
   ua->addrlen = htonl(strlen (plugin->unix_socket_path) + 1);
-  memcpy (&ua[1], plugin->unix_socket_path, strlen (plugin->unix_socket_path) + 1);
+  unix_path = (char *) &ua[1];
+  memcpy (unix_path, plugin->unix_socket_path, strlen (plugin->unix_socket_path) + 1);
 
   plugin->address_update_task = GNUNET_SCHEDULER_NO_TASK;
-  plugin->env->notify_address (plugin->env->cls, GNUNET_YES,
-                               ua, len, "unix");
+  address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+      PLUGIN_NAME, ua, len, GNUNET_HELLO_ADDRESS_INFO_NONE);
+
+  plugin->env->notify_address (plugin->env->cls, GNUNET_YES, address);
   GNUNET_free (ua);
+  GNUNET_free (address);
 }
 
 
 /**
  * Increment session timeout due to activity
  *
- * @param s session for which the timeout should be moved
+ * @param s session for which the timeout should be rescheduled
  */
 static void
 reschedule_session_timeout (struct Session *s)
@@ -1532,17 +1584,20 @@ reschedule_session_timeout (struct Session *s)
 /**
  * Function called on sessions to disconnect
  *
- * @param cls the plugin (unused)
+ * @param cls the plugin
  * @param key peer identity (unused)
- * @param value the 'struct Session' to disconnect
- * @return GNUNET_YES (always, continue to iterate)
+ * @param value the `struct Session *` to disconnect
+ * @return #GNUNET_YES (always, continue to iterate)
  */
 static int
-get_session_delete_it (void *cls, const struct GNUNET_HashCode * key, void *value)
+get_session_delete_it (void *cls,
+                      const struct GNUNET_PeerIdentity *key,
+                      void *value)
 {
+  struct Plugin *plugin = cls;
   struct Session *s = value;
 
-  disconnect_session (s);
+  unix_session_disconnect (plugin, s);
   return GNUNET_YES;
 }
 
@@ -1552,17 +1607,17 @@ get_session_delete_it (void *cls, const struct GNUNET_HashCode * key, void *valu
  *
  * @param cls closure for this call (should be handle to Plugin)
  * @param target the peeridentity of the peer to disconnect
- * @return GNUNET_OK on success, GNUNET_SYSERR if the operation failed
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the operation failed
  */
 static void
-unix_disconnect (void *cls, 
-                const struct GNUNET_PeerIdentity *target)
+unix_peer_disconnect (void *cls,
+                      const struct GNUNET_PeerIdentity *target)
 {
   struct Plugin *plugin = cls;
 
   GNUNET_assert (plugin != NULL);
-  GNUNET_CONTAINER_multihashmap_get_multiple (plugin->session_map,
-                                             &target->hashPubKey, 
+  GNUNET_CONTAINER_multipeermap_get_multiple (plugin->session_map,
+                                             target,
                                              &get_session_delete_it, plugin);
 }
 
@@ -1578,7 +1633,6 @@ void *
 libgnunet_plugin_transport_unix_init (void *cls)
 {
   struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
-  unsigned long long port;
   struct GNUNET_TRANSPORT_PluginFunctions *api;
   struct Plugin *plugin;
   int sockets_created;
@@ -1587,43 +1641,63 @@ libgnunet_plugin_transport_unix_init (void *cls)
   {
     /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
        initialze the plugin or the API */
-    api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
+    api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
     api->cls = NULL;
     api->address_pretty_printer = &unix_plugin_address_pretty_printer;
     api->address_to_string = &unix_address_to_string;
     api->string_to_address = &unix_string_to_address;
     return api;
   }
+
+  plugin = GNUNET_new (struct Plugin);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number (env->cfg, "transport-unix", "PORT",
-                                             &port))
-    port = UNIX_NAT_DEFAULT_PORT;
-  plugin = GNUNET_malloc (sizeof (struct Plugin));
-  plugin->port = port;
+      GNUNET_CONFIGURATION_get_value_filename(env->cfg, "transport-unix", "UNIXPATH",
+                                             &plugin->unix_socket_path))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _("No UNIXPATH given in configuration!\n"));
+    GNUNET_free (plugin);
+    return NULL;
+  }
+
   plugin->env = env;
-  GNUNET_asprintf (&plugin->unix_socket_path, 
-                  "/tmp/unix-plugin-sock.%d",
-                   plugin->port);
 
   /* Initialize my flags */
-  myoptions = 0;
+#ifdef LINUX
+    plugin->abstract = GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
+        "testing", "USE_ABSTRACT_SOCKETS");
+#endif
+  plugin->myoptions = UNIX_OPTIONS_NONE;
+  if (GNUNET_YES == plugin->abstract)
+  {
+    plugin->myoptions = UNIX_OPTIONS_USE_ABSTRACT_SOCKETS;
+  }
 
-  api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
+  api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
   api->cls = plugin;
 
   api->get_session = &unix_plugin_get_session;
   api->send = &unix_plugin_send;
-  api->disconnect = &unix_disconnect;
+  api->disconnect_peer = &unix_peer_disconnect;
+  api->disconnect_session = &unix_session_disconnect;
+  api->query_keepalive_factor = &unix_query_keepalive_factor;
   api->address_pretty_printer = &unix_plugin_address_pretty_printer;
   api->address_to_string = &unix_address_to_string;
   api->check_address = &unix_check_address;
   api->string_to_address = &unix_string_to_address;
   api->get_network = &unix_get_network;
+  api->update_session_timeout = &unix_plugin_update_session_timeout;
   sockets_created = unix_transport_server_start (plugin);
-  if (0 == sockets_created)
+  if ((0 == sockets_created) || (GNUNET_SYSERR == sockets_created))
+  {
     LOG (GNUNET_ERROR_TYPE_WARNING,
         _("Failed to open UNIX listen socket\n"));
-  plugin->session_map = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
+    GNUNET_free (api);
+    GNUNET_free (plugin->unix_socket_path);
+    GNUNET_free (plugin);
+    return NULL;
+  }
+  plugin->session_map = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
   plugin->address_update_task = GNUNET_SCHEDULER_add_now (&address_notification, plugin);
   return api;
 }
@@ -1640,6 +1714,7 @@ libgnunet_plugin_transport_unix_done (void *cls)
 {
   struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
   struct Plugin *plugin = api->cls;
+  struct GNUNET_HELLO_Address *address;
   struct UNIXMessageWrapper * msgw;
   struct UnixAddress *ua;
   size_t len;
@@ -1652,13 +1727,16 @@ libgnunet_plugin_transport_unix_done (void *cls)
 
   len = sizeof (struct UnixAddress) + strlen (plugin->unix_socket_path) + 1;
   ua = GNUNET_malloc (len);
-  ua->options = htonl (myoptions);
+  ua->options = htonl (plugin->myoptions);
   ua->addrlen = htonl(strlen (plugin->unix_socket_path) + 1);
   memcpy (&ua[1], plugin->unix_socket_path, strlen (plugin->unix_socket_path) + 1);
+  address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
+      PLUGIN_NAME, ua, len, GNUNET_HELLO_ADDRESS_INFO_NONE);
+  plugin->env->notify_address (plugin->env->cls, GNUNET_NO, address);
 
-  plugin->env->notify_address (plugin->env->cls, GNUNET_NO,
-                                                                                                                ua, len, "unix");
+  GNUNET_free (address);
   GNUNET_free (ua);
+
   while (NULL != (msgw = plugin->msg_head))
   {
     GNUNET_CONTAINER_DLL_remove (plugin->msg_head, plugin->msg_tail, msgw);
@@ -1686,9 +1764,9 @@ libgnunet_plugin_transport_unix_done (void *cls)
     plugin->unix_sock.desc = NULL;
     plugin->with_ws = GNUNET_NO;
   }
-  GNUNET_CONTAINER_multihashmap_iterate (plugin->session_map,
+  GNUNET_CONTAINER_multipeermap_iterate (plugin->session_map,
                                         &get_session_delete_it, plugin);
-  GNUNET_CONTAINER_multihashmap_destroy (plugin->session_map);
+  GNUNET_CONTAINER_multipeermap_destroy (plugin->session_map);
   if (NULL != plugin->rs)
     GNUNET_NETWORK_fdset_destroy (plugin->rs);
   if (NULL != plugin->ws)