plugin_transport_unix.c

Go to the documentation of this file.

/*
     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
 */

#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"


#define RETRY 0

#define PLUGIN_NAME "unix"

enum UNIX_ADDRESS_OPTIONS {
  UNIX_OPTIONS_NONE = 0,

  UNIX_OPTIONS_USE_ABSTRACT_SOCKETS = 1
};


#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

struct UnixAddress {
  uint32_t options GNUNET_PACKED;

  uint32_t addrlen GNUNET_PACKED;

  /* followed by actual path */
};


struct UNIXMessage {
  struct GNUNET_MessageHeader header;

  struct GNUNET_PeerIdentity sender;
};

GNUNET_NETWORK_STRUCT_END


struct UNIXMessageWrapper {
  struct UNIXMessageWrapper *next;

  struct UNIXMessageWrapper *prev;

  struct UNIXMessage *msg;

  struct GNUNET_ATS_Session *session;

  GNUNET_TRANSPORT_TransmitContinuation cont;

  void *cont_cls;

  struct GNUNET_TIME_Absolute timeout;

  size_t msgsize;

  size_t payload;

  unsigned int priority;
};


struct GNUNET_ATS_Session {
  struct GNUNET_ATS_Session *next;

  struct GNUNET_ATS_Session *prev;

  struct GNUNET_PeerIdentity target;

  struct Plugin *plugin;

  struct GNUNET_HELLO_Address *address;

  unsigned long long bytes_in_queue;

  struct GNUNET_TIME_Absolute timeout;

  struct GNUNET_SCHEDULER_Task *timeout_task;

  unsigned int msgs_in_queue;
};


struct Plugin;


struct UNIX_Sock_Info {
  struct GNUNET_NETWORK_Handle *desc;
};


struct Plugin {
  struct GNUNET_SCHEDULER_Task *address_update_task;

  struct GNUNET_SCHEDULER_Task *read_task;

  struct GNUNET_SCHEDULER_Task *write_task;

  unsigned long long bytes_in_queue;

  struct GNUNET_TRANSPORT_PluginEnvironment *env;

  struct GNUNET_CONTAINER_MultiPeerMap *session_map;

  struct UNIXMessageWrapper *msg_head;

  struct UNIXMessageWrapper *msg_tail;

  char *unix_socket_path;

  GNUNET_TRANSPORT_SessionInfoCallback sic;

  void *sic_cls;

  struct UNIX_Sock_Info unix_sock;

  uint32_t myoptions;

  int is_abstract;
};


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);
}


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;
}


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;
}


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);
}


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);
}


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;
}


struct LookupCtx {
  struct GNUNET_ATS_Session *res;

  const struct GNUNET_HELLO_Address *address;
};


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;
}


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;
}


static unsigned int
unix_plugin_query_keepalive_factor(void *cls)
{
  return 3;
}


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;
}


static enum GNUNET_NetworkType
unix_plugin_get_network(void *cls, struct GNUNET_ATS_Session *session)
{
  GNUNET_assert(NULL != session);
  return GNUNET_NT_LOOPBACK;
}


static enum GNUNET_NetworkType
unix_plugin_get_network_for_address(void *cls,
                                    const struct GNUNET_HELLO_Address *address)
{
  return GNUNET_NT_LOOPBACK;
}


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;
}


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);
}


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);
}


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);
}


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);
}


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);
}


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);
}


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 %u bytes with session for peer `%s' `%s'\n",
      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;
}


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;
}


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;
}


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);
}


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;
}


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);
}


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;
}


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);
}


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;
}


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);
    }
}


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
         initialze 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;
}


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 */