GNUnet  0.11.x
Data Structures | Macros | Functions | Variables
gnunet-communicator-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_protocols.h"
#include "gnunet_constants.h"
#include "gnunet_nt_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_communication_service.h"
Include dependency graph for gnunet-communicator-unix.c:

Go to the source code of this file.

Data Structures

struct  UNIXMessage
 UNIX Message-Packet header. More...
 
struct  Queue
 Handle for a queue. More...
 
struct  LookupCtx
 Closure to lookup_queue_it(). More...
 

Macros

#define DEFAULT_MAX_QUEUE_LENGTH   8000
 How many messages do we keep at most in the queue to the transport service before we start to drop (default, can be changed via the configuration file). More...
 
#define COMMUNICATOR_ADDRESS_PREFIX   "unix"
 Address prefix used by the communicator. More...
 
#define COMMUNICATOR_CONFIG_SECTION   "communicator-unix"
 Configuration section used by the communicator. More...
 
#define UNIX_MTU   UINT16_MAX
 Our MTU. More...
 

Functions

static void queue_destroy (struct Queue *queue)
 Functions with this signature are called whenever we need to close a queue due to a disconnect or failure to establish a connection. More...
 
static void queue_timeout (void *cls)
 Queue was idle for too long, so disconnect it. More...
 
static void reschedule_queue_timeout (struct Queue *queue)
 Increment queue 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_queue_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Function called to find a queue by address. More...
 
static struct Queuelookup_queue (const struct GNUNET_PeerIdentity *peer, const struct sockaddr_un *un, socklen_t un_len)
 Find an existing queue by address. More...
 
static void select_write_cb (void *cls)
 We have been notified that our socket is ready to write. More...
 
static void mq_send (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
 Signature of functions implementing the sending functionality of a message queue. More...
 
static void mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Signature of functions implementing the destruction of a message queue. More...
 
static void mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Implementation function that cancels the currently sent message. More...
 
static void mq_error (void *cls, enum GNUNET_MQ_Error error)
 Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...
 
static struct Queuesetup_queue (const struct GNUNET_PeerIdentity *target, enum GNUNET_TRANSPORT_ConnectionStatus cs, const struct sockaddr_un *un, socklen_t un_len)
 Creates a new outbound queue the transport service will use to send data to another peer. More...
 
static void select_read_cb (void *cls)
 We have been notified that our socket has something to read. More...
 
static void receive_complete_cb (void *cls, int success)
 Function called when message was successfully passed to transport service. More...
 
static int mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
 Function called by the transport service to initialize a message queue given address information about another peer. More...
 
static int get_queue_delete_it (void *cls, const struct GNUNET_PeerIdentity *target, void *value)
 Iterator over all message queues to clean up. More...
 
static void do_shutdown (void *cls)
 Shutdown the UNIX communicator. More...
 
static void enc_notify_cb (void *cls, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg)
 Function called when the transport service has received an acknowledgement for this communicator (!) via a different return path. More...
 
static void run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 Setup communicator and launch network interactions. More...
 
int main (int argc, char *const *argv)
 The main function for the UNIX communicator. More...
 

Variables

static struct GNUNET_PeerIdentity my_identity
 My Peer Identity. More...
 
static struct GNUNET_SCHEDULER_Taskread_task
 ID of read task. More...
 
static struct GNUNET_SCHEDULER_Taskwrite_task
 ID of write task. More...
 
static unsigned long long delivering_messages
 Number of messages we currently have in our queues towards the transport service. More...
 
static unsigned long long max_queue_length
 Maximum queue length before we stop reading towards the transport service. More...
 
static struct GNUNET_STATISTICS_Handlestats
 For logging statistics. More...
 
static struct GNUNET_TRANSPORT_CommunicatorHandlech
 Our environment. More...
 
static struct GNUNET_CONTAINER_MultiPeerMapqueue_map
 Queues (map from peer identity to struct Queue) More...
 
static struct Queuequeue_head
 Head of queue of messages to transmit. More...
 
static struct Queuequeue_tail
 Tail of queue of messages to transmit. More...
 
static struct GNUNET_NETWORK_Handleunix_sock
 socket that we transmit all data with More...
 
static struct GNUNET_TRANSPORT_AddressIdentifierai
 Handle to the operation that publishes our address. 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 gnunet-communicator-unix.c.

Macro Definition Documentation

◆ DEFAULT_MAX_QUEUE_LENGTH

#define DEFAULT_MAX_QUEUE_LENGTH   8000

How many messages do we keep at most in the queue to the transport service before we start to drop (default, can be changed via the configuration file).

Should be below the level of the communicator API, as otherwise we may read messages just to have them dropped by the communicator API.

Definition at line 45 of file gnunet-communicator-unix.c.

◆ COMMUNICATOR_ADDRESS_PREFIX

#define COMMUNICATOR_ADDRESS_PREFIX   "unix"

Address prefix used by the communicator.

Definition at line 50 of file gnunet-communicator-unix.c.

◆ COMMUNICATOR_CONFIG_SECTION

#define COMMUNICATOR_CONFIG_SECTION   "communicator-unix"

Configuration section used by the communicator.

Definition at line 55 of file gnunet-communicator-unix.c.

◆ UNIX_MTU

#define UNIX_MTU   UINT16_MAX

Our MTU.

Definition at line 61 of file gnunet-communicator-unix.c.

Function Documentation

◆ queue_destroy()

static void queue_destroy ( struct Queue queue)
static

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

Parameters
queuequeue to close down

Definition at line 218 of file gnunet-communicator-unix.c.

219 {
220  struct GNUNET_MQ_Handle *mq;
221 
223  "Disconnecting queue for peer `%s'\n",
224  GNUNET_i2s (&queue->target));
225  if (0 != queue->bytes_in_queue)
226  {
228  queue->bytes_in_queue = 0;
229  }
230  if (NULL != (mq = queue->mq))
231  {
232  queue->mq = NULL;
234  }
235  GNUNET_assert (
236  GNUNET_YES ==
239  "# queues active",
241  GNUNET_NO);
242  if (NULL != queue->timeout_task)
243  {
244  GNUNET_SCHEDULER_cancel (queue->timeout_task);
245  queue->timeout_task = NULL;
246  }
247  GNUNET_free (queue->address);
248  GNUNET_free (queue);
249 }
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static struct GNUNET_CONTAINER_MultiPeerMap * queue_map
Queues (map from peer identity to struct Queue)
static struct Queue * queue_tail
Tail of queue of messages to transmit.
static struct GNUNET_STATISTICS_Handle * stats
For logging statistics.
static struct Queue * queue_head
Head of queue of messages to transmit.
static void queue(const char *hostname)
Add hostname to the list of requests to be made.
#define GNUNET_log(kind,...)
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
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.
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
Handle to a message queue.
Definition: mq.c:86

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_MQ_destroy(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_YES, mq, queue(), queue_head, queue_map, queue_tail, and stats.

Referenced by get_queue_delete_it(), mq_destroy(), mq_error(), and queue_timeout().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ queue_timeout()

static void queue_timeout ( void *  cls)
static

Queue was idle for too long, so disconnect it.

Parameters
clsthe struct Queue * to disconnect

Definition at line 258 of file gnunet-communicator-unix.c.

259 {
260  struct Queue *queue = cls;
261  struct GNUNET_TIME_Relative left;
262 
263  queue->timeout_task = NULL;
264  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
265  if (0 != left.rel_value_us)
266  {
267  /* not actually our turn yet, but let's at least update
268  the monitor, it may think we're about to die ... */
269  queue->timeout_task =
271  return;
272  }
274  "Queue %p was idle for %s, disconnecting\n",
275  queue,
278  GNUNET_YES));
280 }
static void queue_timeout(void *cls)
Queue was idle for too long, so disconnect it.
static void queue_destroy(struct Queue *queue)
Functions with this signature are called whenever we need to close a queue due to a disconnect or fai...
#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?
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:1269
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:232
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:557
Time for relative time used by GNUnet, in microseconds.
Handle for a queue.

References GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, queue(), queue_destroy(), and GNUNET_TIME_Relative::rel_value_us.

Referenced by setup_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ reschedule_queue_timeout()

static void reschedule_queue_timeout ( struct Queue queue)
static

Increment queue timeout due to activity.

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

Parameters
queuequeue for which the timeout should be rescheduled

Definition at line 291 of file gnunet-communicator-unix.c.

292 {
293  GNUNET_assert (NULL != queue->timeout_task);
294  queue->timeout =
296 }
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:181

References GNUNET_assert, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_TIME_relative_to_absolute(), and queue().

Referenced by select_read_cb(), and select_write_cb().

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
is_abstractis this an abstract unixpath
Returns
converted unix path

Definition at line 308 of file gnunet-communicator-unix.c.

309 {
310  struct sockaddr_un *un;
311  size_t slen;
312 
313  GNUNET_assert (0 < strlen (unixpath)); /* sanity check */
314  un = GNUNET_new (struct sockaddr_un);
315  un->sun_family = AF_UNIX;
316  slen = strlen (unixpath);
317  if (slen >= sizeof(un->sun_path))
318  slen = sizeof(un->sun_path) - 1;
319  GNUNET_memcpy (un->sun_path, unixpath, slen);
320  un->sun_path[slen] = '\0';
321  slen = sizeof(struct sockaddr_un);
322 #if HAVE_SOCKADDR_UN_SUN_LEN
323  un->sun_len = (u_char) slen;
324 #endif
325  (*sock_len) = slen;
326  if ('@' == un->sun_path[0])
327  un->sun_path[0] = '\0';
328  return un;
329 }
#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.

References GNUNET_assert, GNUNET_memcpy, and GNUNET_new.

Referenced by mq_init(), and run().

Here is the caller graph for this function:

◆ lookup_queue_it()

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

Function called to find a queue by address.

Parameters
clsthe struct LookupCtx *
keypeer we are looking for (unused)
valuea queue
Returns
GNUNET_YES if not found (continue looking), GNUNET_NO on success

Definition at line 363 of file gnunet-communicator-unix.c.

364 {
365  struct LookupCtx *lctx = cls;
366  struct Queue *queue = value;
367 
368  if ((queue->address_len == lctx->un_len) &&
369  (0 == memcmp (lctx->un, queue->address, queue->address_len)))
370  {
371  lctx->res = queue;
372  return GNUNET_NO;
373  }
374  return GNUNET_YES;
375 }
static char * value
Value of the record to add/remove.
Closure to lookup_queue_it().
socklen_t un_len
Number of bytes in un.
const struct sockaddr_un * un
Address we are looking for.
struct Queue * res
Location to store the queue, if found.

References GNUNET_NO, GNUNET_YES, queue(), LookupCtx::res, LookupCtx::un, LookupCtx::un_len, and value.

Referenced by lookup_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ lookup_queue()

static struct Queue* lookup_queue ( const struct GNUNET_PeerIdentity peer,
const struct sockaddr_un *  un,
socklen_t  un_len 
)
static

Find an existing queue by address.

Parameters
pluginthe plugin
addressthe address to find
Returns
NULL if queue was not found

Definition at line 386 of file gnunet-communicator-unix.c.

389 {
390  struct LookupCtx lctx;
391 
392  lctx.un = un;
393  lctx.un_len = un_len;
394  lctx.res = NULL;
396  peer,
398  &lctx);
399  return lctx.res;
400 }
static int lookup_queue_it(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Function called to find a queue by address.
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.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

References GNUNET_CONTAINER_multipeermap_get_multiple(), lookup_queue_it(), peer, queue_map, LookupCtx::res, LookupCtx::un, and LookupCtx::un_len.

Referenced by mq_init(), and select_read_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ select_write_cb()

static void select_write_cb ( 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
clsNULL

Definition at line 410 of file gnunet-communicator-unix.c.

411 {
412  struct Queue *queue = queue_tail;
413  const struct GNUNET_MessageHeader *msg = &queue->msg->header;
414  size_t msg_size = ntohs (msg->size);
415  ssize_t sent;
416 
417  /* take queue of the ready list */
418  write_task = NULL;
419 resend:
420  /* Send the data */
422  msg,
423  msg_size,
424  (const struct sockaddr *) queue->address,
425  queue->address_len);
427  "UNIX transmitted message to %s (%d/%u: %s)\n",
428  GNUNET_i2s (&queue->target),
429  (int) sent,
430  (unsigned int) msg_size,
431  (sent < 0) ? strerror (errno) : "ok");
432  if (-1 != sent)
433  {
435  if (NULL != queue_head)
437  unix_sock,
439  NULL);
440 
441  /* send 'msg' */
442  GNUNET_free (queue->msg);
443  queue->msg = NULL;
446  "# bytes sent",
447  (long long) sent,
448  GNUNET_NO);
450  return; /* all good */
451  }
453  "# network transmission failures",
454  1,
455  GNUNET_NO);
457  unix_sock,
459  NULL);
460  switch (errno)
461  {
462  case EAGAIN:
463  case ENOBUFS:
464  /* We should retry later... */
466  return;
467 
468  case EMSGSIZE: {
469  socklen_t size = 0;
470  socklen_t len = sizeof(size);
471 
473  SOL_SOCKET,
474  SO_SNDBUF,
475  &size,
476  &len);
477  if (size > ntohs (msg->size))
478  {
479  /* Buffer is bigger than message: error, no retry
480  * This should never happen!*/
481  GNUNET_break (0);
482  return;
483  }
484  GNUNET_log (
486  "Trying to increase socket buffer size from %u to %u for message size %u\n",
487  (unsigned int) size,
488  (unsigned int) ((msg_size / 1000) + 2) * 1000,
489  (unsigned int) msg_size);
490  size = ((msg_size / 1000) + 2) * 1000;
492  SOL_SOCKET,
493  SO_SNDBUF,
494  &size,
495  sizeof(size)))
496  goto resend; /* Increased buffer size, retry sending */
497  /* Ok, then just try very modest increase */
498  size = msg_size;
500  SOL_SOCKET,
501  SO_SNDBUF,
502  &size,
503  sizeof(size)))
504  goto resend; /* Increased buffer size, retry sending */
505  /* Could not increase buffer size: error, no retry */
507  return;
508  }
509 
510  default:
512  return;
513  }
514 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static struct GNUNET_SCHEDULER_Task * write_task
ID of write task.
static void reschedule_queue_timeout(struct Queue *queue)
Increment queue timeout due to activity.
static struct GNUNET_NETWORK_Handle * unix_sock
socket that we transmit all data with
static void select_write_cb(void *cls)
We have been notified that our socket is ready to write.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
@ GNUNET_OK
Definition: gnunet_common.h:95
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:499
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:683
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:880
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:846
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:1588
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
static unsigned int size
Size of the "table".
Definition: peer.c:67
Header for all communications.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.

References GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_log_strerror, GNUNET_MQ_impl_send_continue(), GNUNET_NETWORK_socket_getsockopt(), GNUNET_NETWORK_socket_sendto(), GNUNET_NETWORK_socket_setsockopt(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_write_net(), GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_FOREVER_REL, len, msg, queue(), queue_head, queue_tail, reschedule_queue_timeout(), GNUNET_MessageHeader::size, size, stats, unix_sock, and write_task.

Referenced by mq_send().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_send()

static void mq_send ( struct GNUNET_MQ_Handle mq,
const struct GNUNET_MessageHeader msg,
void *  impl_state 
)
static

Signature of functions implementing the sending functionality of a message queue.

Parameters
mqthe message queue
msgthe message to send
impl_stateour struct Queue

Definition at line 526 of file gnunet-communicator-unix.c.

529 {
530  struct Queue *queue = impl_state;
531  size_t msize = ntohs (msg->size);
532 
533  GNUNET_assert (mq == queue->mq);
534  GNUNET_assert (NULL == queue->msg);
535  // Convert to UNIXMessage
536  queue->msg = GNUNET_malloc (msize + sizeof (struct UNIXMessage));
537  queue->msg->header.size = htons (msize + sizeof (struct UNIXMessage));
538  queue->msg->sender = my_identity;
539  memcpy (&queue->msg[1], msg, msize);
541  GNUNET_assert (NULL != unix_sock);
542  if (NULL == write_task)
544  unix_sock,
546  NULL);
547 }
static struct GNUNET_PeerIdentity my_identity
My Peer Identity.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_malloc(size)
Wrapper around malloc.
UNIX Message-Packet header.

References GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_malloc, GNUNET_SCHEDULER_add_write_net(), GNUNET_TIME_UNIT_FOREVER_REL, mq, msg, my_identity, queue(), queue_head, queue_tail, select_write_cb(), GNUNET_MessageHeader::size, unix_sock, and write_task.

Referenced by setup_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_destroy()

static void mq_destroy ( struct GNUNET_MQ_Handle mq,
void *  impl_state 
)
static

Signature of functions implementing the destruction of a message queue.

Implementations must not free mq, but should take care of impl_state.

Parameters
mqthe message queue to destroy
impl_stateour struct Queue

Definition at line 559 of file gnunet-communicator-unix.c.

560 {
561  struct Queue *queue = impl_state;
562 
563  if (mq == queue->mq)
564  {
565  queue->mq = NULL;
567  }
568 }

References mq, queue(), and queue_destroy().

Referenced by setup_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_cancel()

static void mq_cancel ( struct GNUNET_MQ_Handle mq,
void *  impl_state 
)
static

Implementation function that cancels the currently sent message.

Parameters
mqmessage queue
impl_stateour struct Queue

Definition at line 578 of file gnunet-communicator-unix.c.

579 {
580  struct Queue *queue = impl_state;
581 
582  GNUNET_assert (NULL != queue->msg);
583  queue->msg = NULL;
585  GNUNET_assert (NULL != write_task);
586  if (NULL == queue_head)
587  {
589  write_task = NULL;
590  }
591 }

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_SCHEDULER_cancel(), queue(), queue_head, queue_tail, and write_task.

Referenced by setup_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_error()

static void mq_error ( void *  cls,
enum GNUNET_MQ_Error  error 
)
static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters
clsour struct Queue
errorerror code

Definition at line 604 of file gnunet-communicator-unix.c.

605 {
606  struct Queue *queue = cls;
607 
609  "UNIX MQ error in queue to %s: %d\n",
610  GNUNET_i2s (&queue->target),
611  (int) error);
613 }

References GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s(), GNUNET_log, queue(), and queue_destroy().

Referenced by setup_queue().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ setup_queue()

static struct Queue* setup_queue ( const struct GNUNET_PeerIdentity target,
enum GNUNET_TRANSPORT_ConnectionStatus  cs,
const struct sockaddr_un *  un,
socklen_t  un_len 
)
static

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

Parameters
peerthe target peer
csinbound or outbound queue
unthe address
un_lennumber of bytes in un
Returns
the queue or NULL of max connections exceeded

Definition at line 627 of file gnunet-communicator-unix.c.

631 {
632  struct Queue *queue;
633 
634  queue = GNUNET_new (struct Queue);
635  queue->target = *target;
636  queue->address = GNUNET_memdup (un, un_len);
637  queue->address_len = un_len;
639  queue_map,
640  &queue->target,
641  queue,
644  "# queues active",
646  GNUNET_NO);
647  queue->timeout =
649  queue->timeout_task =
651  &queue_timeout,
652  queue);
654  &mq_destroy,
655  &mq_cancel,
656  queue,
657  NULL,
658  &mq_error,
659  queue);
660  {
661  char *foreign_addr;
662 
663  if ('\0' == un->sun_path[0])
664  GNUNET_asprintf (&foreign_addr,
665  "%s-@%s",
667  &un->sun_path[1]);
668  else
669  GNUNET_asprintf (&foreign_addr,
670  "%s-%s",
672  un->sun_path);
674  &queue->target,
675  foreign_addr,
676  UNIX_MTU - sizeof (struct
677  UNIXMessage),
679  0,
681  cs,
682  queue->mq);
683  GNUNET_free (foreign_addr);
684  }
685  return queue;
686 }
#define UNIX_MTU
Our MTU.
#define COMMUNICATOR_ADDRESS_PREFIX
Address prefix used by the communicator.
static void mq_destroy(struct GNUNET_MQ_Handle *mq, void *impl_state)
Signature of functions implementing the destruction of a message queue.
static struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Our environment.
static void mq_cancel(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
static void mq_error(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
static void mq_send(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
Signature of functions implementing the sending functionality of a message queue.
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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
struct GNUNET_MQ_Handle * GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send, GNUNET_MQ_DestroyImpl destroy, GNUNET_MQ_CancelImpl cancel, void *impl_state, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *cls)
Create a message queue for the specified handlers.
Definition: mq.c:565
@ GNUNET_NT_LOOPBACK
Loopback (same host).
Definition: gnunet_nt_lib.h:45
#define GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED
Queue length.
struct GNUNET_TRANSPORT_QueueHandle * GNUNET_TRANSPORT_communicator_mq_add(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *peer, const char *address, uint32_t mtu, uint64_t q_len, uint32_t priority, enum GNUNET_NetworkType nt, enum GNUNET_TRANSPORT_ConnectionStatus cs, struct GNUNET_MQ_Handle *mq)
Notify transport service that a MQ became available due to an "inbound" connection or because the com...
struct GNUNET_PeerIdentity target
To whom are we talking to.
enum GNUNET_TRANSPORT_ConnectionStatus cs
The connection status of this queue.

References ch, COMMUNICATOR_ADDRESS_PREFIX, Queue::cs, GNUNET_asprintf(), GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_free, GNUNET_memdup, GNUNET_MQ_queue_for_callbacks(), GNUNET_new, GNUNET_NO, GNUNET_NT_LOOPBACK, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_set(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_communicator_mq_add(), GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, mq_cancel(), mq_destroy(), mq_error(), mq_send(), queue(), queue_map, queue_timeout(), stats, Queue::target, and UNIX_MTU.

Referenced by mq_init(), and select_read_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ select_read_cb()

static void select_read_cb ( void *  cls)
static

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

Do the read and reschedule this function to be called again once more is available.

Parameters
clsNULL

Definition at line 734 of file gnunet-communicator-unix.c.

735 {
736  char buf[65536] GNUNET_ALIGN;
737  struct Queue *queue;
738  const struct UNIXMessage *msg;
739  struct sockaddr_un un;
740  socklen_t addrlen;
741  ssize_t ret;
742  uint16_t msize;
743 
744  GNUNET_assert (NULL != unix_sock);
746  unix_sock,
748  NULL);
749  addrlen = sizeof(un);
750  memset (&un, 0, sizeof(un));
752  buf,
753  sizeof(buf),
754  (struct sockaddr *) &un,
755  &addrlen);
756  if ((-1 == ret) && ((EAGAIN == errno) || (ENOBUFS == errno)))
757  return;
758  if (-1 == ret)
759  {
761  return;
762  }
764  "Read %d bytes from socket %s\n",
765  (int) ret,
766  un.sun_path);
767  GNUNET_assert (AF_UNIX == (un.sun_family));
768  msg = (struct UNIXMessage *) buf;
769  msize = ntohs (msg->header.size);
770  if ((msize < sizeof(struct UNIXMessage)) || (msize > ret))
771  {
773  "Wrong message size: %d bytes\n",
774  msize);
775  GNUNET_break_op (0);
776  return;
777  }
778  queue = lookup_queue (&msg->sender, &un, addrlen);
779  if (NULL == queue)
780  queue =
781  setup_queue (&msg->sender, GNUNET_TRANSPORT_CS_INBOUND, &un, addrlen);
782  else
784  if (NULL == queue)
785  {
786  GNUNET_log (
788  _ (
789  "Maximum number of UNIX connections exceeded, dropping incoming message\n"));
790  return;
791  }
792 
793  {
794  uint16_t tsize = msize - sizeof(struct UNIXMessage);
795 
796  const struct GNUNET_MessageHeader *currhdr;
797  struct GNUNET_MessageHeader al_hdr;
798 
799  currhdr = (const struct GNUNET_MessageHeader *) &msg[1];
800  /* ensure aligned access */
801  memcpy (&al_hdr, currhdr, sizeof(al_hdr));
802  if ((tsize < sizeof(struct GNUNET_MessageHeader)) ||
803  (tsize != ntohs (al_hdr.size)))
804  {
805  GNUNET_break_op (0);
806  return;
807  }
809  &msg->sender,
810  currhdr,
813  NULL);
814  if (GNUNET_SYSERR == ret)
815  {
817  "Transport not up!\n");
818  return; /* transport not up */
819  }
820  if (GNUNET_NO == ret)
821  {
823  "Error sending message to transport\n");
824  return;
825  }
827  }
829  {
831  "Back pressure %llu\n", delivering_messages);
832 
833  /* we should try to apply 'back pressure' */
835  read_task = NULL;
836  }
837 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static void receive_complete_cb(void *cls, int success)
Function called when message was successfully passed to transport service.
static unsigned long long max_queue_length
Maximum queue length before we stop reading towards the transport service.
static struct Queue * setup_queue(const struct GNUNET_PeerIdentity *target, enum GNUNET_TRANSPORT_ConnectionStatus cs, const struct sockaddr_un *un, socklen_t un_len)
Creates a new outbound queue the transport service will use to send data to another peer.
static struct GNUNET_SCHEDULER_Task * read_task
ID of read task.
static struct Queue * lookup_queue(const struct GNUNET_PeerIdentity *peer, const struct sockaddr_un *un, socklen_t un_len)
Find an existing queue by address.
static unsigned long long delivering_messages
Number of messages we currently have in our queues towards the transport service.
static void select_read_cb(void *cls)
We have been notified that our socket has something to read.
static char buf[2048]
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to 'struct's.
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
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:754
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:1517
int GNUNET_TRANSPORT_communicator_receive(struct GNUNET_TRANSPORT_CommunicatorHandle *handle, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg, struct GNUNET_TIME_Relative expected_addr_validity, GNUNET_TRANSPORT_MessageCompletedCallback cb, void *cb_cls)
Notify transport service that the communicator has received a message.
@ GNUNET_TRANSPORT_CS_INBOUND
this is an inbound connection (communicator initiated)
#define _(String)
GNU gettext support macro.
Definition: platform.h:177

References _, buf, ch, delivering_messages, GNUNET_ALIGN, GNUNET_assert, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_socket_recvfrom(), GNUNET_NO, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_communicator_receive(), GNUNET_TRANSPORT_CS_INBOUND, lookup_queue(), max_queue_length, msg, queue(), read_task, receive_complete_cb(), reschedule_queue_timeout(), ret, setup_queue(), GNUNET_MessageHeader::size, and unix_sock.

Referenced by receive_complete_cb(), and run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ receive_complete_cb()

static void receive_complete_cb ( void *  cls,
int  success 
)
static

Function called when message was successfully passed to transport service.

Continue read activity.

Parameters
clsNULL
successGNUNET_OK on success

Definition at line 708 of file gnunet-communicator-unix.c.

709 {
710  (void) cls;
712  if (GNUNET_OK != success)
714  "# transport transmission failures",
715  1,
716  GNUNET_NO);
717  if ((NULL == read_task) && (delivering_messages < max_queue_length) &&
718  (NULL != unix_sock))
720  unix_sock,
722  NULL);
723 }

References delivering_messages, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_FOREVER_REL, max_queue_length, read_task, select_read_cb(), stats, and unix_sock.

Referenced by select_read_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ mq_init()

static int mq_init ( void *  cls,
const struct GNUNET_PeerIdentity peer,
const char *  address 
)
static

Function called by the transport service to initialize a message queue given address information about another peer.

If and when the communication channel is established, the communicator must call GNUNET_TRANSPORT_communicator_mq_add() to notify the service that the channel is now up. It is the responsibility of the communicator to manage sane retries and timeouts for any peer/address combination provided by the transport service. Timeouts and retries do not need to be signalled to the transport service.

Parameters
clsclosure
peeridentity of the other peer
addresswhere to send the message, human-readable communicator-specific format, 0-terminated, UTF-8
Returns
GNUNET_OK on success, GNUNET_SYSERR if the provided address is invalid

Definition at line 858 of file gnunet-communicator-unix.c.

859 {
860  struct Queue *queue;
861  const char *path;
862  struct sockaddr_un *un;
863  socklen_t un_len;
864 
865  (void) cls;
866  if (0 != strncmp (address,
868  strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
869  {
870  GNUNET_break_op (0);
871  return GNUNET_SYSERR;
872  }
873  path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
874  un = unix_address_to_sockaddr (path, &un_len);
875  queue = lookup_queue (peer, un, un_len);
876  if (NULL != queue)
877  {
879  "Address `%s' for %s ignored, queue exists\n",
880  path,
881  GNUNET_i2s (peer));
882  GNUNET_free (un);
883  return GNUNET_OK;
884  }
886  GNUNET_free (un);
887  if (NULL == queue)
888  {
890  "Failed to setup queue to %s at `%s'\n",
891  GNUNET_i2s (peer),
892  path);
893  return GNUNET_NO;
894  }
895  return GNUNET_OK;
896 }
static struct sockaddr_un * unix_address_to_sockaddr(const char *unixpath, socklen_t *sock_len)
Convert unix path to a struct sockaddr_un *
static char * address
GNS address for this phone.
@ GNUNET_ERROR_TYPE_INFO
@ GNUNET_TRANSPORT_CS_OUTBOUND
this is an outbound connection (transport initiated)

References address, COMMUNICATOR_ADDRESS_PREFIX, GNUNET_break_op, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TRANSPORT_CS_OUTBOUND, lookup_queue(), peer, queue(), setup_queue(), and unix_address_to_sockaddr().

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_queue_delete_it()

static int get_queue_delete_it ( void *  cls,
const struct GNUNET_PeerIdentity target,
void *  value 
)
static

Iterator over all message queues to clean up.

Parameters
clsNULL
targetunused
valuethe queue to destroy
Returns
GNUNET_OK to continue to iterate

Definition at line 908 of file gnunet-communicator-unix.c.

911 {
912  struct Queue *queue = value;
913 
914  (void) cls;
915  (void) target;
917  return GNUNET_OK;
918 }

References GNUNET_OK, queue(), queue_destroy(), Queue::target, and value.

Referenced by do_shutdown().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_shutdown()

static void do_shutdown ( void *  cls)
static

Shutdown the UNIX communicator.

Parameters
clsNULL (always)

Definition at line 927 of file gnunet-communicator-unix.c.

928 {
929  if (NULL != read_task)
930  {
932  read_task = NULL;
933  }
934  if (NULL != write_task)
935  {
937  write_task = NULL;
938  }
939  if (NULL != unix_sock)
940  {
942  unix_sock = NULL;
943  }
946  if (NULL != ai)
947  {
949  ai = NULL;
950  }
951  if (NULL != ch)
952  {
954  ch = NULL;
955  }
956  if (NULL != stats)
957  {
959  stats = NULL;
960  }
961 }
static int get_queue_delete_it(void *cls, const struct GNUNET_PeerIdentity *target, void *value)
Iterator over all message queues to clean up.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
int GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition: network.c:560
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
void GNUNET_TRANSPORT_communicator_address_remove(struct GNUNET_TRANSPORT_AddressIdentifier *ai)
Notify transport service about an address that this communicator no longer provides for this peer.
void GNUNET_TRANSPORT_communicator_disconnect(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
Disconnect from the transport service.

References ai, ch, get_queue_delete_it(), GNUNET_break, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_NETWORK_socket_close(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GNUNET_TRANSPORT_communicator_address_remove(), GNUNET_TRANSPORT_communicator_disconnect(), queue_map, read_task, stats, unix_sock, and write_task.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ enc_notify_cb()

static void enc_notify_cb ( void *  cls,
const struct GNUNET_PeerIdentity sender,
const struct GNUNET_MessageHeader msg 
)
static

Function called when the transport service has received an acknowledgement for this communicator (!) via a different return path.

Not applicable for UNIX.

Parameters
clsclosure
senderwhich peer sent the notification
msgpayload

Definition at line 976 of file gnunet-communicator-unix.c.

979 {
980  (void) cls;
981  (void) sender;
982  (void) msg;
983  GNUNET_break_op (0);
984 }

References GNUNET_break_op, and msg.

Referenced by run().

Here is the caller graph for this function:

◆ run()

static void run ( void *  cls,
char *const *  args,
const char *  cfgfile,
const struct GNUNET_CONFIGURATION_Handle cfg 
)
static

Setup communicator and launch network interactions.

Parameters
clsNULL (always)
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
cfgconfiguration

Definition at line 996 of file gnunet-communicator-unix.c.

1000 {
1001  char *unix_socket_path;
1002  struct sockaddr_un *un;
1003  socklen_t un_len;
1004  char *my_addr;
1006 
1007  (void) cls;
1008  delivering_messages = 0;
1009 
1011  if (NULL == my_private_key)
1012  {
1013  GNUNET_log (
1015  _ (
1016  "UNIX communicator is lacking key configuration settings. Exiting.\n"));
1018  return;
1019  }
1021 
1022  if (GNUNET_OK !=
1025  "UNIXPATH",
1026  &unix_socket_path))
1027  {
1030  "UNIXPATH");
1031  return;
1032  }
1033  if (GNUNET_OK !=
1036  "MAX_QUEUE_LENGTH",
1037  &max_queue_length))
1039 
1040  un = unix_address_to_sockaddr (unix_socket_path, &un_len);
1041  if (NULL == un)
1042  {
1044  "Failed to setup UNIX domain socket address with path `%s'\n",
1045  unix_socket_path);
1046  GNUNET_free (unix_socket_path);
1047  return;
1048  }
1049  unix_sock = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_DGRAM, 0);
1050  if (NULL == unix_sock)
1051  {
1053  GNUNET_free (un);
1054  GNUNET_free (unix_socket_path);
1055  return;
1056  }
1057  if (('\0' != un->sun_path[0]) &&
1059  {
1061  _ ("Cannot create path to `%s'\n"),
1062  un->sun_path);
1064  unix_sock = NULL;
1065  GNUNET_free (un);
1066  GNUNET_free (unix_socket_path);
1067  return;
1068  }
1070  (const struct sockaddr *) un,
1071  un_len))
1072  {
1073  GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "bind", un->sun_path);
1075  unix_sock = NULL;
1076  GNUNET_free (un);
1077  GNUNET_free (unix_socket_path);
1078  return;
1079  }
1080  GNUNET_free (un);
1081  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Bound to `%s'\n", unix_socket_path);
1082  stats = GNUNET_STATISTICS_create ("C-UNIX", cfg);
1085  unix_sock,
1086  &select_read_cb,
1087  NULL);
1093  &mq_init,
1094  NULL,
1095  &enc_notify_cb,
1096  NULL);
1097  if (NULL == ch)
1098  {
1099  GNUNET_break (0);
1101  GNUNET_free (unix_socket_path);
1102  return;
1103  }
1104  GNUNET_asprintf (&my_addr,
1105  "%s-%s",
1107  unix_socket_path);
1108  GNUNET_free (unix_socket_path);
1110  my_addr,
1113  GNUNET_free (my_addr);
1114 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static void enc_notify_cb(void *cls, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg)
Function called when the transport service has received an acknowledgement for this communicator (!...
static void do_shutdown(void *cls)
Shutdown the UNIX communicator.
#define COMMUNICATOR_CONFIG_SECTION
Configuration section used by the communicator.
static int mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
Function called by the transport service to initialize a message queue given address information abou...
#define DEFAULT_MAX_QUEUE_LENGTH
How many messages do we keep at most in the queue to the transport service before we start to drop (d...
struct GNUNET_CRYPTO_EddsaPrivateKey * my_private_key
Own private key.
enum GNUNET_GenericReturnValue 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.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_configuration(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a new private key by reading our peer's key from the file specified in the configuration.
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:197
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:582
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).
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition: network.c:907
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:485
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1331
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
struct GNUNET_TRANSPORT_AddressIdentifier * GNUNET_TRANSPORT_communicator_address_add(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const char *address, enum GNUNET_NetworkType nt, struct GNUNET_TIME_Relative expiration)
Notify transport service about an address that this communicator provides for this peer.
struct GNUNET_TRANSPORT_CommunicatorHandle * GNUNET_TRANSPORT_communicator_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section_name, const char *addr_prefix, enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc, GNUNET_TRANSPORT_CommunicatorMqInit mq_init, void *mq_init_cls, GNUNET_TRANSPORT_CommunicatorNotify notify_cb, void *notify_cb_cls)
Connect to the transport service.
@ GNUNET_TRANSPORT_CC_RELIABLE
Transmission is reliabile (with ACKs), e.g.
Private ECC key encoded for transmission.
struct GNUNET_CRYPTO_EddsaPublicKey public_key

References _, ai, cfg, ch, COMMUNICATOR_ADDRESS_PREFIX, COMMUNICATOR_CONFIG_SECTION, DEFAULT_MAX_QUEUE_LENGTH, delivering_messages, do_shutdown(), enc_notify_cb(), GNUNET_asprintf(), GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_DISK_directory_create_for_file(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_log_strerror, GNUNET_log_strerror_file, GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NO, GNUNET_NT_LOOPBACK, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_CC_RELIABLE, GNUNET_TRANSPORT_communicator_address_add(), GNUNET_TRANSPORT_communicator_connect(), max_queue_length, mq_init(), my_identity, my_private_key, GNUNET_PeerIdentity::public_key, queue_map, read_task, select_read_cb(), stats, unix_address_to_sockaddr(), and unix_sock.

Here is the call graph for this function:

◆ main()

int main ( int  argc,
char *const *  argv 
)

The main function for the UNIX communicator.

Parameters
argcnumber of arguments from the command line
argvcommand line arguments
Returns
0 ok, 1 on error

Definition at line 1125 of file gnunet-communicator-unix.c.

1126 {
1127  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
1129  };
1130  int ret;
1131 
1132  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
1133  return 2;
1134 
1135  ret = (GNUNET_OK ==
1136  GNUNET_PROGRAM_run (argc,
1137  argv,
1138  "gnunet-communicator-unix",
1139  _ ("GNUnet UNIX domain socket communicator"),
1140  options,
1141  &run,
1142  NULL))
1143  ? 0
1144  : 1;
1145  GNUNET_free_nz ((void *) argv);
1146  return ret;
1147 }
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Setup communicator and launch network interactions.
#define GNUNET_free_nz(ptr)
Wrapper around free.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:364
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1209
Definition of a command line option.

Variable Documentation

◆ my_identity

struct GNUNET_PeerIdentity my_identity
static

My Peer Identity.

Definition at line 84 of file gnunet-communicator-unix.c.

Referenced by mq_send(), and run().

◆ read_task

struct GNUNET_SCHEDULER_Task* read_task
static

ID of read task.

Definition at line 157 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), receive_complete_cb(), run(), and select_read_cb().

◆ write_task

struct GNUNET_SCHEDULER_Task* write_task
static

ID of write task.

Definition at line 162 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), mq_cancel(), mq_send(), and select_write_cb().

◆ delivering_messages

unsigned long long delivering_messages
static

Number of messages we currently have in our queues towards the transport service.

Definition at line 167 of file gnunet-communicator-unix.c.

Referenced by receive_complete_cb(), run(), and select_read_cb().

◆ max_queue_length

unsigned long long max_queue_length
static

Maximum queue length before we stop reading towards the transport service.

Definition at line 172 of file gnunet-communicator-unix.c.

Referenced by receive_complete_cb(), run(), and select_read_cb().

◆ stats

struct GNUNET_STATISTICS_Handle* stats
static

For logging statistics.

Definition at line 177 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), queue_destroy(), receive_complete_cb(), run(), select_write_cb(), and setup_queue().

◆ ch

Our environment.

Definition at line 182 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), run(), select_read_cb(), and setup_queue().

◆ queue_map

struct GNUNET_CONTAINER_MultiPeerMap* queue_map
static

Queues (map from peer identity to struct Queue)

Definition at line 187 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), lookup_queue(), queue_destroy(), run(), and setup_queue().

◆ queue_head

struct Queue* queue_head
static

Head of queue of messages to transmit.

Definition at line 192 of file gnunet-communicator-unix.c.

Referenced by mq_cancel(), mq_send(), queue_destroy(), and select_write_cb().

◆ queue_tail

struct Queue* queue_tail
static

Tail of queue of messages to transmit.

Definition at line 197 of file gnunet-communicator-unix.c.

Referenced by mq_cancel(), mq_send(), queue_destroy(), and select_write_cb().

◆ unix_sock

struct GNUNET_NETWORK_Handle* unix_sock
static

socket that we transmit all data with

Definition at line 202 of file gnunet-communicator-unix.c.

Referenced by do_shutdown(), mq_send(), receive_complete_cb(), run(), select_read_cb(), and select_write_cb().

◆ ai