GNUnet  0.10.x
Data Structures | Macros | Enumerations | Functions
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
 Information about ongoing sessions of the transport client. 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_Sessionlookup_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_Sessionunix_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.

Referenced by receive_ready(), transmit_ready(), unix_plugin_do_write(), and unix_real_send().

◆ PLUGIN_NAME

#define PLUGIN_NAME   "unix"

◆ 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 70 of file plugin_transport_unix.c.

◆ LOG

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

Enumeration Type Documentation

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

54  {
59 
64 };
No special options.
Linux abstract domain sockets should be used.

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
pluginour plugin
sessionsession that changed state
statenew state of the session

Definition at line 326 of file plugin_transport_unix.c.

References GNUNET_ATS_Session::address, GNUNET_TRANSPORT_SessionInfo::address, GNUNET_ATS_Session::bytes_in_queue, GNUNET_SYSERR, GNUNET_TRANSPORT_SessionInfo::is_inbound, GNUNET_ATS_Session::msgs_in_queue, GNUNET_TRANSPORT_SessionInfo::num_bytes_pending, GNUNET_TRANSPORT_SessionInfo::num_msg_pending, GNUNET_TRANSPORT_SessionInfo::session_timeout, Plugin::sic, Plugin::sic_cls, state, GNUNET_TRANSPORT_SessionInfo::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().

329 {
330  struct GNUNET_TRANSPORT_SessionInfo info;
331 
332  if (NULL == plugin->sic)
333  return;
334  memset(&info, 0, sizeof(info));
335  info.state = state;
336  info.is_inbound = GNUNET_SYSERR; /* hard to say */
337  info.num_msg_pending = session->msgs_in_queue;
338  info.num_bytes_pending = session->bytes_in_queue;
339  /* info.receive_delay remains zero as this is not supported by UNIX
340  (cannot selectively not receive from 'some' peer while continuing
341  to receive from others) */
342  info.session_timeout = session->timeout;
343  info.address = session->address;
344  plugin->sic(plugin->sic_cls, session, &info);
345 }
GNUNET_TRANSPORT_SessionInfoCallback sic
Function to call about session status changes.
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
struct GNUNET_HELLO_Address * address
Address.
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
Information about a plugin's session.
enum State state
current state of profiling
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
void * sic_cls
Closure for sic.
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
clsclosure
addrbinary address
addrlenlength of the addr
Returns
string representing the same address

Definition at line 360 of file plugin_transport_unix.c.

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

361 {
362  static char rbuf[1024];
363  struct UnixAddress *ua = (struct UnixAddress *)addr;
364  char *addrstr;
365  size_t addr_str_len;
366  unsigned int off;
367 
368  if ((NULL == addr) || (sizeof(struct UnixAddress) > addrlen))
369  {
370  GNUNET_break(0);
371  return NULL;
372  }
373  addrstr = (char *)&ua[1];
374  addr_str_len = ntohl(ua->addrlen);
375 
376  if (addr_str_len != addrlen - sizeof(struct UnixAddress))
377  {
378  GNUNET_break(0);
379  return NULL;
380  }
381  if ('\0' != addrstr[addr_str_len - 1])
382  {
383  GNUNET_break(0);
384  return NULL;
385  }
386  if (strlen(addrstr) + 1 != addr_str_len)
387  {
388  GNUNET_break(0);
389  return NULL;
390  }
391 
392  off = 0;
393  if ('\0' == addrstr[0])
394  off++;
395  memset(rbuf, 0, sizeof(rbuf));
396  GNUNET_snprintf(rbuf,
397  sizeof(rbuf) - 1,
398  "%s.%u.%s%.*s",
399  PLUGIN_NAME,
400  ntohl(ua->options),
401  (off == 1) ? "@" : "",
402  (int)(addr_str_len - off),
403  &addrstr[off]);
404  return rbuf;
405 }
uint32_t addrlen
Length of the address (path length), in NBO.
#define PLUGIN_NAME
Name of the plugin.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Binary format for an UNIX Domain Socket address in GNUnet.
uint32_t options
Options to use for the address, in NBO.
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
clsclosure with the struct Plugin *
sessionsession to close down
Returns
GNUNET_OK on success

Definition at line 418 of file plugin_transport_unix.c.

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, GNUNET_ATS_Session::bytes_in_queue, Plugin::bytes_in_queue, GNUNET_DATACACHE_PluginEnvironment::cls, UNIXMessageWrapper::cont, UNIXMessageWrapper::cont_cls, Plugin::env, 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, Plugin::msg_head, Plugin::msg_tail, GNUNET_ATS_Session::msgs_in_queue, UNIXMessageWrapper::msgsize, UNIXMessageWrapper::next, notify_session_monitor(), UNIXMessageWrapper::payload, plugin, UNIXMessageWrapper::session, Plugin::session_map, 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().

419 {
420  struct Plugin *plugin = cls;
421  struct UNIXMessageWrapper *msgw;
422  struct UNIXMessageWrapper *next;
423 
425  "Disconnecting session for peer `%s' `%s'\n",
426  GNUNET_i2s(&session->target),
428  session->address->address,
429  session->address->address_length));
430  plugin->env->session_end(plugin->env->cls, session->address, session);
431  next = plugin->msg_head;
432  while (NULL != next)
433  {
434  msgw = next;
435  next = msgw->next;
436  if (msgw->session != session)
437  continue;
438  GNUNET_CONTAINER_DLL_remove(plugin->msg_head, plugin->msg_tail, msgw);
439  session->msgs_in_queue--;
440  GNUNET_assert(session->bytes_in_queue >= msgw->msgsize);
441  session->bytes_in_queue -= msgw->msgsize;
442  GNUNET_assert(plugin->bytes_in_queue >= msgw->msgsize);
443  plugin->bytes_in_queue -= msgw->msgsize;
444  if (NULL != msgw->cont)
445  msgw->cont(msgw->cont_cls,
446  &msgw->session->target,
448  msgw->payload,
449  0);
450  GNUNET_free(msgw->msg);
451  GNUNET_free(msgw);
452  }
455  &session->target,
456  session));
457  GNUNET_STATISTICS_set(plugin->env->stats,
458  "# UNIX sessions active",
460  plugin->session_map),
461  GNUNET_NO);
462  if (NULL != session->timeout_task)
463  {
465  session->timeout_task = NULL;
467  }
470  GNUNET_break(0 == session->bytes_in_queue);
471  GNUNET_break(0 == session->msgs_in_queue);
472  GNUNET_free(session);
473  return GNUNET_OK;
474 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
size_t address_length
Number of bytes in address.
Session is being torn down and about to disappear.
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
const void * address
Binary representation of the address (plugin-specific).
GNUNET_TRANSPORT_TransmitContinuation cont
Function to call upon transmission.
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
#define LOG(kind,...)
struct UNIXMessage * msg
The actual payload (allocated separately right now).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
size_t msgsize
Number of bytes in msg.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct UNIXMessageWrapper * msg_head
Head of queue of messages to transmit.
struct GNUNET_CONTAINER_MultiPeerMap * session_map
Sessions (map from peer identity to struct GNUNET_ATS_Session)
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
Information we track for a message awaiting transmission.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
void * cont_cls
Closure for cont.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
size_t payload
Number of bytes of payload encapsulated in msg.
unsigned long long bytes_in_queue
Number of bytes we currently have in our write queues.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_PeerIdentity target
To whom are we talking to.
struct GNUNET_ATS_Session * session
Session this message belongs to.
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.
struct UNIXMessageWrapper * next
We keep messages in a doubly linked list.
void * cls
Closure to use for callbacks.
#define GNUNET_YES
Definition: gnunet_common.h:77
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
struct UNIXMessageWrapper * msg_tail
Tail of queue of messages to transmit.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_HELLO_address_free(addr)
Free an address.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
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
clsthe struct GNUNET_ATS_Session * to disconnect

Definition at line 483 of file plugin_transport_unix.c.

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

484 {
485  struct GNUNET_ATS_Session *session = cls;
486  struct GNUNET_TIME_Relative left;
487 
488  session->timeout_task = NULL;
490  if (0 != left.rel_value_us)
491  {
492  /* not actually our turn yet, but let's at least update
493  the monitor, it may think we're about to die ... */
495  session,
497  session->timeout_task =
499  return;
500  }
502  "Session %p was idle for %s, disconnecting\n",
503  session,
506  GNUNET_YES));
507  unix_plugin_session_disconnect(session->plugin, session);
508 }
static void session_timeout(void *cls)
Session was idle for too long, so disconnect it.
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
#define LOG(kind,...)
struct Plugin * plugin
Pointer to the global plugin struct.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1237
Information about ongoing sessions of the transport client.
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
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 f...
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don't receive messages from the peer...
This is just an update about the session, the state did not change.
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.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
#define GNUNET_YES
Definition: gnunet_common.h:77
Time for relative time used by GNUnet, in microseconds.
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
sessionsession for which the timeout should be rescheduled

Definition at line 519 of file plugin_transport_unix.c.

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

520 {
521  GNUNET_assert(NULL != session->timeout_task);
522  session->timeout =
524 }
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_TIME_Absolute timeout
When does this session time out.
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don't receive messages from the peer...
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
unixpathpath to convert
[out]sock_lenset to the length of the address
Returns
converted unix path

Definition at line 535 of file plugin_transport_unix.c.

References GNUNET_assert, GNUNET_memcpy, and GNUNET_new.

Referenced by unix_real_send(), and unix_transport_server_start().

536 {
537  struct sockaddr_un *un;
538  size_t slen;
539 
540  GNUNET_assert(0 < strlen(unixpath)); /* sanity check */
541  un = GNUNET_new(struct sockaddr_un);
542  un->sun_family = AF_UNIX;
543  slen = strlen(unixpath);
544  if (slen >= sizeof(un->sun_path))
545  slen = sizeof(un->sun_path) - 1;
546  GNUNET_memcpy(un->sun_path, unixpath, slen);
547  un->sun_path[slen] = '\0';
548  slen = sizeof(struct sockaddr_un);
549 #if HAVE_SOCKADDR_UN_SUN_LEN
550  un->sun_len = (u_char)slen;
551 #endif
552  (*sock_len) = slen;
553  return un;
554 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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
clsthe struct LookupCtx *
keypeer we are looking for (unused)
valuea session
Returns
GNUNET_YES if not found (continue looking), GNUNET_NO on success

Definition at line 582 of file plugin_transport_unix.c.

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

Referenced by lookup_session().

585 {
586  struct LookupCtx *lctx = cls;
587  struct GNUNET_ATS_Session *session = value;
588 
589  if (0 == GNUNET_HELLO_address_cmp(lctx->address, session->address))
590  {
591  lctx->res = session;
592  return GNUNET_NO;
593  }
594  return GNUNET_YES;
595 }
Closure to lookup_queue_it().
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_HELLO_Address * address
Address.
int GNUNET_HELLO_address_cmp(const struct GNUNET_HELLO_Address *a1, const struct GNUNET_HELLO_Address *a2)
Compare two addresses.
Definition: address.c:130
static char * value
Value of the record to add/remove.
Information about ongoing sessions of the transport client.
const struct GNUNET_HELLO_Address * address
Address we are looking for.
struct Queue * res
Location to store the queue, if found.
#define GNUNET_YES
Definition: gnunet_common.h:77
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
pluginthe plugin
addressthe address to find
Returns
NULL if session was not found

Definition at line 606 of file plugin_transport_unix.c.

References address, LookupCtx::address, GNUNET_CONTAINER_multipeermap_get_multiple(), lookup_session_it(), GNUNET_HELLO_Address::peer, LookupCtx::res, and Plugin::session_map.

Referenced by unix_demultiplexer(), and unix_plugin_get_session().

608 {
609  struct LookupCtx lctx;
610 
611  lctx.address = address;
612  lctx.res = NULL;
614  &address->peer,
616  &lctx);
617  return lctx.res;
618 }
Closure to lookup_queue_it().
struct GNUNET_CONTAINER_MultiPeerMap * session_map
Sessions (map from peer identity to struct GNUNET_ATS_Session)
struct GNUNET_PeerIdentity peer
For which peer is this an address?
const struct GNUNET_HELLO_Address * address
Address we are looking for.
static int lookup_session_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Function called to find a session by address.
static char * address
GNS address for this phone.
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
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
clsclosure with the struct Plugin
Returns
keepalive factor

Definition at line 630 of file plugin_transport_unix.c.

Referenced by libgnunet_plugin_transport_unix_init().

631 {
632  return 3;
633 }
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
clsclosure
send_handlewhich handle to send message on
targetwho should receive this message (ignored by UNIX)
msgbufone or more GNUNET_MessageHeader(s) strung together
msgbuf_sizethe size of the msgbuf to send
priorityhow important is the message (ignored by UNIX)
timeoutwhen should we time out (give up) if we can not transmit?
addrthe addr to send the message to, needs to be a sockaddr for us
addrlenthe len of addr
payloadbytes payload to send
contcontinuation 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_clsclosure for cont
Returns
on success the number of bytes written, RETRY for retry, -1 on errors

Definition at line 658 of file plugin_transport_unix.c.

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, Plugin::is_abstract, len, LOG, UnixAddress::options, plugin, RETRY, size, unix_address_to_sockaddr(), and UNIX_OPTIONS_USE_ABSTRACT_SOCKETS.

Referenced by unix_plugin_do_write().

670 {
671  struct Plugin *plugin = cls;
672  ssize_t sent;
673  struct sockaddr_un *un;
674  socklen_t un_len;
675  const char *unixpath;
676 
677  if (NULL == send_handle)
678  {
679  GNUNET_break(0); /* We do not have a send handle */
680  return GNUNET_SYSERR;
681  }
682  if ((NULL == addr) || (0 == addrlen))
683  {
684  GNUNET_break(0); /* Can never send if we don't have an address */
685  return GNUNET_SYSERR;
686  }
687 
688  /* Prepare address */
689  unixpath = (const char *)&addr[1];
690  if (NULL == (un = unix_address_to_sockaddr(unixpath, &un_len)))
691  {
692  GNUNET_break(0);
693  return -1;
694  }
695 
696  if ((GNUNET_YES == plugin->is_abstract) &&
697  (0 != (UNIX_OPTIONS_USE_ABSTRACT_SOCKETS & ntohl(addr->options))))
698  {
699  un->sun_path[0] = '\0';
700  }
701 resend:
702  /* Send the data */
703  sent = GNUNET_NETWORK_socket_sendto(send_handle,
704  msgbuf,
705  msgbuf_size,
706  (const struct sockaddr *)un,
707  un_len);
708  if (GNUNET_SYSERR == sent)
709  {
710  if ((EAGAIN == errno) || (ENOBUFS == errno))
711  {
712  GNUNET_free(un);
713  return RETRY; /* We have to retry later */
714  }
715  if (EMSGSIZE == errno)
716  {
717  socklen_t size = 0;
718  socklen_t len = sizeof(size);
719 
721  send_handle,
722  SOL_SOCKET,
723  SO_SNDBUF,
724  &size,
725  &len);
726  if (size < msgbuf_size)
727  {
729  "Trying to increase socket buffer size from %u to %u for message size %u\n",
730  (unsigned int)size,
731  (unsigned int)((msgbuf_size / 1000) + 2) * 1000,
732  (unsigned int)msgbuf_size);
733  size = ((msgbuf_size / 1000) + 2) * 1000;
734  if (GNUNET_OK ==
736  send_handle,
737  SOL_SOCKET,
738  SO_SNDBUF,
739  &size,
740  sizeof(size)))
741  goto resend; /* Increased buffer size, retry sending */
742  else
743  {
744  /* Could not increase buffer size: error, no retry */
746  GNUNET_free(un);
747  return GNUNET_SYSERR;
748  }
749  }
750  else
751  {
752  /* Buffer is bigger than message: error, no retry
753  * This should never happen!*/
754  GNUNET_break(0);
755  GNUNET_free(un);
756  return GNUNET_SYSERR;
757  }
758  }
759  }
760 
762  "UNIX transmitted %u-byte message to %s (%d: %s)\n",
763  (unsigned int)msgbuf_size,
764  GNUNET_a2s((const struct sockaddr *)un, un_len),
765  (int)sent,
766  (sent < 0) ? strerror(errno) : "ok");
767  GNUNET_free(un);
768  return sent;
769 }
int GNUNET_NETWORK_socket_setsockopt(struct GNUNET_NETWORK_Handle *fd, int level, int option_name, const void *option_value, socklen_t option_len)
Set socket option.
Definition: network.c:871
#define RETRY
Return code we give on &#39;send&#39; if we failed to send right now but it makes sense to retry later...
#define LOG(kind,...)
int GNUNET_NETWORK_socket_getsockopt(const struct GNUNET_NETWORK_Handle *desc, int level, int optname, void *optval, socklen_t *optlen)
Get socket options.
Definition: network.c:671
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static struct sockaddr_un * unix_address_to_sockaddr(const char *unixpath, socklen_t *sock_len)
Convert unix path to a struct sockaddr_un *
ssize_t GNUNET_NETWORK_socket_sendto(const struct GNUNET_NETWORK_Handle *desc, const void *message, size_t length, const struct sockaddr *dest_addr, socklen_t dest_len)
Send data to a particular destination (always non-blocking).
Definition: network.c:838
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages)...
uint32_t options
Options to use for the address, in NBO.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:66
int is_abstract
Are we using an abstract UNIX domain socket?
Handle for a plugin.
Definition: block.c:37
Linux abstract domain sockets should be used.
handle to a socket
Definition: network.c:46
#define GNUNET_YES
Definition: gnunet_common.h:77
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
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
clsclosure ('struct Plugin*')
sessionthe session
Returns
the network type in HBO or GNUNET_SYSERR

Definition at line 780 of file plugin_transport_unix.c.

References GNUNET_assert, and GNUNET_NT_LOOPBACK.

Referenced by libgnunet_plugin_transport_unix_init().

781 {
782  GNUNET_assert(NULL != session);
783  return GNUNET_NT_LOOPBACK;
784 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Loopback (same host).
Definition: gnunet_nt_lib.h:44
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
clsclosure (struct Plugin *)
addressthe address
Returns
the network type

Definition at line 795 of file plugin_transport_unix.c.

References GNUNET_NT_LOOPBACK.

Referenced by libgnunet_plugin_transport_unix_init().

797 {
798  return GNUNET_NT_LOOPBACK;
799 }
Loopback (same host).
Definition: gnunet_nt_lib.h:44
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
clsthe plugin
addressthe address
Returns
the session or NULL of max connections exceeded

Definition at line 811 of file plugin_transport_unix.c.

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, UnixAddress::addrlen, Plugin::env, 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, Plugin::is_abstract, LOG, lookup_session(), notify_session_monitor(), UnixAddress::options, GNUNET_HELLO_Address::peer, plugin, GNUNET_ATS_Session::plugin, Plugin::session_map, 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().

812 {
813  struct Plugin *plugin = cls;
814  struct GNUNET_ATS_Session *session;
815  struct UnixAddress *ua;
816  char *addrstr;
817  uint32_t addr_str_len;
818  uint32_t addr_option;
819 
820  ua = (struct UnixAddress *)address->address;
821  if ((NULL == address->address) || (0 == address->address_length) ||
822  (sizeof(struct UnixAddress) > address->address_length))
823  {
824  GNUNET_break(0);
825  return NULL;
826  }
827  addrstr = (char *)&ua[1];
828  addr_str_len = ntohl(ua->addrlen);
829  addr_option = ntohl(ua->options);
830 
831  if ((0 != (UNIX_OPTIONS_USE_ABSTRACT_SOCKETS & addr_option)) &&
832  (GNUNET_NO == plugin->is_abstract))
833  {
834  return NULL;
835  }
836 
837  if (addr_str_len != address->address_length - sizeof(struct UnixAddress))
838  {
839  return NULL; /* This can be a legacy address */
840  }
841 
842  if ('\0' != addrstr[addr_str_len - 1])
843  {
844  GNUNET_break(0);
845  return NULL;
846  }
847  if (strlen(addrstr) + 1 != addr_str_len)
848  {
849  GNUNET_break(0);
850  return NULL;
851  }
852 
853  /* Check if a session for this address already exists */
854  if (NULL != (session = lookup_session(plugin, address)))
855  {
857  "Found existing session %p for address `%s'\n",
858  session,
860  address->address,
861  address->address_length));
862  return session;
863  }
864 
865  /* create a new session */
866  session = GNUNET_new(struct GNUNET_ATS_Session);
867  session->target = address->peer;
868  session->address = GNUNET_HELLO_address_copy(address);
869  session->plugin = plugin;
870  session->timeout =
872  session->timeout_task =
875  session);
877  "Creating a new session %p for address `%s'\n",
878  session,
880  address->address,
881  address->address_length));
883  plugin->session_map,
884  &address->peer,
885  session,
887  GNUNET_STATISTICS_set(plugin->env->stats,
888  "# UNIX sessions active",
890  plugin->session_map),
891  GNUNET_NO);
894  return session;
895 }
static void session_timeout(void *cls)
Session was idle for too long, so disconnect it.
size_t address_length
Number of bytes in address.
uint32_t addrlen
Length of the address (path length), in NBO.
const void * address
Binary representation of the address (plugin-specific).
struct GNUNET_SCHEDULER_Task * timeout_task
Session timeout task.
#define LOG(kind,...)
struct Plugin * plugin
Pointer to the global plugin struct.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
struct GNUNET_TIME_Absolute timeout
When does this session time out.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_HELLO_Address * address
Address.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Binary format for an UNIX Domain Socket address in GNUnet.
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.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1237
struct GNUNET_CONTAINER_MultiPeerMap * session_map
Sessions (map from peer identity to struct GNUNET_ATS_Session)
Information about ongoing sessions of the transport client.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
static struct GNUNET_ATS_Session * lookup_session(struct Plugin *plugin, const struct GNUNET_HELLO_Address *address)
Find an existing session by address.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
uint32_t options
Options to use for the address, in NBO.
int is_abstract
Are we using an abstract UNIX domain socket?
struct GNUNET_PeerIdentity peer
For which peer is this an address?
Allow multiple values with the same key.
#define GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
After how long do we consider a connection to a peer dead if we don&#39;t receive messages from the peer...
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
Handle for a plugin.
Definition: block.c:37
Linux abstract domain sockets should be used.
struct GNUNET_PeerIdentity target
To whom are we talking to.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_copy(const struct GNUNET_HELLO_Address *address)
Copy an address struct.
Definition: address.c:109
The session was created (first call for each session object).
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.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
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
clsclosure with the struct Plugin *
peerwhich peer was the session for
sessionwhich session is being updated

Definition at line 908 of file plugin_transport_unix.c.

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

Referenced by libgnunet_plugin_transport_unix_init().

911 {
912  struct Plugin *plugin = cls;
913 
914  if (GNUNET_OK !=
916  &session->target,
917  session))
918  {
919  GNUNET_break(0);
920  return;
921  }
923 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_CONTAINER_MultiPeerMap * session_map
Sessions (map from peer identity to struct GNUNET_ATS_Session)
static void reschedule_session_timeout(struct GNUNET_ATS_Session *session)
Increment session timeout due to activity.
int GNUNET_CONTAINER_multipeermap_contains_value(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Check if the map contains the given value under the given key.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_PeerIdentity target
To whom are we talking to.
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
pluginthe main plugin for this transport
senderfrom which peer the message was received
currhdrpointer to the header of the message
uaaddress to look for
ua_lenlength of the address ua

Definition at line 936 of file plugin_transport_unix.c.

References GNUNET_ATS_Session::address, address, GNUNET_DATACACHE_PluginEnvironment::cls, Plugin::env, 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_NAME, reschedule_session_timeout(), GNUNET_MessageHeader::size, unix_plugin_address_to_string(), and unix_plugin_get_session().

Referenced by unix_plugin_do_read().

941 {
942  struct GNUNET_ATS_Session *session;
944 
945  GNUNET_assert(ua_len >= sizeof(struct UnixAddress));
947  "Received message from %s\n",
948  unix_plugin_address_to_string(NULL, ua, ua_len));
949  GNUNET_STATISTICS_update(plugin->env->stats,
950  "# bytes received via UNIX",
951  ntohs(currhdr->size),
952  GNUNET_NO);
953 
954  /* Look for existing session */
956  sender,
957  PLUGIN_NAME,
958  ua,
959  ua_len,
960  GNUNET_HELLO_ADDRESS_INFO_NONE); /* UNIX does not have "inbound" sessions */
961  session = lookup_session(plugin, address);
962  if (NULL == session)
963  {
964  session = unix_plugin_get_session(plugin, address);
965  /* Notify transport and ATS about new inbound session */
966  plugin->env->session_start(NULL,
967  session->address,
968  session,
970  }
971  else
972  {
974  }
975  GNUNET_HELLO_address_free(address);
976  plugin->env->receive(plugin->env->cls, session->address, session, currhdr);
977 }
#define PLUGIN_NAME
Name of the plugin.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_allocate(const struct GNUNET_PeerIdentity *peer, const char *transport_name, const void *address, size_t address_length, enum GNUNET_HELLO_AddressInfo local_info)
Allocate an address struct.
Definition: address.c:73
#define LOG(kind,...)
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_HELLO_Address * address
Address.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
Binary format for an UNIX Domain Socket address in GNUnet.
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.
Information about ongoing sessions of the transport client.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
static struct GNUNET_ATS_Session * lookup_session(struct Plugin *plugin, const struct GNUNET_HELLO_Address *address)
Find an existing session by address.
static void reschedule_session_timeout(struct GNUNET_ATS_Session *session)
Increment session timeout due to activity.
Loopback (same host).
Definition: gnunet_nt_lib.h:44
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...
No additional information.
An address for communicating with a peer.
void * cls
Closure to use for callbacks.
static char * address
GNS address for this phone.
#define GNUNET_HELLO_address_free(addr)
Free an address.
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
pluginthe plugin

Definition at line 986 of file plugin_transport_unix.c.

References UnixAddress::addrlen, buf, csize, UNIX_Sock_Info::desc, 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, UNIXMessage::header, LOG, msg, ret, UNIXMessage::sender, GNUNET_MessageHeader::size, unix_demultiplexer(), UNIX_OPTIONS_NONE, UNIX_OPTIONS_USE_ABSTRACT_SOCKETS, and Plugin::unix_sock.

Referenced by unix_plugin_select_read().

987 {
988  char buf[65536] GNUNET_ALIGN;
989  struct UnixAddress *ua;
990  struct UNIXMessage *msg;
991  struct GNUNET_PeerIdentity sender;
992  struct sockaddr_un un;
993  socklen_t addrlen;
994  ssize_t ret;
995  int offset;
996  int tsize;
997  int is_abstract;
998  char *msgbuf;
999  const struct GNUNET_MessageHeader *currhdr;
1000  uint16_t csize;
1001  size_t ua_len;
1002 
1003  addrlen = sizeof(un);
1004  memset(&un, 0, sizeof(un));
1006  buf,
1007  sizeof(buf),
1008  (struct sockaddr *)&un,
1009  &addrlen);
1010  if ((GNUNET_SYSERR == ret) && ((errno == EAGAIN) || (errno == ENOBUFS)))
1011  return;
1012  if (GNUNET_SYSERR == ret)
1013  {
1015  return;
1016  }
1017  else
1018  {
1020  "Read %d bytes from socket %s\n",
1021  (int)ret,
1022  un.sun_path);
1023  }
1024 
1025  GNUNET_assert(AF_UNIX == (un.sun_family));
1026  is_abstract = GNUNET_NO;
1027  if ('\0' == un.sun_path[0])
1028  {
1029  un.sun_path[0] = '@';
1030  is_abstract = GNUNET_YES;
1031  }
1032 
1033  ua_len = sizeof(struct UnixAddress) + strlen(un.sun_path) + 1;
1034  ua = GNUNET_malloc(ua_len);
1035  ua->addrlen = htonl(strlen(&un.sun_path[0]) + 1);
1036  GNUNET_memcpy(&ua[1], &un.sun_path[0], strlen(un.sun_path) + 1);
1037  if (is_abstract)
1038  ua->options = htonl(UNIX_OPTIONS_USE_ABSTRACT_SOCKETS);
1039  else
1040  ua->options = htonl(UNIX_OPTIONS_NONE);
1041 
1042  msg = (struct UNIXMessage *)buf;
1043  csize = ntohs(msg->header.size);
1044  if ((csize < sizeof(struct UNIXMessage)) || (csize > ret))
1045  {
1046  GNUNET_break_op(0);
1047  GNUNET_free(ua);
1048  return;
1049  }
1050  msgbuf = (char *)&msg[1];
1051  GNUNET_memcpy(&sender, &msg->sender, sizeof(struct GNUNET_PeerIdentity));
1052  offset = 0;
1053  tsize = csize - sizeof(struct UNIXMessage);
1054  while (offset + sizeof(struct GNUNET_MessageHeader) <= tsize)
1055  {
1056  currhdr = (struct GNUNET_MessageHeader *)&msgbuf[offset];
1057  csize = ntohs(currhdr->size);
1058  if ((csize < sizeof(struct GNUNET_MessageHeader)) ||
1059  (csize > tsize - offset))
1060  {
1061  GNUNET_break_op(0);
1062  break;
1063  }
1064  unix_demultiplexer(plugin, &sender, currhdr, ua, ua_len);
1065  offset += csize;
1066  }
1067  GNUNET_free(ua);
1068 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_NETWORK_Handle * desc
The network handle.
#define LOG(kind,...)
struct GNUNET_MessageHeader header
Message header.
No special options.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
static int ret
Final status code.
Definition: gnunet-arm.c:89
Binary format for an UNIX Domain Socket address in GNUnet.
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.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
UNIX Message-Packet header.
static unsigned int csize
struct UNIX_Sock_Info unix_sock
socket that we transmit all data with
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
static char buf[2048]
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
The identity of the host (wraps the signing key of the peer).
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to &#39;struct&#39;s...
Linux abstract domain sockets should be used.
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:77
ssize_t GNUNET_NETWORK_socket_recvfrom(const struct GNUNET_NETWORK_Handle *desc, void *buffer, size_t length, struct sockaddr *src_addr, socklen_t *addrlen)
Read data from a socket (always non-blocking).
Definition: network.c:742
struct GNUNET_PeerIdentity sender
What is the identity of the sender (GNUNET_hash of public key)
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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
pluginhandle to the plugin

Definition at line 1077 of file plugin_transport_unix.c.

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, GNUNET_ATS_Session::bytes_in_queue, Plugin::bytes_in_queue, UNIXMessageWrapper::cont, UNIXMessageWrapper::cont_cls, UNIX_Sock_Info::desc, Plugin::env, 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, Plugin::msg_head, Plugin::msg_tail, GNUNET_ATS_Session::msgs_in_queue, UNIXMessageWrapper::msgsize, notify_session_monitor(), UNIXMessageWrapper::payload, UNIXMessageWrapper::priority, GNUNET_TIME_Relative::rel_value_us, RETRY, UNIXMessageWrapper::session, GNUNET_ATS_Session::target, UNIXMessageWrapper::timeout, unix_real_send(), and Plugin::unix_sock.

Referenced by unix_plugin_select_write().

1078 {
1079  ssize_t sent = 0;
1080  struct UNIXMessageWrapper *msgw;
1081  struct GNUNET_ATS_Session *session;
1082  int did_delete;
1083 
1084  session = NULL;
1085  did_delete = GNUNET_NO;
1086  while (NULL != (msgw = plugin->msg_head))
1087  {
1089  break; /* Message is ready for sending */
1090  /* Message has a timeout */
1091  did_delete = GNUNET_YES;
1093  "Timeout for message with %u bytes \n",
1094  (unsigned int)msgw->msgsize);
1095  GNUNET_CONTAINER_DLL_remove(plugin->msg_head, plugin->msg_tail, msgw);
1096  session = msgw->session;
1097  session->msgs_in_queue--;
1098  GNUNET_assert(session->bytes_in_queue >= msgw->msgsize);
1099  session->bytes_in_queue -= msgw->msgsize;
1100  GNUNET_assert(plugin->bytes_in_queue >= msgw->msgsize);
1101  plugin->bytes_in_queue -= msgw->msgsize;
1102  GNUNET_STATISTICS_set(plugin->env->stats,
1103  "# bytes currently in UNIX buffers",
1104  plugin->bytes_in_queue,
1105  GNUNET_NO);
1106  GNUNET_STATISTICS_update(plugin->env->stats,
1107  "# UNIX bytes discarded",
1108  msgw->msgsize,
1109  GNUNET_NO);
1110  if (NULL != msgw->cont)
1111  msgw->cont(msgw->cont_cls,
1112  &msgw->session->target,
1113  GNUNET_SYSERR,
1114  msgw->payload,
1115  0);
1116  GNUNET_free(msgw->msg);
1117  GNUNET_free(msgw);
1118  }
1119  if (NULL == msgw)
1120  {
1121  if (GNUNET_YES == did_delete)
1123  return; /* Nothing to send at the moment */
1124  }
1125  session = msgw->session;
1126  sent = unix_real_send(plugin,
1127  plugin->unix_sock.desc,
1128  &session->target,
1129  (const char *)msgw->msg,
1130  msgw->msgsize,
1131  msgw->priority,
1132  msgw->timeout,
1133  msgw->session->address->address,
1134  msgw->session->address->address_length,
1135  msgw->payload,
1136  msgw->cont,
1137  msgw->cont_cls);
1138  if (RETRY == sent)
1139  {
1140  GNUNET_STATISTICS_update(plugin->env->stats,
1141  "# UNIX retry attempts",
1142  1,
1143  GNUNET_NO);
1145  return;
1146  }
1147  GNUNET_CONTAINER_DLL_remove(plugin->msg_head, plugin->msg_tail, msgw);
1148  session->msgs_in_queue--;
1149  GNUNET_assert(session->bytes_in_queue >= msgw->msgsize);
1150  session->bytes_in_queue -= msgw->msgsize;
1151  GNUNET_assert(plugin->bytes_in_queue >= msgw->msgsize);
1152  plugin->bytes_in_queue -= msgw->msgsize;
1153  GNUNET_STATISTICS_set(plugin->env->stats,
1154  "# bytes currently in UNIX buffers",
1155  plugin->bytes_in_queue,
1156  GNUNET_NO);
1158  if (GNUNET_SYSERR == sent)
1159  {
1160  /* failed and no retry */
1161  if (NULL != msgw->cont)
1162  msgw->cont(msgw->cont_cls,
1163  &msgw->session->target,
1164  GNUNET_SYSERR,
1165  msgw->payload,
1166  0);
1167  GNUNET_STATISTICS_update(plugin->env->stats,
1168  "# UNIX bytes discarded",
1169  msgw->msgsize,
1170  GNUNET_NO);
1171  GNUNET_free(msgw->msg);
1172  GNUNET_free(msgw);
1173  return;
1174  }
1175  /* successfully sent bytes */
1176  GNUNET_break(sent > 0);
1177  GNUNET_STATISTICS_update(plugin->env->stats,
1178  "# bytes transmitted via UNIX",
1179  msgw->msgsize,
1180  GNUNET_NO);
1181  if (NULL != msgw->cont)
1182  msgw->cont(msgw->cont_cls,
1183  &msgw->session->target,
1184  GNUNET_OK,
1185  msgw->payload,
1186  msgw->msgsize);
1187  GNUNET_free(msgw->msg);
1188  GNUNET_free(msgw);
1189 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
size_t address_length
Number of bytes in address.
uint64_t rel_value_us
The actual value.
const void * address
Binary representation of the address (plugin-specific).
#define RETRY
Return code we give on &#39;send&#39; if we failed to send right now but it makes sense to retry later...
GNUNET_TRANSPORT_TransmitContinuation cont
Function to call upon transmission.
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
struct GNUNET_NETWORK_Handle * desc
The network handle.
#define LOG(kind,...)
struct UNIXMessage * msg
The actual payload (allocated separately right now).
struct GNUNET_TIME_Absolute timeout
Timeout for this message.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
size_t msgsize
Number of bytes in msg.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HELLO_Address * address
Address.
unsigned int priority
Priority of the message (ignored, just dragged along in UNIX).
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct UNIXMessageWrapper * msg_head
Head of queue of messages to transmit.
struct UNIX_Sock_Info unix_sock
socket that we transmit all data with
Information about ongoing sessions of the transport client.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
Information we track for a message awaiting transmission.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
void * cont_cls
Closure for cont.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
size_t payload
Number of bytes of payload encapsulated in msg.
This is just an update about the session, the state did not change.
unsigned long long bytes_in_queue
Number of bytes we currently have in our write queues.
struct GNUNET_PeerIdentity target
To whom are we talking to.
struct GNUNET_ATS_Session * session
Session this message belongs to.
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&#39;ve got the address and send_handle squared away! ...
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.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:331
#define GNUNET_YES
Definition: gnunet_common.h:77
struct UNIXMessageWrapper * msg_tail
Tail of queue of messages to transmit.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsthe plugin handle

Definition at line 1199 of file plugin_transport_unix.c.

References UNIX_Sock_Info::desc, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_READ_READY, GNUNET_TIME_UNIT_FOREVER_REL, plugin, Plugin::read_task, GNUNET_SCHEDULER_TaskContext::reason, tc, unix_plugin_do_read(), and Plugin::unix_sock.

Referenced by unix_transport_server_start().

1200 {
1201  struct Plugin *plugin = cls;
1202  const struct GNUNET_SCHEDULER_TaskContext *tc;
1203 
1204  plugin->read_task = NULL;
1206  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
1207  unix_plugin_do_read(plugin);
1208  plugin->read_task =
1210  plugin->unix_sock.desc,
1212  plugin);
1213 }
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:737
struct GNUNET_NETWORK_Handle * desc
The network handle.
The reading socket is ready.
Context information passed to each scheduler task.
static void unix_plugin_select_read(void *cls)
We have been notified that our socket has something to read.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:410
struct GNUNET_SCHEDULER_Task * read_task
ID of read task.
enum GNUNET_SCHEDULER_Reason reason
Reason why the task is run now.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct UNIX_Sock_Info unix_sock
socket that we transmit all data with
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
static void unix_plugin_do_read(struct Plugin *plugin)
Read from UNIX domain socket (it is ready).
Handle for a plugin.
Definition: block.c:37
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1467
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
clsthe plugin handle

Definition at line 1223 of file plugin_transport_unix.c.

References UNIX_Sock_Info::desc, GNUNET_SCHEDULER_add_write_net(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_WRITE_READY, GNUNET_TIME_UNIT_FOREVER_REL, Plugin::msg_head, plugin, GNUNET_SCHEDULER_TaskContext::reason, tc, unix_plugin_do_write(), Plugin::unix_sock, and Plugin::write_task.

Referenced by unix_plugin_send().

1224 {
1225  struct Plugin *plugin = cls;
1226  const struct GNUNET_SCHEDULER_TaskContext *tc;
1227 
1228  plugin->write_task = NULL;
1231  unix_plugin_do_write(plugin);
1232  if (NULL == plugin->msg_head)
1233  return; /* write queue empty */
1234  plugin->write_task =
1236  plugin->unix_sock.desc,
1238  plugin);
1239 }
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition: scheduler.c:737
static void unix_plugin_select_write(void *cls)
We have been notified that our socket is ready to write.
struct GNUNET_NETWORK_Handle * desc
The network handle.
Context information passed to each scheduler task.
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:410
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1537
enum GNUNET_SCHEDULER_Reason reason
Reason why the task is run now.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct UNIXMessageWrapper * msg_head
Head of queue of messages to transmit.
struct UNIX_Sock_Info unix_sock
socket that we transmit all data with
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
The writing socket is ready.
struct GNUNET_SCHEDULER_Task * write_task
ID of write task.
Handle for a plugin.
Definition: block.c:37
static void unix_plugin_do_write(struct Plugin *plugin)
Write to UNIX domain socket (it is ready).
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
clsclosure
sessionwhich session must be used
msgbufthe message to transmit
msgbuf_sizenumber of bytes in msgbuf
priorityhow important is the message (most plugins will ignore message priority and just FIFO)
tohow 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)
contcontinuation 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_clsclosure 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 1270 of file plugin_transport_unix.c.

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, GNUNET_ATS_Session::bytes_in_queue, Plugin::bytes_in_queue, UNIXMessageWrapper::cont, UNIXMessageWrapper::cont_cls, UNIX_Sock_Info::desc, Plugin::env, 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, LOG, UNIXMessageWrapper::msg, Plugin::msg_head, Plugin::msg_tail, GNUNET_ATS_Session::msgs_in_queue, UNIXMessageWrapper::msgsize, notify_session_monitor(), UNIXMessageWrapper::payload, plugin, UNIXMessageWrapper::priority, UNIXMessageWrapper::session, Plugin::session_map, GNUNET_ATS_Session::target, UNIXMessageWrapper::timeout, unix_plugin_address_to_string(), unix_plugin_select_write(), Plugin::unix_sock, and Plugin::write_task.

Referenced by libgnunet_plugin_transport_unix_init().

1278 {
1279  struct Plugin *plugin = cls;
1280  struct UNIXMessageWrapper *wrapper;
1281  struct UNIXMessage *message;
1282  int ssize;
1283 
1284  if (GNUNET_OK !=
1286  &session->target,
1287  session))
1288  {
1290  "Invalid session for peer `%s' `%s'\n",
1291  GNUNET_i2s(&session->target),
1293  session->address->address,
1294  session->address->address_length));
1295  GNUNET_break(0);
1296  return GNUNET_SYSERR;
1297  }
1299  "Sending %u bytes with session for peer `%s' `%s'\n",
1300  msgbuf_size,
1301  GNUNET_i2s(&session->target),
1303  session->address->address,
1304  session->address->address_length));
1305  ssize = sizeof(struct UNIXMessage) + msgbuf_size;
1306  message = GNUNET_malloc(sizeof(struct UNIXMessage) + msgbuf_size);
1307  message->header.size = htons(ssize);
1308  message->header.type = htons(0);
1309  GNUNET_memcpy(&message->sender,
1310  plugin->env->my_identity,
1311  sizeof(struct GNUNET_PeerIdentity));
1312  GNUNET_memcpy(&message[1], msgbuf, msgbuf_size);
1313  wrapper = GNUNET_new(struct UNIXMessageWrapper);
1314  wrapper->msg = message;
1315  wrapper->msgsize = ssize;
1316  wrapper->payload = msgbuf_size;
1317  wrapper->priority = priority;
1319  wrapper->cont = cont;
1320  wrapper->cont_cls = cont_cls;
1321  wrapper->session = session;
1323  plugin->msg_tail,
1324  wrapper);
1325  plugin->bytes_in_queue += ssize;
1326  session->bytes_in_queue += ssize;
1327  session->msgs_in_queue++;
1328  GNUNET_STATISTICS_set(plugin->env->stats,
1329  "# bytes currently in UNIX buffers",
1330  plugin->bytes_in_queue,
1331  GNUNET_NO);
1333  if (NULL == plugin->write_task)
1334  plugin->write_task =
1336  plugin->unix_sock.desc,
1338  plugin);
1339  return ssize;
1340 }
size_t address_length
Number of bytes in address.
const void * address
Binary representation of the address (plugin-specific).
GNUNET_TRANSPORT_TransmitContinuation cont
Function to call upon transmission.
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
static void unix_plugin_select_write(void *cls)
We have been notified that our socket is ready to write.
struct GNUNET_NETWORK_Handle * desc
The network handle.
#define LOG(kind,...)
struct UNIXMessage * msg
The actual payload (allocated separately right now).
struct GNUNET_TIME_Absolute timeout
Timeout for this message.
size_t msgsize
Number of bytes in msg.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_write_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1537
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_add(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Relative duration)
Add a given relative duration to the given start time.
Definition: time.c:393
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_HELLO_Address * address
Address.
unsigned int priority
Priority of the message (ignored, just dragged along in UNIX).
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct UNIXMessageWrapper * msg_head
Head of queue of messages to transmit.
UNIX Message-Packet header.
struct UNIX_Sock_Info unix_sock
socket that we transmit all data with
struct GNUNET_CONTAINER_MultiPeerMap * session_map
Sessions (map from peer identity to struct GNUNET_ATS_Session)
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
Information we track for a message awaiting transmission.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
void * cont_cls
Closure for cont.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
size_t payload
Number of bytes of payload encapsulated in msg.
struct GNUNET_SCHEDULER_Task * write_task
ID of write task.
This is just an update about the session, the state did not change.
The identity of the host (wraps the signing key of the peer).
int GNUNET_CONTAINER_multipeermap_contains_value(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Check if the map contains the given value under the given key.
unsigned long long bytes_in_queue
Number of bytes we currently have in our write queues.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_PeerIdentity target
To whom are we talking to.
struct GNUNET_ATS_Session * session
Session this message belongs to.
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.
struct UNIXMessageWrapper * msg_tail
Tail of queue of messages to transmit.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_malloc(size)
Wrapper around malloc.
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
clsclosure for server start, should be a struct Plugin *
Returns
number of sockets created or GNUNET_SYSERR on error

Definition at line 1350 of file plugin_transport_unix.c.

References _, UNIX_Sock_Info::desc, 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, Plugin::is_abstract, LOG, plugin, Plugin::read_task, unix_address_to_sockaddr(), unix_plugin_select_read(), Plugin::unix_sock, and Plugin::unix_socket_path.

Referenced by libgnunet_plugin_transport_unix_init().

1351 {
1352  struct Plugin *plugin = cls;
1353  struct sockaddr_un *un;
1354  socklen_t un_len;
1355 
1356  un = unix_address_to_sockaddr(plugin->unix_socket_path, &un_len);
1357  if (GNUNET_YES == plugin->is_abstract)
1358  {
1359  plugin->unix_socket_path[0] = '@';
1360  un->sun_path[0] = '\0';
1361  }
1362  plugin->unix_sock.desc =
1363  GNUNET_NETWORK_socket_create(AF_UNIX, SOCK_DGRAM, 0);
1364  if (NULL == plugin->unix_sock.desc)
1365  {
1367  GNUNET_free(un);
1368  return GNUNET_SYSERR;
1369  }
1370  if ('\0' != un->sun_path[0])
1371  {
1372  if (GNUNET_OK != GNUNET_DISK_directory_create_for_file(un->sun_path))
1373  {
1375  _("Cannot create path to `%s'\n"),
1376  un->sun_path);
1378  plugin->unix_sock.desc = NULL;
1379  GNUNET_free(un);
1380  return GNUNET_SYSERR;
1381  }
1382  }
1384  (const struct sockaddr *)un,
1385  un_len))
1386  {
1388  LOG(GNUNET_ERROR_TYPE_ERROR, _("Cannot bind to `%s'\n"), un->sun_path);
1390  plugin->unix_sock.desc = NULL;
1391  GNUNET_free(un);
1392  return GNUNET_SYSERR;
1393  }
1394  LOG(GNUNET_ERROR_TYPE_DEBUG, "Bound to `%s'\n", plugin->unix_socket_path);
1395  plugin->read_task =
1397  plugin->unix_sock.desc,
1399  plugin);
1400  GNUNET_free(un);
1401  return 1;
1402 }
struct GNUNET_NETWORK_Handle * desc
The network handle.
char * unix_socket_path
Path of our unix domain socket (/tmp/unix-plugin)
#define LOG(kind,...)
static void unix_plugin_select_read(void *cls)
We have been notified that our socket has something to read.
int GNUNET_NETWORK_socket_bind(struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Bind a socket to a particular address.
Definition: network.c:474
int GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:681
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_SCHEDULER_Task * read_task
ID of read task.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
struct UNIX_Sock_Info unix_sock
socket that we transmit all data with
static struct sockaddr_un * unix_address_to_sockaddr(const char *unixpath, socklen_t *sock_len)
Convert unix path to a struct sockaddr_un *
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int is_abstract
Are we using an abstract UNIX domain socket?
Handle for a plugin.
Definition: block.c:37
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_read_net(struct GNUNET_TIME_Relative delay, struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when the specified file descriptor is ready f...
Definition: scheduler.c:1467
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:548
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:900
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
clsclosure, should be our handle to the Plugin
addrpointer to the address
addrlenlength of addr
Returns
GNUNET_OK if this is a plausible address for this peer and transport, GNUNET_SYSERR if not

Definition at line 1422 of file plugin_transport_unix.c.

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

Referenced by libgnunet_plugin_transport_unix_init().

1423 {
1424  struct Plugin *plugin = cls;
1425  const struct UnixAddress *ua = addr;
1426  char *addrstr;
1427  size_t addr_str_len;
1428 
1429  if ((NULL == addr) || (0 == addrlen) ||
1430  (sizeof(struct UnixAddress) > addrlen))
1431  {
1432  GNUNET_break(0);
1433  return GNUNET_SYSERR;
1434  }
1435  addrstr = (char *)&ua[1];
1436  addr_str_len = ntohl(ua->addrlen);
1437  if ('\0' != addrstr[addr_str_len - 1])
1438  {
1439  GNUNET_break(0);
1440  return GNUNET_SYSERR;
1441  }
1442  if (strlen(addrstr) + 1 != addr_str_len)
1443  {
1444  GNUNET_break(0);
1445  return GNUNET_SYSERR;
1446  }
1447 
1448  if (0 == strcmp(plugin->unix_socket_path, addrstr))
1449  return GNUNET_OK;
1450  return GNUNET_SYSERR;
1451 }
uint32_t addrlen
Length of the address (path length), in NBO.
char * unix_socket_path
Path of our unix domain socket (/tmp/unix-plugin)
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Binary format for an UNIX Domain Socket address in GNUnet.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
Handle for a plugin.
Definition: block.c:37
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
clsclosure
typename of the transport that generated the address
addrone of the addresses of the host, NULL for the last address the specific address format depends on the transport
addrlenlength of the addr
numericshould (IP) addresses be displayed in numeric form?
timeoutafter how long should we give up?
ascfunction to call on each string
asc_clsclosure for asc

Definition at line 1469 of file plugin_transport_unix.c.

References GNUNET_OK, GNUNET_SYSERR, ret, and unix_plugin_address_to_string().

Referenced by libgnunet_plugin_transport_unix_init().

1477 {
1478  const char *ret;
1479 
1480  if ((NULL != addr) && (addrlen > 0))
1481  ret = unix_plugin_address_to_string(NULL, addr, addrlen);
1482  else
1483  ret = NULL;
1484  asc(asc_cls, ret, (NULL == ret) ? GNUNET_SYSERR : GNUNET_OK);
1485  asc(asc_cls, NULL, GNUNET_OK);
1486 }
uint32_t addrlen
Length of the address (path length), in NBO.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int ret
Final status code.
Definition: gnunet-arm.c:89
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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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
clsclosure (struct Plugin *)
addrstring address
addrlenlength of the addr (strlen(addr) + '\0')
buflocation to store the buffer If the function returns GNUNET_SYSERR, its contents are undefined.
addedlength of created address
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1502 of file plugin_transport_unix.c.

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

Referenced by libgnunet_plugin_transport_unix_init().

1507 {
1508  struct UnixAddress *ua;
1509  char *address;
1510  char *plugin;
1511  char *optionstr;
1512  uint32_t options;
1513  size_t ua_size;
1514 
1515  /* Format unix.options.address */
1516  address = NULL;
1517  plugin = NULL;
1518  optionstr = NULL;
1519 
1520  if ((NULL == addr) || (addrlen == 0))
1521  {
1522  GNUNET_break(0);
1523  return GNUNET_SYSERR;
1524  }
1525  if ('\0' != addr[addrlen - 1])
1526  {
1527  GNUNET_break(0);
1528  return GNUNET_SYSERR;
1529  }
1530  if (strlen(addr) != addrlen - 1)
1531  {
1532  GNUNET_break(0);
1533  return GNUNET_SYSERR;
1534  }
1535  plugin = GNUNET_strdup(addr);
1536  optionstr = strchr(plugin, '.');
1537  if (NULL == optionstr)
1538  {
1539  GNUNET_break(0);
1540  GNUNET_free(plugin);
1541  return GNUNET_SYSERR;
1542  }
1543  optionstr[0] = '\0';
1544  optionstr++;
1545  options = atol(optionstr);
1546  address = strchr(optionstr, '.');
1547  if (NULL == address)
1548  {
1549  GNUNET_break(0);
1550  GNUNET_free(plugin);
1551  return GNUNET_SYSERR;
1552  }
1553  address[0] = '\0';
1554  address++;
1555  if (0 != strcmp(plugin, PLUGIN_NAME))
1556  {
1557  GNUNET_break(0);
1558  GNUNET_free(plugin);
1559  return GNUNET_SYSERR;
1560  }
1561 
1562  ua_size = sizeof(struct UnixAddress) + strlen(address) + 1;
1563  ua = GNUNET_malloc(ua_size);
1564  ua->options = htonl(options);
1565  ua->addrlen = htonl(strlen(address) + 1);
1566  GNUNET_memcpy(&ua[1], address, strlen(address) + 1);
1567  GNUNET_free(plugin);
1568 
1569  (*buf) = ua;
1570  (*added) = ua_size;
1571  return GNUNET_OK;
1572 }
uint32_t addrlen
Length of the address (path length), in NBO.
#define PLUGIN_NAME
Name of the plugin.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Binary format for an UNIX Domain Socket address in GNUnet.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static char * address
GNS address for this phone.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function:

◆ address_notification()

static void address_notification ( void *  cls)
static

Notify transport service about address.

Parameters
clsthe plugin

Definition at line 1581 of file plugin_transport_unix.c.

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

Referenced by libgnunet_plugin_transport_unix_init().

1582 {
1583  struct Plugin *plugin = cls;
1584  struct GNUNET_HELLO_Address *address;
1585  size_t len;
1586  struct UnixAddress *ua;
1587  char *unix_path;
1588 
1589  len = sizeof(struct UnixAddress) + strlen(plugin->unix_socket_path) + 1;
1590  ua = GNUNET_malloc(len);
1591  ua->options = htonl(plugin->myoptions);
1592  ua->addrlen = htonl(strlen(plugin->unix_socket_path) + 1);
1593  unix_path = (char *)&ua[1];
1594  GNUNET_memcpy(unix_path,
1595  plugin->unix_socket_path,
1596  strlen(plugin->unix_socket_path) + 1);
1597 
1598  plugin->address_update_task = NULL;
1599  address = GNUNET_HELLO_address_allocate(plugin->env->my_identity,
1600  PLUGIN_NAME,
1601  ua,
1602  len,
1604  plugin->env->notify_address(plugin->env->cls, GNUNET_YES, address);
1605  GNUNET_free(ua);
1606  GNUNET_free(address);
1607 }
#define PLUGIN_NAME
Name of the plugin.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_allocate(const struct GNUNET_PeerIdentity *peer, const char *transport_name, const void *address, size_t address_length, enum GNUNET_HELLO_AddressInfo local_info)
Allocate an address struct.
Definition: address.c:73
char * unix_socket_path
Path of our unix domain socket (/tmp/unix-plugin)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_SCHEDULER_Task * address_update_task
ID of task used to update our addresses when one expires.
Binary format for an UNIX Domain Socket address in GNUnet.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
No additional information.
Handle for a plugin.
Definition: block.c:37
An address for communicating with a peer.
void * cls
Closure to use for callbacks.
#define GNUNET_YES
Definition: gnunet_common.h:77
uint32_t myoptions
Address options.
static char * address
GNS address for this phone.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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
clsthe plugin
keypeer identity (unused)
valuethe struct GNUNET_ATS_Session * to disconnect
Returns
GNUNET_YES (always, continue to iterate)

Definition at line 1619 of file plugin_transport_unix.c.

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

Referenced by libgnunet_plugin_transport_unix_done(), and unix_plugin_peer_disconnect().

1622 {
1623  struct Plugin *plugin = cls;
1624  struct GNUNET_ATS_Session *session = value;
1625 
1626  unix_plugin_session_disconnect(plugin, session);
1627  return GNUNET_YES;
1628 }
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
static char * value
Value of the record to add/remove.
Information about ongoing sessions of the transport client.
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 f...
Handle for a plugin.
Definition: block.c:37
#define GNUNET_YES
Definition: gnunet_common.h:77
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
clsclosure for this call (should be handle to Plugin)
targetthe peeridentity of the peer to disconnect
Returns
GNUNET_OK on success, GNUNET_SYSERR if the operation failed

Definition at line 1639 of file plugin_transport_unix.c.

References get_session_delete_it(), GNUNET_CONTAINER_multipeermap_get_multiple(), plugin, and Plugin::session_map.

Referenced by libgnunet_plugin_transport_unix_init().

1641 {
1642  struct Plugin *plugin = cls;
1643 
1645  target,
1647  plugin);
1648 }
static int get_session_delete_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Function called on sessions to disconnect.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_CONTAINER_MultiPeerMap * session_map
Sessions (map from peer identity to struct GNUNET_ATS_Session)
Handle for a plugin.
Definition: block.c:37
int GNUNET_CONTAINER_multipeermap_get_multiple(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
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
clsthe struct Plugin with the monitor callback (sic)
peerpeer we send information about
valueour struct GNUNET_ATS_Session to send information about
Returns
GNUNET_OK (continue to iterate)

Definition at line 1661 of file plugin_transport_unix.c.

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

Referenced by unix_plugin_setup_monitor().

1664 {
1665  struct Plugin *plugin = cls;
1666  struct GNUNET_ATS_Session *session = value;
1667 
1670  return GNUNET_OK;
1671 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
static char * value
Value of the record to add/remove.
Information about ongoing sessions of the transport client.
Handle for a plugin.
Definition: block.c:37
The session was created (first call for each session object).
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.
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
clsclosure of the plugin
siccallback to invoke, NULL to disable monitor; plugin will being by iterating over all active sessions immediately and then enter monitor mode
sic_clsclosure for sic

Definition at line 1687 of file plugin_transport_unix.c.

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

Referenced by libgnunet_plugin_transport_unix_init().

1690 {
1691  struct Plugin *plugin = cls;
1692 
1693  plugin->sic = sic;
1694  plugin->sic_cls = sic_cls;
1695  if (NULL != sic)
1696  {
1699  plugin);
1700  /* signal end of first iteration */
1701  sic(sic_cls, NULL, NULL);
1702  }
1703 }
GNUNET_TRANSPORT_SessionInfoCallback sic
Function to call about session status changes.
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.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_CONTAINER_MultiPeerMap * session_map
Sessions (map from peer identity to struct GNUNET_ATS_Session)
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
Handle for a plugin.
Definition: block.c:37
void * sic_cls
Closure for sic.
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
clsthe plugin's execution environment
Returns
NULL on error, plugin functions otherwise

Definition at line 1714 of file plugin_transport_unix.c.

References _, address_notification(), GNUNET_TRANSPORT_PluginFunctions::address_pretty_printer, GNUNET_TRANSPORT_PluginFunctions::address_to_string, Plugin::address_update_task, Plugin::api, GNUNET_DATACACHE_PluginEnvironment::cfg, GNUNET_TRANSPORT_PluginEnvironment::cfg, GNUNET_TRANSPORT_PluginFunctions::check_address, GNUNET_TRANSPORT_PluginEnvironment::cls, GNUNET_TRANSPORT_PluginFunctions::cls, GNUNET_TRANSPORT_PluginFunctions::disconnect_peer, GNUNET_TRANSPORT_PluginFunctions::disconnect_session, env, Plugin::env, GNUNET_TRANSPORT_PluginFunctions::get_network, GNUNET_TRANSPORT_PluginFunctions::get_network_for_address, GNUNET_TRANSPORT_PluginFunctions::get_session, 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, Plugin::is_abstract, LOG, Plugin::myoptions, plugin, GNUNET_TRANSPORT_PluginFunctions::query_keepalive_factor, GNUNET_TRANSPORT_PluginEnvironment::receive, GNUNET_TRANSPORT_PluginFunctions::send, Plugin::session_map, GNUNET_TRANSPORT_PluginFunctions::setup_monitor, GNUNET_TRANSPORT_PluginFunctions::string_to_address, 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(), Plugin::unix_socket_path, unix_transport_server_start(), and GNUNET_TRANSPORT_PluginFunctions::update_session_timeout.

1715 {
1718  struct Plugin *plugin;
1719  int sockets_created;
1720 
1721  if (NULL == env->receive)
1722  {
1723  /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
1724  initialze the plugin or the API */
1726  api->cls = NULL;
1730  return api;
1731  }
1732 
1733  plugin = GNUNET_new(struct Plugin);
1734  if (GNUNET_OK !=
1736  "transport-unix",
1737  "UNIXPATH",
1738  &plugin->unix_socket_path))
1739  {
1741  "transport-unix",
1742  "UNIXPATH");
1743  GNUNET_free(plugin);
1744  return NULL;
1745  }
1746 
1747  plugin->env = env;
1748 
1749  /* Initialize my flags */
1750 #ifdef LINUX
1751  plugin->is_abstract =
1753  "testing",
1754  "USE_ABSTRACT_SOCKETS");
1755 #endif
1756  plugin->myoptions = UNIX_OPTIONS_NONE;
1757  if (GNUNET_YES == plugin->is_abstract)
1759 
1761  api->cls = plugin;
1763  api->send = &unix_plugin_send;
1775  sockets_created = unix_transport_server_start(plugin);
1776  if ((0 == sockets_created) || (GNUNET_SYSERR == sockets_created))
1777  {
1778  LOG(GNUNET_ERROR_TYPE_WARNING, _("Failed to open UNIX listen socket\n"));
1779  GNUNET_free(api);
1780  GNUNET_free(plugin->unix_socket_path);
1781  GNUNET_free(plugin);
1782  return NULL;
1783  }
1785  plugin->address_update_task =
1787  return api;
1788 }
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 correspo...
GNUNET_TRANSPORT_CreateSession get_session
Function that will be called tell the plugin to create a session object.
GNUNET_TRANSPORT_AddressToString address_to_string
Function that will be called to convert a binary address to a string (numeric conversion only)...
char * unix_socket_path
Path of our unix domain socket (/tmp/unix-plugin)
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
#define LOG(kind,...)
GNUNET_TRANSPORT_TransmitFunction send
Function that the transport service will use to transmit data to another peer.
GNUNET_TRANSPORT_DisconnectPeerFunction disconnect_peer
Function that can be used to force the plugin to disconnect from the given peer and cancel all previo...
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.
No special options.
GNUNET_TRANSPORT_DisconnectSessionFunction disconnect_session
Function that can be used to force the plugin to disconnect from the given peer and cancel all previo...
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
GNUNET_TRANSPORT_SessionMonitorSetup setup_monitor
Function to monitor the sessions managed by the plugin.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
struct GNUNET_SCHEDULER_Task * address_update_task
ID of task used to update our addresses when one expires.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:46
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
GNUNET_TRANSPORT_PluginReceiveCallback receive
Function that should be called by the transport plugin whenever a message is received.
GNUNET_TRANSPORT_UpdateSessionTimeout update_session_timeout
Function that will be called whenever the transport service wants to notify the plugin that a session...
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...
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.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
void * cls
Closure for the various callbacks.
void * cls
Closure for all of the callbacks.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
static void address_notification(void *cls)
Notify transport service about address.
GNUNET_TRANSPORT_StringToAddress string_to_address
Function that will be called to convert a string address to binary (numeric conversion only)...
struct GNUNET_CONTAINER_MultiPeerMap * session_map
Sessions (map from peer identity to struct GNUNET_ATS_Session)
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
The transport service will pass a pointer to a struct of this type as the first and only argument to ...
static void unix_plugin_peer_disconnect(void *cls, const struct GNUNET_PeerIdentity *target)
Disconnect from a remote node.
GNUNET_TRANSPORT_GetNetworkType get_network
Function to obtain the network type for a session.
static enum GNUNET_NetworkType unix_plugin_get_network(void *cls, struct GNUNET_ATS_Session *session)
Function obtain the network type for a session.
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...
static void unix_plugin_setup_monitor(void *cls, GNUNET_TRANSPORT_SessionInfoCallback sic, void *sic_cls)
Begin monitoring sessions of a plugin.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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.
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.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
int is_abstract
Are we using an abstract UNIX domain socket?
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 f...
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
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...
static unsigned int unix_plugin_query_keepalive_factor(void *cls)
Function that is called to get the keepalive factor.
GNUNET_TRANSPORT_QueryKeepaliveFactorFunction query_keepalive_factor
Function that is used to query keepalive factor.
Handle for a plugin.
Definition: block.c:37
Linux abstract domain sockets should be used.
int GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
GNUNET_TRANSPORT_AddressPrettyPrinter address_pretty_printer
Function to pretty-print addresses.
#define GNUNET_YES
Definition: gnunet_common.h:77
uint32_t myoptions
Address options.
GNUNET_TRANSPORT_CheckAddress check_address
Function that will be called to check if a binary address for this plugin is well-formed and correspo...
int GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
static int unix_transport_server_start(void *cls)
Create a slew of UNIX sockets.
#define GNUNET_free(ptr)
Wrapper around free.
GNUNET_TRANSPORT_GetNetworkTypeForAddress get_network_for_address
Function to obtain the network type for an address.
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
clsthe plugin API returned from the initialization function
Returns
NULL (always)

Definition at line 1798 of file plugin_transport_unix.c.

References address, GNUNET_ATS_Session::bytes_in_queue, 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, UNIXMessageWrapper::payload, plugin, PLUGIN_NAME, UNIXMessageWrapper::session, and GNUNET_ATS_Session::target.

1799 {
1800  struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
1801  struct Plugin *plugin = api->cls;
1802  struct GNUNET_HELLO_Address *address;
1803  struct UNIXMessageWrapper *msgw;
1804  struct UnixAddress *ua;
1805  size_t len;
1806  struct GNUNET_ATS_Session *session;
1807 
1808  if (NULL == plugin)
1809  {
1810  GNUNET_free(api);
1811  return NULL;
1812  }
1813  len = sizeof(struct UnixAddress) + strlen(plugin->unix_socket_path) + 1;
1814  ua = GNUNET_malloc(len);
1815  ua->options = htonl(plugin->myoptions);
1816  ua->addrlen = htonl(strlen(plugin->unix_socket_path) + 1);
1817  GNUNET_memcpy(&ua[1],
1818  plugin->unix_socket_path,
1819  strlen(plugin->unix_socket_path) + 1);
1820  address = GNUNET_HELLO_address_allocate(plugin->env->my_identity,
1821  PLUGIN_NAME,
1822  ua,
1823  len,
1825  plugin->env->notify_address(plugin->env->cls, GNUNET_NO, address);
1826 
1827  GNUNET_free(address);
1828  GNUNET_free(ua);
1829 
1830  while (NULL != (msgw = plugin->msg_head))
1831  {
1832  GNUNET_CONTAINER_DLL_remove(plugin->msg_head, plugin->msg_tail, msgw);
1833  session = msgw->session;
1834  session->msgs_in_queue--;
1835  GNUNET_assert(session->bytes_in_queue >= msgw->msgsize);
1836  session->bytes_in_queue -= msgw->msgsize;
1837  GNUNET_assert(plugin->bytes_in_queue >= msgw->msgsize);
1838  plugin->bytes_in_queue -= msgw->msgsize;
1839  if (NULL != msgw->cont)
1840  msgw->cont(msgw->cont_cls,
1841  &msgw->session->target,
1842  GNUNET_SYSERR,
1843  msgw->payload,
1844  0);
1845  GNUNET_free(msgw->msg);
1846  GNUNET_free(msgw);
1847  }
1848 
1849  if (NULL != plugin->read_task)
1850  {
1852  plugin->read_task = NULL;
1853  }
1854  if (NULL != plugin->write_task)
1855  {
1857  plugin->write_task = NULL;
1858  }
1859  if (NULL != plugin->address_update_task)
1860  {
1862  plugin->address_update_task = NULL;
1863  }
1864  if (NULL != plugin->unix_sock.desc)
1865  {
1868  plugin->unix_sock.desc = NULL;
1869  }
1872  plugin);
1874  GNUNET_break(0 == plugin->bytes_in_queue);
1875  GNUNET_free(plugin->unix_socket_path);
1876  GNUNET_free(plugin);
1877  GNUNET_free(api);
1878  return NULL;
1879 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define PLUGIN_NAME
Name of the plugin.
struct GNUNET_HELLO_Address * GNUNET_HELLO_address_allocate(const struct GNUNET_PeerIdentity *peer, const char *transport_name, const void *address, size_t address_length, enum GNUNET_HELLO_AddressInfo local_info)
Allocate an address struct.
Definition: address.c:73
GNUNET_TRANSPORT_TransmitContinuation cont
Function to call upon transmission.
unsigned int msgs_in_queue
Number of messages waiting for transmission to this peer.
struct GNUNET_NETWORK_Handle * desc
The network handle.
char * unix_socket_path
Path of our unix domain socket (/tmp/unix-plugin)
struct UNIXMessage * msg
The actual payload (allocated separately right now).
static int get_session_delete_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Function called on sessions to disconnect.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
size_t msgsize
Number of bytes in msg.
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_SCHEDULER_Task * read_task
ID of read task.
unsigned long long bytes_in_queue
Number of bytes waiting for transmission to this peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_SCHEDULER_Task * address_update_task
ID of task used to update our addresses when one expires.
Binary format for an UNIX Domain Socket address in GNUnet.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct UNIXMessageWrapper * msg_head
Head of queue of messages to transmit.
void * cls
Closure for all of the callbacks.
struct UNIX_Sock_Info unix_sock
socket that we transmit all data with
struct GNUNET_CONTAINER_MultiPeerMap * session_map
Sessions (map from peer identity to struct GNUNET_ATS_Session)
Information about ongoing sessions of the transport client.
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
Information we track for a message awaiting transmission.
void * cont_cls
Closure for cont.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
size_t payload
Number of bytes of payload encapsulated in msg.
struct GNUNET_SCHEDULER_Task * write_task
ID of write task.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
No additional information.
unsigned long long bytes_in_queue
Number of bytes we currently have in our write queues.
Handle for a plugin.
Definition: block.c:37
struct GNUNET_PeerIdentity target
To whom are we talking to.
An address for communicating with a peer.
struct GNUNET_ATS_Session * session
Session this message belongs to.
void * cls
Closure to use for callbacks.
uint32_t myoptions
Address options.
static char * address
GNS address for this phone.
struct UNIXMessageWrapper * msg_tail
Tail of queue of messages to transmit.
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:548
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
Here is the call graph for this function: