plugin_transport_unix.c File Reference

Transport plugin using unix domain sockets (!) Clearly, can only be used locally on Unix/Linux hosts... More...

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

Include dependency graph for plugin_transport_unix.c:

Go to the source code of this file.

Data Structures
struct	UnixAddress
	Binary format for an UNIX Domain Socket address in GNUnet. More...
struct	UNIXMessage
	UNIX Message-Packet header. More...
struct	UNIXMessageWrapper
	Information we track for a message awaiting transmission. More...
struct	GNUNET_ATS_Session
	Session handle for connections. More...
struct	UNIX_Sock_Info
	Information we keep for each of our listen sockets. More...
struct	Plugin
	Handle for a plugin. More...
struct	LookupCtx
	Closure to lookup_queue_it(). More...

Macros
#define	RETRY   0
	Return code we give on 'send' if we failed to send right now but it makes sense to retry later. More...
#define	PLUGIN_NAME   "unix"
	Name of the plugin. More...
#define	HOSTNAME_RESOLVE_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
	How long until we give up on transmitting the welcome message? More...
#define	LOG(kind, ...)   GNUNET_log_from (kind, "transport-unix", __VA_ARGS__)

Enumerations
enum	UNIX_ADDRESS_OPTIONS { UNIX_OPTIONS_NONE = 0 , UNIX_OPTIONS_USE_ABSTRACT_SOCKETS = 1 }
	Options for UNIX Domain addresses. More...

Functions
static void	notify_session_monitor (struct Plugin *plugin, struct GNUNET_ATS_Session *session, enum GNUNET_TRANSPORT_SessionState state)
	If a session monitor is attached, notify it about the new session state. More...
static const char *	unix_plugin_address_to_string (void *cls, const void *addr, size_t addrlen)
	Function called for a quick conversion of the binary address to a numeric address. More...
static int	unix_plugin_session_disconnect (void *cls, struct GNUNET_ATS_Session *session)
	Functions with this signature are called whenever we need to close a session due to a disconnect or failure to establish a connection. More...
static void	session_timeout (void *cls)
	Session was idle for too long, so disconnect it. More...
static void	reschedule_session_timeout (struct GNUNET_ATS_Session *session)
	Increment session timeout due to activity. More...
static struct sockaddr_un *	unix_address_to_sockaddr (const char *unixpath, socklen_t *sock_len)
	Convert unix path to a struct sockaddr_un * More...
static int	lookup_session_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Function called to find a session by address. More...
static struct GNUNET_ATS_Session *	lookup_session (struct Plugin *plugin, const struct GNUNET_HELLO_Address *address)
	Find an existing session by address. More...
static unsigned int	unix_plugin_query_keepalive_factor (void *cls)
	Function that is called to get the keepalive factor. More...
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)
	Actually send out the message, assume we've got the address and send_handle squared away! More...
static enum GNUNET_NetworkType	unix_plugin_get_network (void *cls, struct GNUNET_ATS_Session *session)
	Function obtain the network type for a session. More...
static enum GNUNET_NetworkType	unix_plugin_get_network_for_address (void *cls, const struct GNUNET_HELLO_Address *address)
	Function obtain the network type for a session. More...
static struct GNUNET_ATS_Session *	unix_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address)
	Creates a new outbound session the transport service will use to send data to the peer. More...
static void	unix_plugin_update_session_timeout (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_ATS_Session *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. More...
static void	unix_demultiplexer (struct Plugin *plugin, struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *currhdr, const struct UnixAddress *ua, size_t ua_len)
	Demultiplexer for UNIX messages. More...
static void	unix_plugin_do_read (struct Plugin *plugin)
	Read from UNIX domain socket (it is ready). More...
static void	unix_plugin_do_write (struct Plugin *plugin)
	Write to UNIX domain socket (it is ready). More...
static void	unix_plugin_select_read (void *cls)
	We have been notified that our socket has something to read. More...
static void	unix_plugin_select_write (void *cls)
	We have been notified that our socket is ready to write. More...
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)
	Function that can be used by the transport service to transmit a message using the plugin. More...
static int	unix_transport_server_start (void *cls)
	Create a slew of UNIX sockets. More...
static int	unix_plugin_check_address (void *cls, const void *addr, size_t addrlen)
	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). More...
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)
	Convert the transports address to a nice, human-readable format. More...
static int	unix_plugin_string_to_address (void *cls, const char *addr, uint16_t addrlen, void **buf, size_t *added)
	Function called to convert a string address to a binary address. More...
static void	address_notification (void *cls)
	Notify transport service about address. More...
static int	get_session_delete_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Function called on sessions to disconnect. More...
static void	unix_plugin_peer_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
	Disconnect from a remote node. More...
static int	send_session_info_iter (void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
	Return information about the given session to the monitor callback. More...
static void	unix_plugin_setup_monitor (void *cls, GNUNET_TRANSPORT_SessionInfoCallback sic, void *sic_cls)
	Begin monitoring sessions of a plugin. More...
void *	libgnunet_plugin_transport_unix_init (void *cls)
	The exported method. More...
void *	libgnunet_plugin_transport_unix_done (void *cls)
	Shutdown the plugin. More...

Detailed Description

Transport plugin using unix domain sockets (!) Clearly, can only be used locally on Unix/Linux hosts...

ONLY INTENDED FOR TESTING!!!

Author

Christian Grothoff

Nathan Evans

Definition in file plugin_transport_unix.c.

Macro Definition Documentation

RETRY

#define RETRY   0

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!?).

Definition at line 44 of file plugin_transport_unix.c.

PLUGIN_NAME

#define PLUGIN_NAME   "unix"

Name of the plugin.

Definition at line 49 of file plugin_transport_unix.c.

HOSTNAME_RESOLVE_TIMEOUT

#define HOSTNAME_RESOLVE_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)

How long until we give up on transmitting the welcome message?

Definition at line 71 of file plugin_transport_unix.c.

LOG

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

Definition at line 74 of file plugin_transport_unix.c.

Enumeration Type Documentation

UNIX_ADDRESS_OPTIONS

enum UNIX_ADDRESS_OPTIONS

Options for UNIX Domain addresses.

Enumerator
UNIX_OPTIONS_NONE	No special options.
UNIX_OPTIONS_USE_ABSTRACT_SOCKETS	Linux abstract domain sockets should be used.

Definition at line 54 of file plugin_transport_unix.c.

{
  UNIX_OPTIONS_NONE = 0,
 
  UNIX_OPTIONS_USE_ABSTRACT_SOCKETS = 1
};

Function Documentation

notify_session_monitor()

static void notify_session_monitor ( struct Plugin *  plugin, struct GNUNET_ATS_Session *  session, enum GNUNET_TRANSPORT_SessionState  state  )

static

If a session monitor is attached, notify it about the new session state.

Parameters

plugin	our plugin
session	session that changed state
state	new state of the session

Definition at line 333 of file plugin_transport_unix.c.

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

References GNUNET_ATS_Session::address, GNUNET_ATS_Session::bytes_in_queue, GNUNET_SYSERR, info, GNUNET_ATS_Session::msgs_in_queue, plugin, state, and GNUNET_ATS_Session::timeout.

Referenced by send_session_info_iter(), session_timeout(), unix_plugin_do_write(), unix_plugin_get_session(), unix_plugin_send(), and unix_plugin_session_disconnect().

Here is the caller graph for this function:

unix_plugin_address_to_string()

static const char* unix_plugin_address_to_string ( void *  cls, const void *  addr, size_t  addrlen  )

static

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.

Parameters

cls	closure
addr	binary address
addrlen	length of the addr

Returns

string representing the same address

Definition at line 367 of file plugin_transport_unix.c.

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

References UnixAddress::addrlen, GNUNET_break, GNUNET_snprintf(), UnixAddress::options, and PLUGIN_NAME.

Referenced by libgnunet_plugin_transport_unix_init(), unix_demultiplexer(), unix_plugin_address_pretty_printer(), unix_plugin_get_session(), unix_plugin_send(), and unix_plugin_session_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_session_disconnect()

static int unix_plugin_session_disconnect ( void *  cls, struct GNUNET_ATS_Session *  session  )

static

Functions with this signature are called whenever we need to close a session due to a disconnect or failure to establish a connection.

Parameters

cls	closure with the struct Plugin *
session	session to close down

Returns

GNUNET_OK on success

Definition at line 425 of file plugin_transport_unix.c.

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

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, GNUNET_ATS_Session::bytes_in_queue, UNIXMessageWrapper::cont, UNIXMessageWrapper::cont_cls, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_address_free, GNUNET_i2s(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_TRANSPORT_SS_DONE, GNUNET_YES, LOG, UNIXMessageWrapper::msg, GNUNET_ATS_Session::msgs_in_queue, UNIXMessageWrapper::msgsize, UNIXMessageWrapper::next, notify_session_monitor(), UNIXMessageWrapper::payload, plugin, UNIXMessageWrapper::session, GNUNET_ATS_Session::target, GNUNET_ATS_Session::timeout, GNUNET_ATS_Session::timeout_task, and unix_plugin_address_to_string().

Referenced by get_session_delete_it(), libgnunet_plugin_transport_unix_init(), and session_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

session_timeout()

static void session_timeout ( void *  cls )

static

Session was idle for too long, so disconnect it.

Parameters

cls	the struct GNUNET_ATS_Session * to disconnect

Definition at line 490 of file plugin_transport_unix.c.

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

References GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TRANSPORT_SS_UPDATE, GNUNET_YES, LOG, notify_session_monitor(), GNUNET_ATS_Session::plugin, GNUNET_TIME_Relative::rel_value_us, GNUNET_ATS_Session::timeout, GNUNET_ATS_Session::timeout_task, and unix_plugin_session_disconnect().

Referenced by unix_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

reschedule_session_timeout()

static void reschedule_session_timeout ( struct GNUNET_ATS_Session *  session )

static

Increment session timeout due to activity.

We do not immediately notify the monitor here as that might generate excessive signalling.

Parameters

session

session for which the timeout should be rescheduled

Definition at line 526 of file plugin_transport_unix.c.

{
  GNUNET_assert (NULL != session->timeout_task);
  session->timeout =
    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
}

References GNUNET_assert, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_TIME_relative_to_absolute(), GNUNET_ATS_Session::timeout, and GNUNET_ATS_Session::timeout_task.

Referenced by unix_demultiplexer(), and unix_plugin_update_session_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_address_to_sockaddr()

static struct sockaddr_un* unix_address_to_sockaddr ( const char *  unixpath, socklen_t *  sock_len  )

static

Convert unix path to a struct sockaddr_un *

Parameters

	unixpath	path to convert
[out]	sock_len	set to the length of the address

Returns

converted unix path

Definition at line 542 of file plugin_transport_unix.c.

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

References GNUNET_assert, GNUNET_memcpy, and GNUNET_new.

Referenced by unix_plugin_get_network(), and unix_transport_server_start().

Here is the caller graph for this function:

lookup_session_it()

static int lookup_session_it ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Function called to find a session by address.

Parameters

cls	the struct LookupCtx *
key	peer we are looking for (unused)
value	a session

Returns

GNUNET_YES if not found (continue looking), GNUNET_NO on success

Definition at line 590 of file plugin_transport_unix.c.

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

References GNUNET_ATS_Session::address, LookupCtx::address, GNUNET_HELLO_address_cmp(), GNUNET_NO, GNUNET_YES, LookupCtx::res, and value.

Referenced by lookup_session().

Here is the call graph for this function:

Here is the caller graph for this function:

lookup_session()

static struct GNUNET_ATS_Session* lookup_session ( struct Plugin *  plugin, const struct GNUNET_HELLO_Address *  address  )

static

Find an existing session by address.

Parameters

plugin	the plugin
address	the address to find

Returns

NULL if session was not found

Definition at line 614 of file plugin_transport_unix.c.

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

References address, LookupCtx::address, GNUNET_CONTAINER_multipeermap_get_multiple(), lookup_session_it(), plugin, and LookupCtx::res.

Referenced by unix_demultiplexer(), and unix_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_query_keepalive_factor()

static unsigned int unix_plugin_query_keepalive_factor ( void *  cls )

static

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.

Parameters

cls	closure with the struct Plugin

Returns

keepalive factor

Definition at line 638 of file plugin_transport_unix.c.

{
  return 3;
}

Referenced by libgnunet_plugin_transport_unix_init().

Here is the caller graph for this function:

unix_real_send()

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  )

static

Actually send out the message, assume we've got the address and send_handle squared away!

Parameters

cls	closure
send_handle	which handle to send message on
target	who should receive this message (ignored by UNIX)
msgbuf	one or more GNUNET_MessageHeader(s) strung together
msgbuf_size	the size of the msgbuf to send
priority	how important is the message (ignored by UNIX)
timeout	when should we time out (give up) if we can not transmit?
addr	the addr to send the message to, needs to be a sockaddr for us
addrlen	the len of addr
payload	bytes payload to send
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...)
cont_cls	closure for cont

Returns

on success the number of bytes written, RETRY for retry, -1 on errors

Definition at line 666 of file plugin_transport_unix.c.

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

Referenced by unix_plugin_do_write().

Here is the caller graph for this function:

unix_plugin_get_network()

static enum GNUNET_NetworkType unix_plugin_get_network ( void *  cls, struct GNUNET_ATS_Session *  session  )

static

Function obtain the network type for a session.

Parameters

cls	closure ('struct Plugin*')
session	the session

Returns

the network type in HBO or GNUNET_SYSERR

Definition at line 666 of file plugin_transport_unix.c.

{
  GNUNET_assert (NULL != session);
  return GNUNET_NT_LOOPBACK;
}

References GNUNET_a2s(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_strerror, GNUNET_NETWORK_socket_getsockopt(), GNUNET_NETWORK_socket_sendto(), GNUNET_NETWORK_socket_setsockopt(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, len, LOG, UnixAddress::options, plugin, RETRY, size, unix_address_to_sockaddr(), and UNIX_OPTIONS_USE_ABSTRACT_SOCKETS.

Referenced by libgnunet_plugin_transport_unix_init().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_get_network_for_address()

static enum GNUNET_NetworkType unix_plugin_get_network_for_address ( void *  cls, const struct GNUNET_HELLO_Address *  address  )

static

Function obtain the network type for a session.

Parameters

cls	closure (struct Plugin *)
address	the address

Returns

the network type

Definition at line 666 of file plugin_transport_unix.c.

{
  return GNUNET_NT_LOOPBACK;
}

Referenced by libgnunet_plugin_transport_unix_init().

Here is the caller graph for this function:

unix_plugin_get_session()

static struct GNUNET_ATS_Session* unix_plugin_get_session ( void *  cls, const struct GNUNET_HELLO_Address *  address  )

static

Creates a new outbound session the transport service will use to send data to the peer.

Parameters

cls	the plugin
address	the address

Returns

the session or NULL of max connections exceeded

Definition at line 819 of file plugin_transport_unix.c.

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

References address, GNUNET_ATS_Session::address, UnixAddress::addrlen, GNUNET_break, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_address_copy(), GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_set(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_SS_INIT, GNUNET_TRANSPORT_SS_UP, LOG, lookup_session(), notify_session_monitor(), UnixAddress::options, plugin, GNUNET_ATS_Session::plugin, session_timeout(), GNUNET_ATS_Session::target, GNUNET_ATS_Session::timeout, GNUNET_ATS_Session::timeout_task, UNIX_OPTIONS_USE_ABSTRACT_SOCKETS, and unix_plugin_address_to_string().

Referenced by libgnunet_plugin_transport_unix_init(), and unix_demultiplexer().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_update_session_timeout()

static void unix_plugin_update_session_timeout ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_ATS_Session *  session  )

static

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.

Parameters

cls	closure with the struct Plugin *
peer	which peer was the session for
session	which session is being updated

Definition at line 916 of file plugin_transport_unix.c.

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

References GNUNET_break, GNUNET_CONTAINER_multipeermap_contains_value(), GNUNET_OK, plugin, reschedule_session_timeout(), and GNUNET_ATS_Session::target.

Referenced by libgnunet_plugin_transport_unix_init().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_demultiplexer()

static void unix_demultiplexer ( struct Plugin *  plugin, struct GNUNET_PeerIdentity *  sender, const struct GNUNET_MessageHeader *  currhdr, const struct UnixAddress *  ua, size_t  ua_len  )

static

Demultiplexer for UNIX messages.

Parameters

plugin	the main plugin for this transport
sender	from which peer the message was received
currhdr	pointer to the header of the message
ua	address to look for
ua_len	length of the address ua

Definition at line 944 of file plugin_transport_unix.c.

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

References address, GNUNET_ATS_Session::address, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_address_free, GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_NO, GNUNET_NT_LOOPBACK, GNUNET_STATISTICS_update(), LOG, lookup_session(), plugin, PLUGIN_NAME, reschedule_session_timeout(), GNUNET_MessageHeader::size, unix_plugin_address_to_string(), and unix_plugin_get_session().

Referenced by unix_plugin_do_read().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_do_read()

static void unix_plugin_do_read ( struct Plugin *  plugin )

static

Read from UNIX domain socket (it is ready).

Parameters

plugin

the plugin

Definition at line 994 of file plugin_transport_unix.c.

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

References UnixAddress::addrlen, buf, csize, GNUNET_ALIGN, GNUNET_assert, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror, GNUNET_malloc, GNUNET_memcpy, GNUNET_NETWORK_socket_recvfrom(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, LOG, msg, UnixAddress::options, plugin, ret, UNIXMessage::sender, GNUNET_MessageHeader::size, unix_demultiplexer(), UNIX_OPTIONS_NONE, and UNIX_OPTIONS_USE_ABSTRACT_SOCKETS.

Referenced by unix_plugin_select_read().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_do_write()

static void unix_plugin_do_write ( struct Plugin *  plugin )

static

Write to UNIX domain socket (it is ready).

Parameters

plugin

handle to the plugin

Definition at line 1085 of file plugin_transport_unix.c.

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

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, GNUNET_ATS_Session::bytes_in_queue, UNIXMessageWrapper::cont, UNIXMessageWrapper::cont_cls, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GNUNET_TRANSPORT_SS_UPDATE, GNUNET_YES, LOG, UNIXMessageWrapper::msg, GNUNET_ATS_Session::msgs_in_queue, UNIXMessageWrapper::msgsize, notify_session_monitor(), UNIXMessageWrapper::payload, plugin, UNIXMessageWrapper::priority, GNUNET_TIME_Relative::rel_value_us, RETRY, UNIXMessageWrapper::session, GNUNET_ATS_Session::target, UNIXMessageWrapper::timeout, and unix_real_send().

Referenced by unix_plugin_select_write().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_select_read()

static void unix_plugin_select_read ( void *  cls )

static

We have been notified that our socket has something to read.

Then reschedule this function to be called again once more is available.

Parameters

cls	the plugin handle

Definition at line 1207 of file plugin_transport_unix.c.

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

References GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_READ_READY, GNUNET_TIME_UNIT_FOREVER_REL, plugin, GNUNET_SCHEDULER_TaskContext::reason, tc, and unix_plugin_do_read().

Referenced by unix_transport_server_start().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_select_write()

static void unix_plugin_select_write ( void *  cls )

static

We have been notified that our socket is ready to write.

Then reschedule this function to be called again once more is available.

Parameters

cls	the plugin handle

Definition at line 1231 of file plugin_transport_unix.c.

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

References GNUNET_SCHEDULER_add_write_net(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_WRITE_READY, GNUNET_TIME_UNIT_FOREVER_REL, plugin, GNUNET_SCHEDULER_TaskContext::reason, tc, and unix_plugin_do_write().

Referenced by unix_plugin_send().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_send()

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  )

static

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.

Parameters

cls	closure
session	which session must be used
msgbuf	the message to transmit
msgbuf_size	number of bytes in msgbuf
priority	how important is the message (most plugins will ignore message priority and just FIFO)
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)
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
cont_cls	closure for cont

Returns

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)

Definition at line 1278 of file plugin_transport_unix.c.

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

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, GNUNET_ATS_Session::bytes_in_queue, UNIXMessageWrapper::cont, UNIXMessageWrapper::cont_cls, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_multipeermap_contains_value(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_write_net(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_SS_UPDATE, UNIXMessage::header, LOG, UNIXMessageWrapper::msg, GNUNET_ATS_Session::msgs_in_queue, UNIXMessageWrapper::msgsize, notify_session_monitor(), UNIXMessageWrapper::payload, plugin, UNIXMessageWrapper::priority, UNIXMessage::sender, UNIXMessageWrapper::session, GNUNET_MessageHeader::size, GNUNET_ATS_Session::target, UNIXMessageWrapper::timeout, GNUNET_MessageHeader::type, unix_plugin_address_to_string(), and unix_plugin_select_write().

Referenced by libgnunet_plugin_transport_unix_init().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_transport_server_start()

static int unix_transport_server_start ( void *  cls )

static

Create a slew of UNIX sockets.

If possible, use IPv6 and IPv4.

Parameters

cls	closure for server start, should be a struct Plugin *

Returns

number of sockets created or GNUNET_SYSERR on error

Definition at line 1358 of file plugin_transport_unix.c.

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

References _, GNUNET_DISK_directory_create_for_file(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_strerror, GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, LOG, plugin, unix_address_to_sockaddr(), and unix_plugin_select_read().

Referenced by libgnunet_plugin_transport_unix_init().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_check_address()

static int unix_plugin_check_address ( void *  cls, const void *  addr, size_t  addrlen  )

static

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.

Parameters

cls	closure, should be our handle to the Plugin
addr	pointer to the address
addrlen	length of addr

Returns

GNUNET_OK if this is a plausible address for this peer and transport, GNUNET_SYSERR if not

Definition at line 1430 of file plugin_transport_unix.c.

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

References UnixAddress::addrlen, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, and plugin.

Referenced by libgnunet_plugin_transport_unix_init().

Here is the caller graph for this function:

unix_plugin_address_pretty_printer()

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  )

static

Convert the transports address to a nice, human-readable format.

Parameters

cls	closure
type	name of the transport that generated the address
addr	one of the addresses of the host, NULL for the last address the specific address format depends on the transport
addrlen	length of the addr
numeric	should (IP) addresses be displayed in numeric form?
timeout	after how long should we give up?
asc	function to call on each string
asc_cls	closure for asc

Definition at line 1477 of file plugin_transport_unix.c.

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

References UnixAddress::addrlen, GNUNET_OK, GNUNET_SYSERR, ret, and unix_plugin_address_to_string().

Referenced by libgnunet_plugin_transport_unix_init().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_string_to_address()

static int unix_plugin_string_to_address ( void *  cls, const char *  addr, uint16_t  addrlen, void **  buf, size_t *  added  )

static

Function called to convert a string address to a binary address.

Parameters

cls	closure (struct Plugin *)
addr	string address
addrlen	length of the addr (strlen(addr) + '\0')
buf	location to store the buffer If the function returns GNUNET_SYSERR, its contents are undefined.
added	length of created address

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1510 of file plugin_transport_unix.c.

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

References address, UnixAddress::addrlen, GNUNET_break, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, options, UnixAddress::options, plugin, and PLUGIN_NAME.

Referenced by libgnunet_plugin_transport_unix_init().

Here is the caller graph for this function:

address_notification()

static void address_notification ( void *  cls )

static

Notify transport service about address.

Parameters

cls	the plugin

Definition at line 1589 of file plugin_transport_unix.c.

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

References address, UnixAddress::addrlen, GNUNET_free, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_malloc, GNUNET_memcpy, GNUNET_YES, len, UnixAddress::options, plugin, and PLUGIN_NAME.

Referenced by libgnunet_plugin_transport_unix_init().

Here is the call graph for this function:

Here is the caller graph for this function:

get_session_delete_it()

static int get_session_delete_it ( void *  cls, const struct GNUNET_PeerIdentity *  key, void *  value  )

static

Function called on sessions to disconnect.

Parameters

cls	the plugin
key	peer identity (unused)
value	the struct GNUNET_ATS_Session * to disconnect

Returns

GNUNET_YES (always, continue to iterate)

Definition at line 1627 of file plugin_transport_unix.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_ATS_Session *session = value;
 
  unix_plugin_session_disconnect (plugin, session);
  return GNUNET_YES;
}

References GNUNET_YES, plugin, unix_plugin_session_disconnect(), and value.

Referenced by libgnunet_plugin_transport_unix_done(), and unix_plugin_peer_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_peer_disconnect()

static void unix_plugin_peer_disconnect ( void *  cls, const struct GNUNET_PeerIdentity *  target  )

static

Disconnect from a remote node.

Clean up session if we have one for this peer

Parameters

cls	closure for this call (should be handle to Plugin)
target	the peeridentity of the peer to disconnect

Returns

GNUNET_OK on success, GNUNET_SYSERR if the operation failed

Definition at line 1647 of file plugin_transport_unix.c.

{
  struct Plugin *plugin = cls;
 
  GNUNET_CONTAINER_multipeermap_get_multiple (plugin->session_map,
                                              target,
                                              &get_session_delete_it,
                                              plugin);
}

References get_session_delete_it(), GNUNET_CONTAINER_multipeermap_get_multiple(), and plugin.

Referenced by libgnunet_plugin_transport_unix_init().

Here is the call graph for this function:

Here is the caller graph for this function:

send_session_info_iter()

static int send_session_info_iter ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  value  )

static

Return information about the given session to the monitor callback.

Parameters

cls	the struct Plugin with the monitor callback (sic)
peer	peer we send information about
value	our struct GNUNET_ATS_Session to send information about

Returns

GNUNET_OK (continue to iterate)

Definition at line 1669 of file plugin_transport_unix.c.

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

References GNUNET_OK, GNUNET_TRANSPORT_SS_INIT, GNUNET_TRANSPORT_SS_UP, notify_session_monitor(), plugin, and value.

Referenced by unix_plugin_setup_monitor().

Here is the call graph for this function:

Here is the caller graph for this function:

unix_plugin_setup_monitor()

static void unix_plugin_setup_monitor ( void *  cls, GNUNET_TRANSPORT_SessionInfoCallback  sic, void *  sic_cls  )

static

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).

Parameters

cls	closure of the plugin
sic	callback to invoke, NULL to disable monitor; plugin will being by iterating over all active sessions immediately and then enter monitor mode
sic_cls	closure for sic

Definition at line 1695 of file plugin_transport_unix.c.

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

References GNUNET_CONTAINER_multipeermap_iterate(), plugin, send_session_info_iter(), Plugin::sic, and Plugin::sic_cls.

Referenced by libgnunet_plugin_transport_unix_init().

Here is the call graph for this function:

Here is the caller graph for this function:

libgnunet_plugin_transport_unix_init()

void* libgnunet_plugin_transport_unix_init

(

void *

cls

)

The exported method.

Initializes the plugin and returns a struct with the callbacks.

Parameters

cls	the plugin's execution environment

Returns

NULL on error, plugin functions otherwise

Definition at line 1722 of file plugin_transport_unix.c.

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

References _, address_notification(), Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_TRANSPORT_PluginEnvironment::cls, env, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_config_missing(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, GNUNET_YES, LOG, plugin, UNIX_OPTIONS_NONE, UNIX_OPTIONS_USE_ABSTRACT_SOCKETS, unix_plugin_address_pretty_printer(), unix_plugin_address_to_string(), unix_plugin_check_address(), unix_plugin_get_network(), unix_plugin_get_network_for_address(), unix_plugin_get_session(), unix_plugin_peer_disconnect(), unix_plugin_query_keepalive_factor(), unix_plugin_send(), unix_plugin_session_disconnect(), unix_plugin_setup_monitor(), unix_plugin_string_to_address(), unix_plugin_update_session_timeout(), and unix_transport_server_start().

Here is the call graph for this function:

libgnunet_plugin_transport_unix_done()

void* libgnunet_plugin_transport_unix_done

(

void *

cls

)

Shutdown the plugin.

Parameters

cls	the plugin API returned from the initialization function

Returns

NULL (always)

Definition at line 1806 of file plugin_transport_unix.c.

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

References address, UnixAddress::addrlen, Plugin::api, GNUNET_ATS_Session::bytes_in_queue, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_TRANSPORT_PluginFunctions::cls, UNIXMessageWrapper::cont, UNIXMessageWrapper::cont_cls, get_session_delete_it(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_malloc, GNUNET_memcpy, GNUNET_NETWORK_socket_close(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, len, UNIXMessageWrapper::msg, GNUNET_ATS_Session::msgs_in_queue, UNIXMessageWrapper::msgsize, UnixAddress::options, UNIXMessageWrapper::payload, plugin, PLUGIN_NAME, UNIXMessageWrapper::session, and GNUNET_ATS_Session::target.

Here is the call graph for this function: