/*
     This file is part of GNUnet
     Copyright (C) 2010-2014 GNUnet e.V.

     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.

     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.

     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later
 */

/**
 * @file transport/plugin_transport_unix.c
 * @brief Transport plugin using unix domain sockets (!)
 *        Clearly, can only be used locally on Unix/Linux hosts...
 *        ONLY INTENDED FOR TESTING!!!
 * @author Christian Grothoff
 * @author Nathan Evans
 */
#include "platform.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"
#include "gnunet_transport_plugin.h"
#include "transport.h"


/**
 * Return code we give on 'send' if we failed to send right now
 * but it makes sense to retry later. (Note: we might want to
 * move this to the plugin API!?).
 */
#define RETRY 0

/**
 * Name of the plugin.
 */
#define PLUGIN_NAME "unix"

/**
 * Options for UNIX Domain addresses.
 */
enum UNIX_ADDRESS_OPTIONS
{
  /**
   * No special options.
   */
  UNIX_OPTIONS_NONE = 0,

  /**
   * Linux abstract domain sockets should be used.
   */
  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)

#define LOG(kind, ...) GNUNET_log_from (kind, "transport-unix", __VA_ARGS__)


GNUNET_NETWORK_STRUCT_BEGIN

/**
 * Binary format for an UNIX Domain Socket address in GNUnet.
 */
struct UnixAddress
{
  /**
   * Options to use for the address, in NBO
   */
  uint32_t options GNUNET_PACKED;

  /**
   * Length of the address (path length), in NBO
   */
  uint32_t addrlen GNUNET_PACKED;

  /* followed by actual path */
};


/**
 * UNIX Message-Packet header.
 */
struct UNIXMessage
{
  /**
   * Message header.
   */
  struct GNUNET_MessageHeader header;

  /**
   * What is the identity of the sender (GNUNET_hash of public key)
   */
  struct GNUNET_PeerIdentity sender;
};

GNUNET_NETWORK_STRUCT_END


/**
 * Information we track for a message awaiting transmission.
 */
struct UNIXMessageWrapper
{
  /**
   * We keep messages in a doubly linked list.
   */
  struct UNIXMessageWrapper *next;

  /**
   * We keep messages in a doubly linked list.
   */
  struct UNIXMessageWrapper *prev;

  /**
   * The actual payload (allocated separately right now).
   */
  struct UNIXMessage *msg;

  /**
   * Session this message belongs to.
   */
  struct GNUNET_ATS_Session *session;

  /**
   * Function to call upon transmission.
   */
  GNUNET_TRANSPORT_TransmitContinuation cont;

  /**
   * Closure for @e cont.
   */
  void *cont_cls;

  /**
   * Timeout for this message.
   */
  struct GNUNET_TIME_Absolute timeout;

  /**
   * Number of bytes in @e msg.
   */
  size_t msgsize;

  /**
   * Number of bytes of payload encapsulated in @e msg.
   */
  size_t payload;

  /**
   * Priority of the message (ignored, just dragged along in UNIX).
   */
  unsigned int priority;
};


/**
 * Handle for a session.
 */
struct GNUNET_ATS_Session
{
  /**
   * Sessions with pending messages (!) are kept in a DLL.
   */
  struct GNUNET_ATS_Session *next;

  /**
   * Sessions with pending messages (!) are kept in a DLL.
   */
  struct GNUNET_ATS_Session *prev;

  /**
   * To whom are we talking to (set to our identity
   * if we are still waiting for the welcome message).
   *
   * FIXME: information duplicated with 'peer' in address!
   */
  struct GNUNET_PeerIdentity target;

  /**
   * Pointer to the global plugin struct.
   */
  struct Plugin *plugin;

  /**
   * Address of the other peer.
   */
  struct GNUNET_HELLO_Address *address;

  /**
   * Number of bytes we currently have in our write queue.
   */
  unsigned long long bytes_in_queue;

  /**
   * Timeout for this session.
   */
  struct GNUNET_TIME_Absolute timeout;

  /**
   * Session timeout task.
   */
  struct GNUNET_SCHEDULER_Task *timeout_task;

  /**
   * Number of messages we currently have in our write queue.
   */
  unsigned int msgs_in_queue;
};


/**
 * Encapsulation of all of the state of the plugin.
 */
struct Plugin;


/**
 * Information we keep for each of our listen sockets.
 */
struct UNIX_Sock_Info
{
  /**
   * The network handle
   */
  struct GNUNET_NETWORK_Handle *desc;
};


/**
 * Encapsulation of all of the state of the plugin.
 */
struct Plugin
{
  /**
   * ID of task used to update our addresses when one expires.
   */
  struct GNUNET_SCHEDULER_Task *address_update_task;

  /**
   * ID of read task
   */
  struct GNUNET_SCHEDULER_Task *read_task;

  /**
   * ID of write task
   */
  struct GNUNET_SCHEDULER_Task *write_task;

  /**
   * Number of bytes we currently have in our write queues.
   */
  unsigned long long bytes_in_queue;

  /**
   * Our environment.
   */
  struct GNUNET_TRANSPORT_PluginEnvironment *env;

  /**
   * Sessions (map from peer identity to `struct GNUNET_ATS_Session`)
   */
  struct GNUNET_CONTAINER_MultiPeerMap *session_map;

  /**
   * Head of queue of messages to transmit.
   */
  struct UNIXMessageWrapper *msg_head;

  /**
   * Tail of queue of messages to transmit.
   */
  struct UNIXMessageWrapper *msg_tail;

  /**
   * Path of our unix domain socket (/tmp/unix-plugin)
   */
  char *unix_socket_path;

  /**
   * Function to call about session status changes.
   */
  GNUNET_TRANSPORT_SessionInfoCallback sic;

  /**
   * Closure for @e sic.
   */
  void *sic_cls;

  /**
   * socket that we transmit all data with
   */
  struct UNIX_Sock_Info unix_sock;

  /**
   * Address options in HBO
   */
  uint32_t myoptions;

  /**
   * Are we using an abstract UNIX domain socket?
   */
  int is_abstract;
};


/**
 * If a session monitor is attached, notify it about the new
 * session state.
 *
 * @param plugin our plugin
 * @param session session that changed state
 * @param state new state of the session
 */
static void
notify_session_monitor (struct Plugin *plugin,
                        struct GNUNET_ATS_Session *session,
                        enum GNUNET_TRANSPORT_SessionState state)
{
  struct GNUNET_TRANSPORT_SessionInfo info;

  if (NULL == plugin->sic)
    return;
  memset (&info, 0, sizeof(info));
  info.state = state;
  info.is_inbound = GNUNET_SYSERR; /* hard to say */
  info.num_msg_pending = session->msgs_in_queue;
  info.num_bytes_pending = session->bytes_in_queue;
  /* info.receive_delay remains zero as this is not supported by UNIX
     (cannot selectively not receive from 'some' peer while continuing
     to receive from others) */
  info.session_timeout = session->timeout;
  info.address = session->address;
  plugin->sic (plugin->sic_cls, session, &info);
}


/**
 * 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 @a addr
 * @return string representing the same address
 */
static const char *
unix_plugin_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;
}


/**
 * Functions with this signature are called whenever we need
 * to close a session due to a disconnect or failure to
 * establish a connection.
 *
 * @param cls closure with the `struct Plugin *`
 * @param session session to close down
 * @return #GNUNET_OK on success
 */
static int
unix_plugin_session_disconnect (void *cls, struct GNUNET_ATS_Session *session)
{
  struct Plugin *plugin = cls;
  struct UNIXMessageWrapper *msgw;
  struct UNIXMessageWrapper *next;

  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Disconnecting session for peer `%s' `%s'\n",
       GNUNET_i2s (&session->target),
       unix_plugin_address_to_string (NULL,
                                      session->address->address,
                                      session->address->address_length));
  plugin->env->session_end (plugin->env->cls, session->address, session);
  next = plugin->msg_head;
  while (NULL != next)
  {
    msgw = next;
    next = msgw->next;
    if (msgw->session != session)
      continue;
    GNUNET_CONTAINER_DLL_remove (plugin->msg_head, plugin->msg_tail, msgw);
    session->msgs_in_queue--;
    GNUNET_assert (session->bytes_in_queue >= msgw->msgsize);
    session->bytes_in_queue -= msgw->msgsize;
    GNUNET_assert (plugin->bytes_in_queue >= msgw->msgsize);
    plugin->bytes_in_queue -= msgw->msgsize;
    if (NULL != msgw->cont)
      msgw->cont (msgw->cont_cls,
                  &msgw->session->target,
                  GNUNET_SYSERR,
                  msgw->payload,
                  0);
    GNUNET_free (msgw->msg);
    GNUNET_free (msgw);
  }
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multipeermap_remove (plugin->session_map,
                                                       &session->target,
                                                       session));
  GNUNET_STATISTICS_set (plugin->env->stats,
                         "# UNIX sessions active",
                         GNUNET_CONTAINER_multipeermap_size (
                           plugin->session_map),
                         GNUNET_NO);
  if (NULL != session->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (session->timeout_task);
    session->timeout_task = NULL;
    session->timeout = GNUNET_TIME_UNIT_ZERO_ABS;
  }
  notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_DONE);
  GNUNET_HELLO_address_free (session->address);
  GNUNET_break (0 == session->bytes_in_queue);
  GNUNET_break (0 == session->msgs_in_queue);
  GNUNET_free (session);
  return GNUNET_OK;
}


/**
 * Session was idle for too long, so disconnect it
 *
 * @param cls the `struct GNUNET_ATS_Session *` to disconnect
 */
static void
session_timeout (void *cls)
{
  struct GNUNET_ATS_Session *session = cls;
  struct GNUNET_TIME_Relative left;

  session->timeout_task = NULL;
  left = GNUNET_TIME_absolute_get_remaining (session->timeout);
  if (0 != left.rel_value_us)
  {
    /* not actually our turn yet, but let's at least update
       the monitor, it may think we're about to die ... */
    notify_session_monitor (session->plugin,
                            session,
                            GNUNET_TRANSPORT_SS_UPDATE);
    session->timeout_task =
      GNUNET_SCHEDULER_add_delayed (left, &session_timeout, session);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Session %p was idle for %s, disconnecting\n",
       session,
       GNUNET_STRINGS_relative_time_to_string (
         GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
         GNUNET_YES));
  unix_plugin_session_disconnect (session->plugin, session);
}


/**
 * Increment session timeout due to activity.  We do not immediately
 * notify the monitor here as that might generate excessive
 * signalling.
 *
 * @param session session for which the timeout should be rescheduled
 */
static void
reschedule_session_timeout (struct GNUNET_ATS_Session *session)
{
  GNUNET_assert (NULL != session->timeout_task);
  session->timeout =
    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
}


/**
 * Convert unix path to a `struct sockaddr_un *`
 *
 * @param unixpath path to convert
 * @param[out] sock_len set to the length of the address
 * @return converted unix path
 */
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;
  GNUNET_memcpy (un->sun_path, unixpath, slen);
  un->sun_path[slen] = '\0';
  slen = sizeof(struct sockaddr_un);
#if HAVE_SOCKADDR_UN_SUN_LEN
  un->sun_len = (u_char) slen;
#endif
  (*sock_len) = slen;
  return un;
}


/**
 * Closure to #lookup_session_it().
 */
struct LookupCtx
{
  /**
   * Location to store the session, if found.
   */
  struct GNUNET_ATS_Session *res;

  /**
   * Address we are looking for.
   */
  const struct GNUNET_HELLO_Address *address;
};


/**
 * Function called to find a session by address.
 *
 * @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
 */
static int
lookup_session_it (void *cls,
                   const struct GNUNET_PeerIdentity *key,
                   void *value)
{
  struct LookupCtx *lctx = cls;
  struct GNUNET_ATS_Session *session = value;

  if (0 == GNUNET_HELLO_address_cmp (lctx->address, session->address))
  {
    lctx->res = session;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}


/**
 * Find an existing session by address.
 *
 * @param plugin the plugin
 * @param address the address to find
 * @return NULL if session was not found
 */
static struct GNUNET_ATS_Session *
lookup_session (struct Plugin *plugin,
                const struct GNUNET_HELLO_Address *address)
{
  struct LookupCtx lctx;

  lctx.address = address;
  lctx.res = NULL;
  GNUNET_CONTAINER_multipeermap_get_multiple (plugin->session_map,
                                              &address->peer,
                                              &lookup_session_it,
                                              &lctx);
  return lctx.res;
}


/**
 * 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_plugin_query_keepalive_factor (void *cls)
{
  return 3;
}


/**
 * Actually send out the message, assume we've got the address and
 * send_handle squared away!
 *
 * @param cls closure
 * @param send_handle which handle to send message on
 * @param target who should receive this message (ignored by UNIX)
 * @param msgbuf one or more GNUNET_MessageHeader(s) strung together
 * @param msgbuf_size the size of the @a msgbuf to send
 * @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 @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 @a cont
 * @return on success the number of bytes written, RETRY for retry, -1 on errors
 */
static ssize_t
unix_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_Absolute timeout,
                const struct UnixAddress *addr,
                size_t addrlen,
                size_t payload,
                GNUNET_TRANSPORT_TransmitContinuation cont,
                void *cont_cls)
{
  struct Plugin *plugin = cls;
  ssize_t sent;
  struct sockaddr_un *un;
  socklen_t un_len;
  const char *unixpath;

  if (NULL == send_handle)
  {
    GNUNET_break (0);  /* We do not have a send handle */
    return GNUNET_SYSERR;
  }
  if ((NULL == addr) || (0 == addrlen))
  {
    GNUNET_break (0);  /* Can never send if we don't have an address */
    return GNUNET_SYSERR;
  }

  /* Prepare address */
  unixpath = (const char *) &addr[1];
  if (NULL == (un = unix_address_to_sockaddr (unixpath, &un_len)))
  {
    GNUNET_break (0);
    return -1;
  }

  if ((GNUNET_YES == plugin->is_abstract) &&
      (0 != (UNIX_OPTIONS_USE_ABSTRACT_SOCKETS & ntohl (addr->options))))
  {
    un->sun_path[0] = '\0';
  }
resend:
  /* Send the data */
  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;
      socklen_t len = sizeof(size);

      GNUNET_NETWORK_socket_getsockopt ((struct GNUNET_NETWORK_Handle *)
                                        send_handle,
                                        SOL_SOCKET,
                                        SO_SNDBUF,
                                        &size,
                                        &len);
      if (size < msgbuf_size)
      {
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "Trying to increase socket buffer size from %u to %u for message size %u\n",
             (unsigned int) size,
             (unsigned int) ((msgbuf_size / 1000) + 2) * 1000,
             (unsigned int) msgbuf_size);
        size = ((msgbuf_size / 1000) + 2) * 1000;
        if (GNUNET_OK ==
            GNUNET_NETWORK_socket_setsockopt ((struct GNUNET_NETWORK_Handle *)
                                              send_handle,
                                              SOL_SOCKET,
                                              SO_SNDBUF,
                                              &size,
                                              sizeof(size)))
          goto resend;       /* Increased buffer size, retry sending */
        else
        {
          /* Could not increase buffer size: error, no retry */
          GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsockopt");
          GNUNET_free (un);
          return GNUNET_SYSERR;
        }
      }
      else
      {
        /* Buffer is bigger than message:  error, no retry
         * This should never happen!*/
        GNUNET_break (0);
        GNUNET_free (un);
        return GNUNET_SYSERR;
      }
    }
  }

  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "UNIX transmitted %u-byte message to %s (%d: %s)\n",
       (unsigned int) msgbuf_size,
       GNUNET_a2s ((const struct sockaddr *) un, un_len),
       (int) sent,
       (sent < 0) ? strerror (errno) : "ok");
  GNUNET_free (un);
  return sent;
}


/**
 * 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
 */
static enum GNUNET_NetworkType
unix_plugin_get_network (void *cls, struct GNUNET_ATS_Session *session)
{
  GNUNET_assert (NULL != session);
  return GNUNET_NT_LOOPBACK;
}


/**
 * Function obtain the network type for a session
 *
 * @param cls closure (`struct Plugin *`)
 * @param address the address
 * @return the network type
 */
static enum GNUNET_NetworkType
unix_plugin_get_network_for_address (void *cls,
                                     const struct GNUNET_HELLO_Address *address)
{
  return GNUNET_NT_LOOPBACK;
}


/**
 * Creates a new outbound session the transport service will use to send data to the
 * peer
 *
 * @param cls the plugin
 * @param address the address
 * @return the session or NULL of max connections exceeded
 */
static struct GNUNET_ATS_Session *
unix_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address)
{
  struct Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session;
  struct UnixAddress *ua;
  char *addrstr;
  uint32_t addr_str_len;
  uint32_t addr_option;

  ua = (struct UnixAddress *) address->address;
  if ((NULL == address->address) || (0 == address->address_length) ||
      (sizeof(struct UnixAddress) > address->address_length))
  {
    GNUNET_break (0);
    return NULL;
  }
  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->is_abstract))
  {
    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);
    return NULL;
  }
  if (strlen (addrstr) + 1 != addr_str_len)
  {
    GNUNET_break (0);
    return NULL;
  }

  /* Check if a session for this address already exists */
  if (NULL != (session = lookup_session (plugin, address)))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Found existing session %p for address `%s'\n",
         session,
         unix_plugin_address_to_string (NULL,
                                        address->address,
                                        address->address_length));
    return session;
  }

  /* create a new session */
  session = GNUNET_new (struct GNUNET_ATS_Session);
  session->target = address->peer;
  session->address = GNUNET_HELLO_address_copy (address);
  session->plugin = plugin;
  session->timeout =
    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
  session->timeout_task =
    GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
                                  &session_timeout,
                                  session);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Creating a new session %p for address `%s'\n",
       session,
       unix_plugin_address_to_string (NULL,
                                      address->address,
                                      address->address_length));
  (void) GNUNET_CONTAINER_multipeermap_put (
    plugin->session_map,
    &address->peer,
    session,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  GNUNET_STATISTICS_set (plugin->env->stats,
                         "# UNIX sessions active",
                         GNUNET_CONTAINER_multipeermap_size (
                           plugin->session_map),
                         GNUNET_NO);
  notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_INIT);
  notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UP);
  return session;
}


/**
 * Function that will be called whenever the transport service wants
 * to notify the plugin that a session is still active and in use and
 * therefore the session timeout for this session has to be updated
 *
 * @param cls closure with the `struct Plugin *`
 * @param peer which peer was the session for
 * @param session which session is being updated
 */
static void
unix_plugin_update_session_timeout (void *cls,
                                    const struct GNUNET_PeerIdentity *peer,
                                    struct GNUNET_ATS_Session *session)
{
  struct Plugin *plugin = cls;

  if (GNUNET_OK !=
      GNUNET_CONTAINER_multipeermap_contains_value (plugin->session_map,
                                                    &session->target,
                                                    session))
  {
    GNUNET_break (0);
    return;
  }
  reschedule_session_timeout (session);
}


/**
 * Demultiplexer for UNIX messages
 *
 * @param plugin the main plugin for this transport
 * @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 @a ua
 */
static void
unix_demultiplexer (struct Plugin *plugin,
                    struct GNUNET_PeerIdentity *sender,
                    const struct GNUNET_MessageHeader *currhdr,
                    const struct UnixAddress *ua,
                    size_t ua_len)
{
  struct GNUNET_ATS_Session *session;
  struct GNUNET_HELLO_Address *address;

  GNUNET_assert (ua_len >= sizeof(struct UnixAddress));
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received message from %s\n",
       unix_plugin_address_to_string (NULL, ua, ua_len));
  GNUNET_STATISTICS_update (plugin->env->stats,
                            "# bytes received via UNIX",
                            ntohs (currhdr->size),
                            GNUNET_NO);

  /* 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 */
  session = lookup_session (plugin, address);
  if (NULL == session)
  {
    session = unix_plugin_get_session (plugin, address);
    /* Notify transport and ATS about new inbound session */
    plugin->env->session_start (NULL,
                                session->address,
                                session,
                                GNUNET_NT_LOOPBACK);
  }
  else
  {
    reschedule_session_timeout (session);
  }
  GNUNET_HELLO_address_free (address);
  plugin->env->receive (plugin->env->cls, session->address, session, currhdr);
}


/**
 * Read from UNIX domain socket (it is ready).
 *
 * @param plugin the plugin
 */
static void
unix_plugin_do_read (struct Plugin *plugin)
{
  char buf[65536] GNUNET_ALIGN;
  struct UnixAddress *ua;
  struct UNIXMessage *msg;
  struct GNUNET_PeerIdentity sender;
  struct sockaddr_un un;
  socklen_t addrlen;
  ssize_t ret;
  int offset;
  int tsize;
  int is_abstract;
  char *msgbuf;
  const struct GNUNET_MessageHeader *currhdr;
  uint16_t csize;
  size_t ua_len;

  addrlen = sizeof(un);
  memset (&un, 0, sizeof(un));
  ret = GNUNET_NETWORK_socket_recvfrom (plugin->unix_sock.desc,
                                        buf,
                                        sizeof(buf),
                                        (struct sockaddr *) &un,
                                        &addrlen);
  if ((GNUNET_SYSERR == ret) && ((errno == EAGAIN) || (errno == ENOBUFS)))
    return;
  if (GNUNET_SYSERR == ret)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "recvfrom");
    return;
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Read %d bytes from socket %s\n",
         (int) ret,
         un.sun_path);
  }

  GNUNET_assert (AF_UNIX == (un.sun_family));
  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);
  GNUNET_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];
  GNUNET_memcpy (&sender, &msg->sender, sizeof(struct GNUNET_PeerIdentity));
  offset = 0;
  tsize = csize - sizeof(struct UNIXMessage);
  while (offset + sizeof(struct GNUNET_MessageHeader) <= tsize)
  {
    currhdr = (struct GNUNET_MessageHeader *) &msgbuf[offset];
    csize = ntohs (currhdr->size);
    if ((csize < sizeof(struct GNUNET_MessageHeader)) ||
        (csize > tsize - offset))
    {
      GNUNET_break_op (0);
      break;
    }
    unix_demultiplexer (plugin, &sender, currhdr, ua, ua_len);
    offset += csize;
  }
  GNUNET_free (ua);
}


/**
 * Write to UNIX domain socket (it is ready).
 *
 * @param plugin handle to the plugin
 */
static void
unix_plugin_do_write (struct Plugin *plugin)
{
  ssize_t sent = 0;
  struct UNIXMessageWrapper *msgw;
  struct GNUNET_ATS_Session *session;
  int did_delete;

  session = NULL;
  did_delete = GNUNET_NO;
  while (NULL != (msgw = plugin->msg_head))
  {
    if (GNUNET_TIME_absolute_get_remaining (msgw->timeout).rel_value_us > 0)
      break;   /* Message is ready for sending */
    /* Message has a timeout */
    did_delete = GNUNET_YES;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Timeout for message with %u bytes \n",
         (unsigned int) msgw->msgsize);
    GNUNET_CONTAINER_DLL_remove (plugin->msg_head, plugin->msg_tail, msgw);
    session = msgw->session;
    session->msgs_in_queue--;
    GNUNET_assert (session->bytes_in_queue >= msgw->msgsize);
    session->bytes_in_queue -= msgw->msgsize;
    GNUNET_assert (plugin->bytes_in_queue >= msgw->msgsize);
    plugin->bytes_in_queue -= msgw->msgsize;
    GNUNET_STATISTICS_set (plugin->env->stats,
                           "# bytes currently in UNIX buffers",
                           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);
    GNUNET_free (msgw->msg);
    GNUNET_free (msgw);
  }
  if (NULL == msgw)
  {
    if (GNUNET_YES == did_delete)
      notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UPDATE);
    return;   /* Nothing to send at the moment */
  }
  session = msgw->session;
  sent = unix_real_send (plugin,
                         plugin->unix_sock.desc,
                         &session->target,
                         (const char *) msgw->msg,
                         msgw->msgsize,
                         msgw->priority,
                         msgw->timeout,
                         msgw->session->address->address,
                         msgw->session->address->address_length,
                         msgw->payload,
                         msgw->cont,
                         msgw->cont_cls);
  if (RETRY == sent)
  {
    GNUNET_STATISTICS_update (plugin->env->stats,
                              "# UNIX retry attempts",
                              1,
                              GNUNET_NO);
    notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UPDATE);
    return;
  }
  GNUNET_CONTAINER_DLL_remove (plugin->msg_head, plugin->msg_tail, msgw);
  session->msgs_in_queue--;
  GNUNET_assert (session->bytes_in_queue >= msgw->msgsize);
  session->bytes_in_queue -= msgw->msgsize;
  GNUNET_assert (plugin->bytes_in_queue >= msgw->msgsize);
  plugin->bytes_in_queue -= msgw->msgsize;
  GNUNET_STATISTICS_set (plugin->env->stats,
                         "# bytes currently in UNIX buffers",
                         plugin->bytes_in_queue,
                         GNUNET_NO);
  notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UPDATE);
  if (GNUNET_SYSERR == sent)
  {
    /* failed and no retry */
    if (NULL != msgw->cont)
      msgw->cont (msgw->cont_cls,
                  &msgw->session->target,
                  GNUNET_SYSERR,
                  msgw->payload,
                  0);
    GNUNET_STATISTICS_update (plugin->env->stats,
                              "# UNIX bytes discarded",
                              msgw->msgsize,
                              GNUNET_NO);
    GNUNET_free (msgw->msg);
    GNUNET_free (msgw);
    return;
  }
  /* successfully sent bytes */
  GNUNET_break (sent > 0);
  GNUNET_STATISTICS_update (plugin->env->stats,
                            "# bytes transmitted via UNIX",
                            msgw->msgsize,
                            GNUNET_NO);
  if (NULL != msgw->cont)
    msgw->cont (msgw->cont_cls,
                &msgw->session->target,
                GNUNET_OK,
                msgw->payload,
                msgw->msgsize);
  GNUNET_free (msgw->msg);
  GNUNET_free (msgw);
}


/**
 * We have been notified that our socket has something to read.
 * Then reschedule this function to be called again once more is available.
 *
 * @param cls the plugin handle
 */
static void
unix_plugin_select_read (void *cls)
{
  struct Plugin *plugin = cls;
  const struct GNUNET_SCHEDULER_TaskContext *tc;

  plugin->read_task = NULL;
  tc = GNUNET_SCHEDULER_get_task_context ();
  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
    unix_plugin_do_read (plugin);
  plugin->read_task =
    GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                   plugin->unix_sock.desc,
                                   &unix_plugin_select_read,
                                   plugin);
}


/**
 * We have been notified that our socket is ready to write.
 * Then reschedule this function to be called again once more is available.
 *
 * @param cls the plugin handle
 */
static void
unix_plugin_select_write (void *cls)
{
  struct Plugin *plugin = cls;
  const struct GNUNET_SCHEDULER_TaskContext *tc;

  plugin->write_task = NULL;
  tc = GNUNET_SCHEDULER_get_task_context ();
  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY))
    unix_plugin_do_write (plugin);
  if (NULL == plugin->msg_head)
    return; /* write queue empty */
  plugin->write_task =
    GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                    plugin->unix_sock.desc,
                                    &unix_plugin_select_write,
                                    plugin);
}


/**
 * Function that can be used by the transport service to transmit
 * a message using the plugin.   Note that in the case of a
 * peer disconnecting, the continuation MUST be called
 * prior to the disconnect notification itself.  This function
 * will be called with this peer's HELLO message to initiate
 * a fresh connection to another peer.
 *
 * @param cls closure
 * @param session which session must be used
 * @param msgbuf the message to transmit
 * @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
 *                require plugins to discard the message after the timeout,
 *                just advisory for the desired delay; most plugins will ignore
 *                this as well)
 * @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...); can be NULL
 * @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)
 */
static ssize_t
unix_plugin_send (void *cls,
                  struct GNUNET_ATS_Session *session,
                  const char *msgbuf,
                  size_t msgbuf_size,
                  unsigned int priority,
                  struct GNUNET_TIME_Relative to,
                  GNUNET_TRANSPORT_TransmitContinuation cont,
                  void *cont_cls)
{
  struct Plugin *plugin = cls;
  struct UNIXMessageWrapper *wrapper;
  struct UNIXMessage *message;
  int ssize;

  if (GNUNET_OK !=
      GNUNET_CONTAINER_multipeermap_contains_value (plugin->session_map,
                                                    &session->target,
                                                    session))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Invalid session for peer `%s' `%s'\n",
         GNUNET_i2s (&session->target),
         unix_plugin_address_to_string (NULL,
                                        session->address->address,
                                        session->address->address_length));
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending %lu bytes with session for peer `%s' `%s'\n",
       (unsigned long) msgbuf_size,
       GNUNET_i2s (&session->target),
       unix_plugin_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);
  message->header.type = htons (0);
  GNUNET_memcpy (&message->sender,
                 plugin->env->my_identity,
                 sizeof(struct GNUNET_PeerIdentity));
  GNUNET_memcpy (&message[1], msgbuf, msgbuf_size);
  wrapper = GNUNET_new (struct UNIXMessageWrapper);
  wrapper->msg = message;
  wrapper->msgsize = ssize;
  wrapper->payload = msgbuf_size;
  wrapper->priority = priority;
  wrapper->timeout = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), to);
  wrapper->cont = cont;
  wrapper->cont_cls = cont_cls;
  wrapper->session = session;
  GNUNET_CONTAINER_DLL_insert_tail (plugin->msg_head,
                                    plugin->msg_tail,
                                    wrapper);
  plugin->bytes_in_queue += ssize;
  session->bytes_in_queue += ssize;
  session->msgs_in_queue++;
  GNUNET_STATISTICS_set (plugin->env->stats,
                         "# bytes currently in UNIX buffers",
                         plugin->bytes_in_queue,
                         GNUNET_NO);
  notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UPDATE);
  if (NULL == plugin->write_task)
    plugin->write_task =
      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                      plugin->unix_sock.desc,
                                      &unix_plugin_select_write,
                                      plugin);
  return ssize;
}


/**
 * 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
 */
static int
unix_transport_server_start (void *cls)
{
  struct Plugin *plugin = cls;
  struct sockaddr_un *un;
  socklen_t un_len;

  un = unix_address_to_sockaddr (plugin->unix_socket_path, &un_len);
  if (GNUNET_YES == plugin->is_abstract)
  {
    plugin->unix_socket_path[0] = '@';
    un->sun_path[0] = '\0';
  }
  plugin->unix_sock.desc =
    GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_DGRAM, 0);
  if (NULL == plugin->unix_sock.desc)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
    GNUNET_free (un);
    return GNUNET_SYSERR;
  }
  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");
    LOG (GNUNET_ERROR_TYPE_ERROR, _ ("Cannot bind 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;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Bound to `%s'\n", plugin->unix_socket_path);
  plugin->read_task =
    GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                   plugin->unix_sock.desc,
                                   &unix_plugin_select_read,
                                   plugin);
  GNUNET_free (un);
  return 1;
}


/**
 * 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
 * (as per our configuration).  Naturally, if absolutely necessary,
 * plugins can be a bit conservative in their answer, but in general
 * plugins should make sure that the address does not redirect
 * traffic to a 3rd party that might try to man-in-the-middle our
 * traffic.
 *
 * @param cls closure, should be our handle to the Plugin
 * @param addr pointer to the address
 * @param addrlen length of @a addr
 * @return #GNUNET_OK if this is a plausible address for this peer
 *         and transport, #GNUNET_SYSERR if not
 *
 */
static int
unix_plugin_check_address (void *cls, const void *addr, size_t addrlen)
{
  struct Plugin *plugin = cls;
  const struct UnixAddress *ua = addr;
  char *addrstr;
  size_t addr_str_len;

  if ((NULL == addr) || (0 == addrlen) ||
      (sizeof(struct UnixAddress) > addrlen))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  addrstr = (char *) &ua[1];
  addr_str_len = ntohl (ua->addrlen);
  if ('\0' != addrstr[addr_str_len - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (strlen (addrstr) + 1 != addr_str_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }

  if (0 == strcmp (plugin->unix_socket_path, addrstr))
    return GNUNET_OK;
  return GNUNET_SYSERR;
}


/**
 * Convert the transports address to a nice, human-readable
 * format.
 *
 * @param cls closure
 * @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 @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 @a asc
 */
static void
unix_plugin_address_pretty_printer (void *cls,
                                    const char *type,
                                    const void *addr,
                                    size_t addrlen,
                                    int numeric,
                                    struct GNUNET_TIME_Relative timeout,
                                    GNUNET_TRANSPORT_AddressStringCallback asc,
                                    void *asc_cls)
{
  const char *ret;

  if ((NULL != addr) && (addrlen > 0))
    ret = unix_plugin_address_to_string (NULL, addr, addrlen);
  else
    ret = NULL;
  asc (asc_cls, ret, (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
  asc (asc_cls, NULL, GNUNET_OK);
}


/**
 * Function called to convert a string address to
 * a binary address.
 *
 * @param cls closure (`struct Plugin *`)
 * @param addr string address
 * @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.
 * @param added length of created address
 * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
 */
static int
unix_plugin_string_to_address (void *cls,
                               const char *addr,
                               uint16_t addrlen,
                               void **buf,
                               size_t *added)
{
  struct UnixAddress *ua;
  char *address;
  char *plugin;
  char *optionstr;
  uint32_t options;
  size_t ua_size;

  /* Format unix.options.address */
  address = NULL;
  plugin = NULL;
  optionstr = NULL;

  if ((NULL == addr) || (addrlen == 0))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if ('\0' != addr[addrlen - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (strlen (addr) != addrlen - 1)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  plugin = GNUNET_strdup (addr);
  optionstr = strchr (plugin, '.');
  if (NULL == optionstr)
  {
    GNUNET_break (0);
    GNUNET_free (plugin);
    return GNUNET_SYSERR;
  }
  optionstr[0] = '\0';
  optionstr++;
  options = atol (optionstr);
  address = strchr (optionstr, '.');
  if (NULL == address)
  {
    GNUNET_break (0);
    GNUNET_free (plugin);
    return GNUNET_SYSERR;
  }
  address[0] = '\0';
  address++;
  if (0 != strcmp (plugin, PLUGIN_NAME))
  {
    GNUNET_break (0);
    GNUNET_free (plugin);
    return GNUNET_SYSERR;
  }

  ua_size = sizeof(struct UnixAddress) + strlen (address) + 1;
  ua = GNUNET_malloc (ua_size);
  ua->options = htonl (options);
  ua->addrlen = htonl (strlen (address) + 1);
  GNUNET_memcpy (&ua[1], address, strlen (address) + 1);
  GNUNET_free (plugin);

  (*buf) = ua;
  (*added) = ua_size;
  return GNUNET_OK;
}


/**
 * Notify transport service about address
 *
 * @param cls the plugin
 */
static void
address_notification (void *cls)
{
  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 (plugin->myoptions);
  ua->addrlen = htonl (strlen (plugin->unix_socket_path) + 1);
  unix_path = (char *) &ua[1];
  GNUNET_memcpy (unix_path,
                 plugin->unix_socket_path,
                 strlen (plugin->unix_socket_path) + 1);

  plugin->address_update_task = NULL;
  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);
}


/**
 * Function called on sessions to disconnect
 *
 * @param cls the plugin
 * @param key peer identity (unused)
 * @param value the `struct GNUNET_ATS_Session *` to disconnect
 * @return #GNUNET_YES (always, continue to iterate)
 */
static int
get_session_delete_it (void *cls,
                       const struct GNUNET_PeerIdentity *key,
                       void *value)
{
  struct Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session = value;

  unix_plugin_session_disconnect (plugin, session);
  return GNUNET_YES;
}


/**
 * Disconnect from a remote node.  Clean up session if we have one for this peer
 *
 * @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
 */
static void
unix_plugin_peer_disconnect (void *cls,
                             const struct GNUNET_PeerIdentity *target)
{
  struct Plugin *plugin = cls;

  GNUNET_CONTAINER_multipeermap_get_multiple (plugin->session_map,
                                              target,
                                              &get_session_delete_it,
                                              plugin);
}


/**
 * Return information about the given session to the
 * monitor callback.
 *
 * @param cls the `struct Plugin` with the monitor callback (`sic`)
 * @param peer peer we send information about
 * @param value our `struct GNUNET_ATS_Session` to send information about
 * @return #GNUNET_OK (continue to iterate)
 */
static int
send_session_info_iter (void *cls,
                        const struct GNUNET_PeerIdentity *peer,
                        void *value)
{
  struct Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session = value;

  notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_INIT);
  notify_session_monitor (plugin, session, GNUNET_TRANSPORT_SS_UP);
  return GNUNET_OK;
}


/**
 * Begin monitoring sessions of a plugin.  There can only
 * be one active monitor per plugin (i.e. if there are
 * multiple monitors, the transport service needs to
 * multiplex the generated events over all of them).
 *
 * @param cls closure of the plugin
 * @param sic callback to invoke, NULL to disable monitor;
 *            plugin will being by iterating over all active
 *            sessions immediately and then enter monitor mode
 * @param sic_cls closure for @a sic
 */
static void
unix_plugin_setup_monitor (void *cls,
                           GNUNET_TRANSPORT_SessionInfoCallback sic,
                           void *sic_cls)
{
  struct Plugin *plugin = cls;

  plugin->sic = sic;
  plugin->sic_cls = sic_cls;
  if (NULL != sic)
  {
    GNUNET_CONTAINER_multipeermap_iterate (plugin->session_map,
                                           &send_session_info_iter,
                                           plugin);
    /* signal end of first iteration */
    sic (sic_cls, NULL, NULL);
  }
}


/**
 * The exported method.  Initializes the plugin and returns a
 * struct with the callbacks.
 *
 * @param cls the plugin's execution environment
 * @return NULL on error, plugin functions otherwise
 */
void *
libgnunet_plugin_transport_unix_init (void *cls)
{
  struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
  struct GNUNET_TRANSPORT_PluginFunctions *api;
  struct Plugin *plugin;
  int sockets_created;

  if (NULL == env->receive)
  {
    /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
       initialize the plugin or the API */
    api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
    api->cls = NULL;
    api->address_pretty_printer = &unix_plugin_address_pretty_printer;
    api->address_to_string = &unix_plugin_address_to_string;
    api->string_to_address = &unix_plugin_string_to_address;
    return api;
  }

  plugin = GNUNET_new (struct Plugin);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (env->cfg,
                                               "transport-unix",
                                               "UNIXPATH",
                                               &plugin->unix_socket_path))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "transport-unix",
                               "UNIXPATH");
    GNUNET_free (plugin);
    return NULL;
  }

  plugin->env = env;

  /* Initialize my flags */
#ifdef __linux__
  plugin->is_abstract =
    GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                          "testing",
                                          "USE_ABSTRACT_SOCKETS");
#endif
  plugin->myoptions = UNIX_OPTIONS_NONE;
  if (GNUNET_YES == plugin->is_abstract)
    plugin->myoptions = UNIX_OPTIONS_USE_ABSTRACT_SOCKETS;

  api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
  api->cls = plugin;
  api->get_session = &unix_plugin_get_session;
  api->send = &unix_plugin_send;
  api->disconnect_peer = &unix_plugin_peer_disconnect;
  api->disconnect_session = &unix_plugin_session_disconnect;
  api->query_keepalive_factor = &unix_plugin_query_keepalive_factor;
  api->address_pretty_printer = &unix_plugin_address_pretty_printer;
  api->address_to_string = &unix_plugin_address_to_string;
  api->check_address = &unix_plugin_check_address;
  api->string_to_address = &unix_plugin_string_to_address;
  api->get_network = &unix_plugin_get_network;
  api->get_network_for_address = &unix_plugin_get_network_for_address;
  api->update_session_timeout = &unix_plugin_update_session_timeout;
  api->setup_monitor = &unix_plugin_setup_monitor;
  sockets_created = unix_transport_server_start (plugin);
  if ((0 == sockets_created) || (GNUNET_SYSERR == sockets_created))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING, _ ("Failed to open UNIX listen socket\n"));
    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;
}


/**
 * Shutdown the plugin.
 *
 * @param cls the plugin API returned from the initialization function
 * @return NULL (always)
 */
void *
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;
  struct GNUNET_ATS_Session *session;

  if (NULL == plugin)
  {
    GNUNET_free (api);
    return NULL;
  }
  len = sizeof(struct UnixAddress) + strlen (plugin->unix_socket_path) + 1;
  ua = GNUNET_malloc (len);
  ua->options = htonl (plugin->myoptions);
  ua->addrlen = htonl (strlen (plugin->unix_socket_path) + 1);
  GNUNET_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);

  GNUNET_free (address);
  GNUNET_free (ua);

  while (NULL != (msgw = plugin->msg_head))
  {
    GNUNET_CONTAINER_DLL_remove (plugin->msg_head, plugin->msg_tail, msgw);
    session = msgw->session;
    session->msgs_in_queue--;
    GNUNET_assert (session->bytes_in_queue >= msgw->msgsize);
    session->bytes_in_queue -= msgw->msgsize;
    GNUNET_assert (plugin->bytes_in_queue >= msgw->msgsize);
    plugin->bytes_in_queue -= msgw->msgsize;
    if (NULL != msgw->cont)
      msgw->cont (msgw->cont_cls,
                  &msgw->session->target,
                  GNUNET_SYSERR,
                  msgw->payload,
                  0);
    GNUNET_free (msgw->msg);
    GNUNET_free (msgw);
  }

  if (NULL != plugin->read_task)
  {
    GNUNET_SCHEDULER_cancel (plugin->read_task);
    plugin->read_task = NULL;
  }
  if (NULL != plugin->write_task)
  {
    GNUNET_SCHEDULER_cancel (plugin->write_task);
    plugin->write_task = NULL;
  }
  if (NULL != plugin->address_update_task)
  {
    GNUNET_SCHEDULER_cancel (plugin->address_update_task);
    plugin->address_update_task = NULL;
  }
  if (NULL != plugin->unix_sock.desc)
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_NETWORK_socket_close (plugin->unix_sock.desc));
    plugin->unix_sock.desc = NULL;
  }
  GNUNET_CONTAINER_multipeermap_iterate (plugin->session_map,
                                         &get_session_delete_it,
                                         plugin);
  GNUNET_CONTAINER_multipeermap_destroy (plugin->session_map);
  GNUNET_break (0 == plugin->bytes_in_queue);
  GNUNET_free (plugin->unix_socket_path);
  GNUNET_free (plugin);
  GNUNET_free (api);
  return NULL;
}


/* end of plugin_transport_unix.c */
