CORE

Secure Communication with other peers. More...

Collaboration diagram for CORE:

Data Structures
struct	PeerConnectCls
	Closure used for the peer_connect_task. More...
struct	QueuedMessage
struct	Connection
	Used to keep track of context of peer. More...
struct	GNUNET_CORE_UNDERLAY_DUMMY_Handle
	Opaque handle to the service. More...

Macros
#define	GNUNET_CORE_UNDERLAY_DUMMY_VERSION   0x00000000
	Version number of the core underlay dummy.

Typedefs
typedef void *(*	GNUNET_CORE_UNDERLAY_DUMMY_NotifyConnect) (void *cls, uint32_t num_addresses, const char *addresses[static num_addresses], struct GNUNET_MQ_Handle *mq, const struct GNUNET_PeerIdentity *peer_id)
	Function called to notify core underlay dummy users that another peer connected to us.
typedef void(*	GNUNET_CORE_UNDERLAY_DUMMY_NotifyDisconnect) (void *cls, void *handler_cls)
	Function called to notify core underlay dummy users that another peer disconnected from us.
typedef void(*	GNUNET_CORE_UNDERLAY_DUMMY_NotifyAddressChange) (void *cls, uint32_t num_addresses, const char *addresses[static num_addresses])
	Function called to notify core of the now available addresses.

Enumerations
enum	ConnectionStatus {   CONNECTION_INITIALIZING , CONNECTION_INITIALIZING_SEND , CONNECTION_INITIALIZING_RECV , CONNECTION_LIVE ,   CONNECTION_DESTROY }

Functions
static const char *	status2string (enum ConnectionStatus status)
static void	do_read (void *cls)
	Callback scheduled to run when there is something to read from the socket.
static void	connection_destroy (struct Connection *connection)
	Destroy a connection.
static void	set_handlers_closure (struct GNUNET_MQ_MessageHandler *handlers, void *handlers_cls)
	Set the closures for mq handlers.
static void	do_handle_message (void *cls)
static void	check_for_messages (struct Connection *connection)
static void	do_notify_connect (void *cls)
	Notify the api caller about a new connection.
static void	try_notify_connect (struct Connection *connection)
static void	cancel_initiating_connections (struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h, struct Connection *connection)
static void	write_cb (void *cls)
	Callback scheduled to run once the socket is ready for writing.
static void	send_init (struct Connection *connection)
static void	mq_send_impl (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
	Callback called from the MQ to send a message over a socket.
static void	mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Callback to destroy the message queue.
static void	mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Callback to cancel sending a message.
static void	mq_error_handler_impl (void *cls, enum GNUNET_MQ_Error error)
	Handle mq errors.
static void	do_accept (void *cls)
	Accept a connection on the dummy's socket.
static void	do_connect_to_peer (void *cls)
	Connect to another peer.
static void	do_notify_address_change (void *cls)
	Notify core about address change.
static void	try_connect (struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h, const char *address)
static enum GNUNET_GenericReturnValue	discovered_socket_cb (void *cls, const char *filename)
	Handle the discovery of a certain socket.
static void	do_discover_peers (void *cls)
	Discover sockets of other peers.
static enum GNUNET_GenericReturnValue	try_open_listening_socket (struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h, char *sock_name)
static void	do_open_listening_socket (void *cls, uint64_t sock_name_ctr_start)
	Opens UNIX domain socket.
static void	do_close_listening_socket (void *cls)
struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *	GNUNET_CORE_UNDERLAY_DUMMY_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_MQ_MessageHandler *handlers, void *cls, GNUNET_CORE_UNDERLAY_DUMMY_NotifyConnect nc, GNUNET_CORE_UNDERLAY_DUMMY_NotifyDisconnect nd, GNUNET_CORE_UNDERLAY_DUMMY_NotifyAddressChange na)
	Connect to the core underlay dummy service.
void	GNUNET_CORE_UNDERLAY_DUMMY_disconnect (struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *handle)
	Disconnect from the core underlay dummy service.

Variables
struct PeerConnectCls *	PeerConnectCls::next
	Linked list next.
struct PeerConnectCls *	PeerConnectCls::prev
	Linked list previous.
struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *	PeerConnectCls::h
	The handle for the service.
char *	PeerConnectCls::sock_name
	The file name to connect to.
struct GNUNET_SCHEDULER_Task *	PeerConnectCls::peer_connect_task
	Task to connect to another peer.
struct QueuedMessage *	QueuedMessage::next
struct QueuedMessage *	QueuedMessage::prev
struct GNUNET_MessageHeader *	QueuedMessage::msg
struct Connection *	Connection::next
	Linked list next.
struct Connection *	Connection::prev
	Linked list previous.
struct GNUNET_MQ_Handle *	Connection::mq
	Message queue towards the connected peer.
struct GNUNET_MQ_MessageHandler *	Connection::handlers
	Handlers for mq.
void *	Connection::cls_mq
	Closure for the mq towards the client.
struct GNUNET_NETWORK_Handle *	Connection::sock
	Socket for the connected peer.
char *	Connection::peer_addr
	Address of the connected peer.
struct GNUNET_SCHEDULER_Task *	Connection::recv_task
	Task waiting for incoming messages.
struct GNUNET_SCHEDULER_Task *	Connection::write_task
	Task waiting until the socket becomes ready to be written to.
struct GNUNET_SCHEDULER_Task *	Connection::notify_connect_task
	Task to notify the client about an open connection.
struct GNUNET_SCHEDULER_Task *	Connection::handle_message_task
	Task to pass the message to the client's handlers.
enum GNUNET_GenericReturnValue	Connection::notify_connect_called
	Whether notify_connect was called already It is used to check whether to call notify_disconnect or not.
enum GNUNET_GenericReturnValue	Connection::client_ready_to_receive
	Indicating whether the client is ready to receive new messages.
enum ConnectionStatus	Connection::status
	Status of the connection: Initializing, Live, Destroy.
const struct GNUNET_MessageHeader *	Connection::message_to_send
	Message about to be sent, given by the message queue, waiting for the socket to be ready.
struct QueuedMessage *	Connection::queued_recv_messages_head
	Queued received messages in a DLL TODO implement cleanup TODO replace with a performant queue.
struct QueuedMessage *	Connection::queued_recv_messages_tail
struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *	Connection::handle
	Handle to the service.
GNUNET_CORE_UNDERLAY_DUMMY_NotifyConnect	GNUNET_CORE_UNDERLAY_DUMMY_Handle::notify_connect
	Callback (from/to client) to call when another peer connects.
GNUNET_CORE_UNDERLAY_DUMMY_NotifyDisconnect	GNUNET_CORE_UNDERLAY_DUMMY_Handle::notify_disconnect
	Callback (from/to client) to call when a peer disconnects.
GNUNET_CORE_UNDERLAY_DUMMY_NotifyAddressChange	GNUNET_CORE_UNDERLAY_DUMMY_Handle::notify_address_change
	Callback (from/to client) to call when our address changes.
struct GNUNET_MQ_MessageHandler *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::handlers
	Array of message handlers given by the client.
void *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::cls
	Closure for handlers given by the client - connection-independant (notify_connect, notify_disconnect, notify_address_change) TODO what's the doxygen way of linking to other members of this struct?
char *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::sock_name
	Name of the listening socket.
uint64_t	GNUNET_CORE_UNDERLAY_DUMMY_Handle::sock_name_index_start
uint64_t	GNUNET_CORE_UNDERLAY_DUMMY_Handle::sock_name_index
struct GNUNET_NETWORK_Handle *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::sock_listen
	Socket on which we listen for incoming connections.
struct GNUNET_SCHEDULER_Task *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::listen_task
	Task that waits for incoming connections.
struct GNUNET_SCHEDULER_Task *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::notify_address_change_task
	Task to notify core about address changes.
struct GNUNET_SCHEDULER_Task *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::peer_discovery_task
	Task to discover other peers.
struct GNUNET_SCHEDULER_Task *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::address_change_task
struct PeerConnectCls *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::peer_connect_cls_head
	Head of linked list with peer connect closures.
struct PeerConnectCls *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::peer_connect_cls_tail
	Tail of linked list with peer connect closures.
struct Connection *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::connections_head
	Head of linked list with peer connect closures.
struct Connection *	GNUNET_CORE_UNDERLAY_DUMMY_Handle::connections_tail
	Tail of linked list with peer connect closures.

Detailed Description

Secure Communication with other peers.

See also

Documentation TODO

Macro Definition Documentation

GNUNET_CORE_UNDERLAY_DUMMY_VERSION

#define GNUNET_CORE_UNDERLAY_DUMMY_VERSION   0x00000000

Version number of the core underlay dummy.

Definition at line 57 of file gnunet_core_underlay_dummy.h.

Typedef Documentation

GNUNET_CORE_UNDERLAY_DUMMY_NotifyConnect

typedef void *(* GNUNET_CORE_UNDERLAY_DUMMY_NotifyConnect) (void *cls, uint32_t num_addresses, const char *addresses[static num_addresses], struct GNUNET_MQ_Handle *mq, const struct GNUNET_PeerIdentity *peer_id)

Function called to notify core underlay dummy users that another peer connected to us.

If the underlay knows the peer id, it should include it in the addresses

Parameters

cls	closure
num_addresses	number of addresses of the connecting peer
addresses	address URIs of the connecting peer
mq	message queue to use to transmit to peer
peer_id	(optional, may be NULL) the peer id of the connecting peer

Returns

closure to use in MQ handlers

Definition at line 79 of file gnunet_core_underlay_dummy.h.

GNUNET_CORE_UNDERLAY_DUMMY_NotifyDisconnect

typedef void(* GNUNET_CORE_UNDERLAY_DUMMY_NotifyDisconnect) (void *cls, void *handler_cls)

Function called to notify core underlay dummy users that another peer disconnected from us.

The message queue that was given to the connect notification will be destroyed and must not be used henceforth.

Parameters

cls	closure from GNUNET_CORE_UNDERLAY_DUMMY_connect
handlers_cls	closure of the handlers, was returned from the connect notification callback

Definition at line 97 of file gnunet_core_underlay_dummy.h.

GNUNET_CORE_UNDERLAY_DUMMY_NotifyAddressChange

typedef void(* GNUNET_CORE_UNDERLAY_DUMMY_NotifyAddressChange) (void *cls, uint32_t num_addresses, const char *addresses[static num_addresses])

Function called to notify core of the now available addresses.

Core will update its peer identity accordingly.

Parameters

cls	closure from GNUNET_CORE_UNDERLAY_DUMMY_connect
num_addresses	number of addresses now available to this peer
addresses	current addresses of this peer

Definition at line 110 of file gnunet_core_underlay_dummy.h.

Enumeration Type Documentation

ConnectionStatus

enum ConnectionStatus

Enumerator
CONNECTION_INITIALIZING
CONNECTION_INITIALIZING_SEND
CONNECTION_INITIALIZING_RECV
CONNECTION_LIVE
CONNECTION_DESTROY

Definition at line 105 of file gnunet_core_underlay_dummy.c.

{
  /* Created, but neither received, nor sent anything over it */
  CONNECTION_INITIALIZING,
 
  /* Created and successfully sent something (probably init) */
  CONNECTION_INITIALIZING_SEND,
 
  /* Created and successfully received something (probably init) */
  CONNECTION_INITIALIZING_RECV,
 
  /* Live - usable - successfully received and sent something (probably init) */
  CONNECTION_LIVE,
 
  /* In the process of destruction */
  CONNECTION_DESTROY,
};

Function Documentation

status2string()

static const char * status2string ( enum ConnectionStatus  status )

static

Definition at line 316 of file gnunet_core_underlay_dummy.c.

{
  switch (status)
  {
  case CONNECTION_INITIALIZING:
    return "C_INITIALIZING";
    break;
  case CONNECTION_INITIALIZING_SEND:
    return "C_INITIALIZING_SEND";
    break;
  case CONNECTION_INITIALIZING_RECV:
    return "C_INITIALIZING_RECV";
    break;
  case CONNECTION_LIVE:
    return "C_LIVE";
    break;
  case CONNECTION_DESTROY:
    return "C_DESTROY";
    break;
  }
  return ""; /* Make compiler happy */
}

References CONNECTION_DESTROY, CONNECTION_INITIALIZING, CONNECTION_INITIALIZING_RECV, CONNECTION_INITIALIZING_SEND, CONNECTION_LIVE, and status.

Referenced by cancel_initiating_connections(), do_read(), try_connect(), and write_cb().

Here is the caller graph for this function:

do_read()

static void do_read ( void *  cls )

static

Callback scheduled to run when there is something to read from the socket.

Reads the data from the socket and passes it to the message queue.

Parameters

cls	Closure: Information for this socket

Definition at line 588 of file gnunet_core_underlay_dummy.c.

{
  struct Connection *connection = cls;
 
  char buf[65536] GNUNET_ALIGN;
  ssize_t ret;
  struct GNUNET_MessageHeader *msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "do_read(): receiving bytes from %s :%s\n",
       connection->peer_addr,
       status2string (connection->status));
  connection->recv_task = NULL;
  GNUNET_assert (NULL != connection->sock);
  ret = GNUNET_NETWORK_socket_recv (connection->sock,
                                    &buf,
                                    sizeof(buf));
  if (0 > ret)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR, "Error reading from socket - MQ_destroy()\n");
    connection->status = CONNECTION_DESTROY;
    GNUNET_MQ_destroy (connection->mq); // This triggers mq_destroy_impl()
    return;
  }
  if (0 == ret)
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         "Other peer closed connection - MQ_destroy()\n");
    connection->status = CONNECTION_DESTROY;
    GNUNET_MQ_destroy (connection->mq); // This triggers mq_destroy_impl()
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Read %d bytes\n", (int) ret);
  GNUNET_assert (2 <= ret); /* has to have returned enough for one full msg_hdr */
 
  /* Handle the message itself */
  {
    ssize_t ret_remain;
    char *buf_iter;
    struct GNUNET_MessageHeader *msg_iter;
 
    msg = (struct GNUNET_MessageHeader *) buf;
    ret_remain = ret;
    buf_iter = buf;
    /* Just debug logging */
    while (0 < ret_remain)
    {
      msg_iter = (struct GNUNET_MessageHeader *) buf_iter;
      LOG (GNUNET_ERROR_TYPE_DEBUG, "Length of message: %d bytes\n", ntohs (
             msg_iter->size));
      LOG (GNUNET_ERROR_TYPE_DEBUG, "Remaining bytes of buffer: %ld\n",
           ret_remain);
 
      {
        // XXX only for debugging purposes
        // this shows everything works as expected
 
        struct GNUNET_UNDERLAY_DUMMY_Message
        {
          struct GNUNET_MessageHeader header;
          // The following will be used for debugging
          uint64_t id; // id of the message
          uint64_t batch; // first batch of that peer (for this test 0 or 1)
          // uint64_t peer; // number of sending peer (for this test 0 or 1)
        };
 
 
        struct GNUNET_UNDERLAY_DUMMY_Message *msg_dbg =
          (struct GNUNET_UNDERLAY_DUMMY_Message *) msg_iter;
        // LOG (GNUNET_ERROR_TYPE_DEBUG, "do_read - id: %u, batch: %u, peer: %u\n",
        LOG (GNUNET_ERROR_TYPE_DEBUG, "do_read - id: %" PRIu64
             ", batch: %" PRIu64 "\n",
             GNUNET_ntohll (msg_dbg->id),
             GNUNET_ntohll (msg_dbg->batch));
        // LOG (GNUNET_ERROR_TYPE_DEBUG, "do_read - size: %u\n",
        //     ntohs (msg_dbg->size));
        // LOG (GNUNET_ERROR_TYPE_DEBUG, "do_read - (sanity) size msghdr: %u\n",
        //     sizeof (struct GNUNET_MessageHeader));
        // LOG (GNUNET_ERROR_TYPE_DEBUG, "do_read - (sanity) size msg field: %u\n",
        //     sizeof (msg_dbg->id));
      }
      buf_iter = buf_iter + ntohs (msg_iter->size);
      ret_remain = ret_remain - ntohs (msg_iter->size);
    }
 
    /* Enqueue the following messages */
    /* skip the first message */
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Enqueueing messages\n");
    buf_iter = buf + ntohs (msg->size);
    ret_remain = ret - ntohs (msg->size);
    /* iterate over the rest */
    while (0 < ret_remain)
    {
      struct QueuedMessage *q_msg = GNUNET_new (struct QueuedMessage);
 
      LOG (GNUNET_ERROR_TYPE_DEBUG, "Enqueueing message\n");
      msg_iter = (struct GNUNET_MessageHeader *) buf_iter;
      q_msg->msg = GNUNET_malloc (ntohs (msg_iter->size));
      GNUNET_memcpy (q_msg->msg, msg_iter, ntohs (msg_iter->size));
      GNUNET_CONTAINER_DLL_insert_tail (connection->queued_recv_messages_head,
                                        connection->queued_recv_messages_tail,
                                        q_msg);
 
      buf_iter = buf_iter + ntohs (msg_iter->size);
      ret_remain = ret_remain - ntohs (msg_iter->size);
    }
  }
 
  /* check for and handle init */
  if ((0 == ntohs (msg->type)) && /* 0 = GNUNET_MESSAGE_TYPE_TEST is deprecated - usage for this dummy should be fine */
      (CONNECTION_LIVE != connection->status)) /* ignore if current connection is already live */
  {
    char *peer_addr_sent = (char *) &msg[1];
    // FIXME is it really meaningful to send multiple addresses? probably just
    //       send the address that's used to open the connection
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Init-message: %s\n",
         peer_addr_sent);
    if ((NULL != connection->peer_addr) &&
        (0 != strcmp (peer_addr_sent, connection->peer_addr)))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Peer sent us an Init-message with an address different from the one we already know. -> MQ_destroy()\n");
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "sent address: %s\n",
           peer_addr_sent);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "old address: %s\n",
           connection->peer_addr);
      GNUNET_MQ_destroy (connection->mq);
      GNUNET_break_op (0);
      return;
    }
    switch (connection->status)
    {
    case CONNECTION_INITIALIZING_SEND:
      connection->status = CONNECTION_LIVE;
      break;
    case CONNECTION_INITIALIZING:
      connection->status = CONNECTION_INITIALIZING_RECV;
      break;
    case CONNECTION_DESTROY:
      return;
    default:
      break;
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Connection to %s is now %s\n",
         connection->peer_addr,
         status2string (connection->status));
    // else: we could skip ahead to end of if - we do already know the peer_addr
    /* Check whether we already got a connection to that address/peer */
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Init - checking other connections\n");
    for (struct Connection *c_iter = connection->handle->connections_head;
         NULL != c_iter;
         c_iter = c_iter->next)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "  %s (%s)\n",
           c_iter->peer_addr,
           status2string (c_iter->status));
      if ((NULL != c_iter->peer_addr) && /* we can't compare the addr */
          (0 == strcmp (peer_addr_sent, c_iter->peer_addr)) && /* same peer */
          (CONNECTION_LIVE == c_iter->status) && /* other connection is live*/
          (connection != c_iter)) /* discovered the currently handled connection - skip */
      {
        /* We already got a connection with this peer - tear the current one
         * down. */
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "Init from other peer - already connected: %s - MQ_destroy()\n",
             peer_addr_sent);
        connection->status = CONNECTION_DESTROY;
        GNUNET_MQ_destroy (connection->mq);
        return;
      }
    }
    connection->peer_addr = strdup (peer_addr_sent);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Init-Message - notifying caller (%s :%s)\n",
         connection->peer_addr,
         status2string (connection->status));
 
    try_notify_connect (connection);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Finished initializing - going to cancel all still initializing connections to this address\n");
    cancel_initiating_connections (connection->handle, connection);
 
    /* We need to schedule the recv_task here because this is not a message
     * passed to the caller an thus the caller will not call
     * GNUNET_CORE_UNDERLAY_DUMMY_receive_continue () which usually schedules
     * the recv_task */
    connection->recv_task =
      GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                     connection->sock,
                                     do_read,
                                     connection);
    return;
  }
  else if ((0 == ntohs (msg->type)) && /* 0 = GNUNET_MESSAGE_TYPE_TEST is deprecated - usage for this dummy should be fine */
           (CONNECTION_LIVE == connection->status))
  {
    /* We need to schedule the recv_task here because this is not a message
     * passed to the caller an thus the caller will not call
     * GNUNET_CORE_UNDERLAY_DUMMY_receive_continue () which usually schedules
     * the recv_task */
    connection->recv_task =
      GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                     connection->sock,
                                     do_read,
                                     connection);
    return;
  }
 
  if (GNUNET_NO == connection->notify_connect_called)
  {
    /* Notify connect has not been called yet - the caller doesn't know about
     * this connection. Enqueue the first message, too; instead of handling it.
     */
    struct QueuedMessage *q_msg = GNUNET_new (struct QueuedMessage);
 
    q_msg->msg = GNUNET_malloc (ntohs (msg->size));
    GNUNET_memcpy (q_msg->msg, msg, ntohs (msg->size));
    GNUNET_CONTAINER_DLL_insert (connection->queued_recv_messages_head,
                                 connection->queued_recv_messages_tail,
                                 q_msg);
    return;
  }
 
  if (GNUNET_YES == connection->client_ready_to_receive)
  {
    // TODO maybe just call check_for_messages() instead?
    // check_for_messages (connection);
    // FIXME for now the above gives only an unsuccessful test - check why
    connection->client_ready_to_receive = GNUNET_NO;
    // FIXME check return value!!!
    GNUNET_MQ_handle_message (connection->handlers, msg);
  }
  // else TODO
}

References cancel_initiating_connections(), Connection::client_ready_to_receive, CONNECTION_DESTROY, CONNECTION_INITIALIZING, CONNECTION_INITIALIZING_RECV, CONNECTION_INITIALIZING_SEND, CONNECTION_LIVE, GNUNET_CORE_UNDERLAY_DUMMY_Handle::connections_head, do_read(), GNUNET_ALIGN, GNUNET_assert, GNUNET_break_op, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_malloc, GNUNET_memcpy, GNUNET_MQ_destroy(), GNUNET_MQ_handle_message(), GNUNET_NETWORK_socket_recv(), GNUNET_new, GNUNET_NO, GNUNET_ntohll(), GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, Connection::handle, Connection::handlers, id, LOG, Connection::mq, msg, QueuedMessage::msg, Connection::notify_connect_called, Connection::peer_addr, Connection::queued_recv_messages_head, Connection::queued_recv_messages_tail, Connection::recv_task, ret, GNUNET_MessageHeader::size, Connection::sock, Connection::status, status2string(), try_notify_connect(), and GNUNET_MessageHeader::type.

Referenced by check_for_messages(), do_accept(), do_connect_to_peer(), and do_read().

Here is the call graph for this function:

Here is the caller graph for this function:

connection_destroy()

static void connection_destroy ( struct Connection *  connection )

static

Destroy a connection.

cancel all tasks, remove its memory, close sockets, remove it from the DLL, ...

Parameters

connection

The Connection to destroy

Definition at line 363 of file gnunet_core_underlay_dummy.c.

{
  /* The mq should already be cleaned as this function is called from within
   * mq_destroy_impl. */
  LOG (GNUNET_ERROR_TYPE_DEBUG, "connection_destroy\n");
  if ((NULL != connection->handle->notify_disconnect) &&
      (GNUNET_YES == connection->notify_connect_called))
  {
    /* Call the notify disconnect only if the notify_connect_task has been
     * executed and the client was actually notified about the connection */
    connection->handle->notify_disconnect (connection->handle->cls, /* connection-independant cls */
                                           connection->cls_mq); /* connection-specific cls */
  }
  if (NULL != connection->notify_connect_task)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Cancelling notify connect task\n");
    GNUNET_SCHEDULER_cancel (connection->notify_connect_task);
  }
  if (NULL != connection->handle_message_task)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Cancelling handle message task\n");
    GNUNET_SCHEDULER_cancel (connection->handle_message_task);
  }
  if (NULL != connection->write_task)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Cancelling write task\n");
    GNUNET_SCHEDULER_cancel (connection->write_task);
  }
  if (NULL != connection->recv_task)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Cancelling recv task\n");
    GNUNET_SCHEDULER_cancel (connection->recv_task);
  }
  if (NULL != connection->sock)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "closing socket\n");
    GNUNET_NETWORK_socket_close (connection->sock);
  }
  GNUNET_free (connection->peer_addr);
  if (NULL != connection->handlers)
    GNUNET_free (connection->handlers);
  /* Don't free the cls_mq - we don't own it! */
  GNUNET_CONTAINER_DLL_remove (connection->handle->connections_head,
                               connection->handle->connections_tail,
                               connection);
  GNUNET_free (connection);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "connection_destroy - end\n");
}

References GNUNET_CORE_UNDERLAY_DUMMY_Handle::cls, Connection::cls_mq, GNUNET_CORE_UNDERLAY_DUMMY_Handle::connections_head, GNUNET_CORE_UNDERLAY_DUMMY_Handle::connections_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, Connection::handle, Connection::handle_message_task, Connection::handlers, LOG, Connection::notify_connect_called, Connection::notify_connect_task, GNUNET_CORE_UNDERLAY_DUMMY_Handle::notify_disconnect, Connection::peer_addr, Connection::recv_task, Connection::sock, and Connection::write_task.

Referenced by GCO_init(), and mq_destroy_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

set_handlers_closure()

static void set_handlers_closure ( struct GNUNET_MQ_MessageHandler *  handlers, void *  handlers_cls  )

static

Set the closures for mq handlers.

This is a utility function that sets the closures of the given mq handlers to a given closure

Parameters

handlers	the list of handlers
handlers_cls	the new closure for the handlers

Definition at line 428 of file gnunet_core_underlay_dummy.c.

{
  GNUNET_assert (NULL != handlers);
 
  for (unsigned int i = 0; NULL != handlers[i].cb; i++)
    handlers[i].cls = handlers_cls;
}

References GNUNET_assert, and handlers.

Referenced by do_notify_connect().

Here is the caller graph for this function:

do_handle_message()

static void do_handle_message ( void *  cls )

static

Definition at line 439 of file gnunet_core_underlay_dummy.c.

{
  struct Connection *connection = cls;
  struct QueuedMessage *q_msg = connection->queued_recv_messages_head;
  struct GNUNET_MessageHeader *msg = q_msg->msg;
 
  connection->handle_message_task = NULL;
  connection->client_ready_to_receive = GNUNET_NO;
  GNUNET_CONTAINER_DLL_remove (
    connection->queued_recv_messages_head,
    connection->queued_recv_messages_tail,
    q_msg);
  GNUNET_free (q_msg);
  // FIXME check return value!!!
  GNUNET_MQ_handle_message (
    connection->handlers,
    msg);
  // GNUNET_free (msg); // TODO what do we do with this pointer? Who owns it?
  //      Who cleans it?
}

References Connection::client_ready_to_receive, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_handle_message(), GNUNET_NO, Connection::handle_message_task, Connection::handlers, msg, QueuedMessage::msg, Connection::queued_recv_messages_head, and Connection::queued_recv_messages_tail.

Referenced by check_for_messages().

Here is the call graph for this function:

Here is the caller graph for this function:

check_for_messages()

static void check_for_messages ( struct Connection *  connection )

static

Definition at line 462 of file gnunet_core_underlay_dummy.c.

{
  if (NULL != connection->queued_recv_messages_head)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "got messages in the queue - handle those\n");
    GNUNET_assert (NULL == connection->handle_message_task);
    connection->handle_message_task =
      GNUNET_SCHEDULER_add_now (do_handle_message, connection);
  }
  else if (NULL == connection->recv_task)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "no messages in the queue - receive more from socket\n");
    connection->recv_task =
      GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                     connection->sock,
                                     do_read,
                                     connection);
  }
}

References do_handle_message(), do_read(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_UNIT_FOREVER_REL, Connection::handle_message_task, LOG, Connection::queued_recv_messages_head, Connection::recv_task, and Connection::sock.

Referenced by do_notify_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

do_notify_connect()

static void do_notify_connect ( void *  cls )

static

Notify the api caller about a new connection.

This connection could either be initiated by us or the connecting peer. The function is supposed to be called through the scheduler.

Parameters

cls

Definition at line 493 of file gnunet_core_underlay_dummy.c.

{
  struct Connection *connection = cls;
  struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h = connection->handle;
  void *cls_mq;
 
  connection->notify_connect_task = NULL;
  connection->notify_connect_called = GNUNET_YES;
  connection->client_ready_to_receive = GNUNET_YES;
  /* The global, connection-independant closure is given to notify_connect,
   * notify_disconnect and notify_address_change, whereas the
   * connection-specific cls is the return value of notify_connect and given to
   * the handlers. */
  cls_mq =
    h->notify_connect (h->cls,
                       1,
                       (const char **) &connection->peer_addr,
                       connection->mq,
                       NULL); /* peer_id */
  /* The handlers are copied because the connection-specific closures can be
   * set. The global handlers remain the same - they are just called with the
   * connection specific closures. */
  connection->handlers = GNUNET_MQ_copy_handlers (h->handlers);
  set_handlers_closure (connection->handlers, h->cls); /* in case there's no connection-specific closure */
  if (NULL != cls_mq)
  {
    connection->cls_mq = cls_mq;
    // GNUNET_MQ_set_handlers_closure (connection->mq, connection->cls_mq);
    /* Overwrite the closure set above with the cls_mq */
    set_handlers_closure (connection->handlers, connection->cls_mq);
  }
 
  /* Handle already enqueued messages */
  check_for_messages (connection);
}

References check_for_messages(), Connection::client_ready_to_receive, Connection::cls_mq, GNUNET_MQ_copy_handlers(), GNUNET_YES, h, Connection::handle, Connection::handlers, Connection::mq, Connection::notify_connect_called, Connection::notify_connect_task, Connection::peer_addr, and set_handlers_closure().

Referenced by try_notify_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

try_notify_connect()

static void try_notify_connect ( struct Connection *  connection )

static

Definition at line 531 of file gnunet_core_underlay_dummy.c.

{
  if ((NULL != connection->peer_addr) &&
      (CONNECTION_LIVE == connection->status) &&
      (NULL != connection->handle->notify_connect) &&
      (NULL == connection->notify_connect_task))
  {
    connection->notify_connect_task =
      GNUNET_SCHEDULER_add_now (do_notify_connect, connection);
  }
}

References CONNECTION_LIVE, do_notify_connect(), GNUNET_SCHEDULER_add_now(), Connection::handle, GNUNET_CORE_UNDERLAY_DUMMY_Handle::notify_connect, Connection::notify_connect_task, Connection::peer_addr, and Connection::status.

Referenced by do_read(), and write_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

cancel_initiating_connections()

static void cancel_initiating_connections ( struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *  h, struct Connection *  connection  )

static

Definition at line 545 of file gnunet_core_underlay_dummy.c.

{
  struct Connection *c_iter_next;
  char *peer_addr = connection->peer_addr;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Going to cancel all initializing connections to %s\n",
       peer_addr);
  if (NULL == peer_addr)
    return;                      /* No sense in comparing to unknown address */
  for (struct Connection *c_iter = h->connections_head;
       NULL != c_iter;
       c_iter = c_iter_next)
  {
    c_iter_next = c_iter->next;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "  %s :%s\n",
         c_iter->peer_addr,
         status2string (c_iter->status));
    if ((c_iter != connection) && /* Don't shut down current connection */
        (NULL != c_iter->peer_addr) && /* No address - can't compare */
        (0 == strcmp (c_iter->peer_addr, peer_addr)) &&
        (
          (CONNECTION_INITIALIZING == c_iter->status) ||
          (CONNECTION_INITIALIZING_SEND == c_iter->status) ||
          (CONNECTION_INITIALIZING_RECV == c_iter->status)))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "    -> Cancelling connection - MQ_destroy()\n");
      GNUNET_MQ_destroy (c_iter->mq);
    }
  }
}

References CONNECTION_INITIALIZING, CONNECTION_INITIALIZING_RECV, CONNECTION_INITIALIZING_SEND, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_destroy(), h, LOG, Connection::next, Connection::peer_addr, and status2string().

Referenced by do_read(), and write_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

write_cb()

static void write_cb ( void *  cls )

static

Callback scheduled to run once the socket is ready for writing.

Writes the message to the socket.

Parameters

cls	Closure: The handle of the underlay dummy

Definition at line 836 of file gnunet_core_underlay_dummy.c.

{
  ssize_t sent;
  struct Connection *connection = cls;
 
  connection->write_task = NULL;
  GNUNET_assert (NULL != connection->sock);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "write_cb(): sending bytes to %s :%s\n",
       connection->peer_addr,
       status2string (connection->status));
  {
    // XXX only for debugging purposes
    // this shows everything works as expected
 
    struct GNUNET_UNDERLAY_DUMMY_Message
    {
      struct GNUNET_MessageHeader header;
      // The following will be used for debugging
      uint64_t id; // id of the message
      uint64_t batch; // first batch of that peer (for this test 0 or 1)
      // uint64_t peer; // number of sending peer (for this test 0 or 1)
    };
 
 
    struct GNUNET_UNDERLAY_DUMMY_Message *msg_dbg =
      (struct GNUNET_UNDERLAY_DUMMY_Message *) connection->message_to_send;
    // LOG (GNUNET_ERROR_TYPE_DEBUG, "write_cb - id: %u, batch: %u, peer: %u\n",
    LOG (GNUNET_ERROR_TYPE_DEBUG, "write_cb - id: %" PRIu64 ", batch: %" PRIu64
         "\n",
         GNUNET_ntohll (msg_dbg->id),
         GNUNET_ntohll (msg_dbg->batch));
    // LOG (GNUNET_ERROR_TYPE_DEBUG, "write_cb - size: %u\n",
    //     ntohs (msg_dbg->size));
    // LOG (GNUNET_ERROR_TYPE_DEBUG, "write_cb - (sanity) size msghdr: %u\n",
    //     sizeof (struct GNUNET_MessageHeader));
    // LOG (GNUNET_ERROR_TYPE_DEBUG, "write_cb - (sanity) size msg field: %u\n",
    //     sizeof (msg_dbg->id));
  }
  GNUNET_assert (NULL != connection->message_to_send);
  sent = GNUNET_NETWORK_socket_send (
    connection->sock,
    connection->message_to_send,
    ntohs (connection->message_to_send->size));
  if (GNUNET_SYSERR == sent)
  {
    // LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to send message\n");
    LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to send message: %s\n", strerror (
           errno));
    if (EPIPE == errno)
    {
      /* Tear down the connection */
      LOG (GNUNET_ERROR_TYPE_DEBUG, "MQ_destroy() (Failed to send message)\n");
      connection->status = CONNECTION_DESTROY;
      GNUNET_MQ_destroy (connection->mq); // This triggers mq_destroy_impl()
      return;
    }
    LOG (GNUNET_ERROR_TYPE_ERROR, "Retrying (due to failure)\n");
    /* retry */
    connection->write_task =
      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                      connection->sock,
                                      &write_cb,
                                      connection);
    return; // TODO proper handling - don't try to resend on certain errors
            // (e.g. EPIPE as above)
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Successfully sent message\n");
  connection->message_to_send = NULL;
  switch (connection->status)
  {
  case CONNECTION_INITIALIZING_RECV:
    connection->status = CONNECTION_LIVE;
    try_notify_connect (connection);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Finished initializing - going to cancel all still initializing connections to this address\n");
    cancel_initiating_connections (connection->handle, connection);
    break;
  case CONNECTION_INITIALIZING:
    connection->status = CONNECTION_INITIALIZING_SEND;
    break;
  case CONNECTION_DESTROY:
    return;
  default:
    break;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Connection to %s is now %s\n",
       connection->peer_addr,
       status2string (connection->status));
  GNUNET_MQ_impl_send_continue (connection->mq);
}

References cancel_initiating_connections(), CONNECTION_DESTROY, CONNECTION_INITIALIZING, CONNECTION_INITIALIZING_RECV, CONNECTION_INITIALIZING_SEND, CONNECTION_LIVE, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_MQ_destroy(), GNUNET_MQ_impl_send_continue(), GNUNET_NETWORK_socket_send(), GNUNET_ntohll(), GNUNET_SCHEDULER_add_write_net(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, Connection::handle, id, LOG, Connection::message_to_send, Connection::mq, Connection::peer_addr, GNUNET_MessageHeader::size, Connection::sock, Connection::status, status2string(), try_notify_connect(), write_cb(), and Connection::write_task.

Referenced by mq_send_impl(), and write_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

send_init()

static void send_init ( struct Connection *  connection )

static

Definition at line 931 of file gnunet_core_underlay_dummy.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
  uint32_t peer_addr_len;
 
  GNUNET_assert (NULL != connection->handle->sock_name);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending init: %s\n",
       connection->handle->sock_name);
  peer_addr_len = strnlen (connection->handle->sock_name, 128) + 1;
  env = GNUNET_MQ_msg_header_extra (msg, // usually we wanted to keep the
                                    peer_addr_len, // envelopes to potentially cancel the
                                    0);  // message
  GNUNET_memcpy (&msg[1], connection->handle->sock_name, peer_addr_len);
  GNUNET_MQ_send (connection->mq, env);
}

References env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_MQ_msg_header_extra, GNUNET_MQ_send(), Connection::handle, LOG, Connection::mq, msg, GNUNET_CORE_UNDERLAY_DUMMY_Handle::sock_name, and strnlen().

Referenced by do_accept(), and do_connect_to_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_send_impl()

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

static

Callback called from the MQ to send a message over a socket.

Schedules the sending of the message once the socket is ready.

Parameters

mq	The message queue
msg	The message to send
impl_state	The handle of the underlay dummy

Definition at line 959 of file gnunet_core_underlay_dummy.c.

{
  struct Connection *connection = impl_state;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "from mq_send_impl\n");
  {
    // XXX only for debugging purposes
    // this shows everything works as expected
 
    struct GNUNET_UNDERLAY_DUMMY_Message
    {
      struct GNUNET_MessageHeader header;
      // The following will be used for debugging
      uint64_t id; // id of the message
      uint64_t batch; // first batch of that peer (for this test 0 or 1)
      // uint64_t peer; // number of sending peer (for this test 0 or 1)
    };
 
    struct GNUNET_UNDERLAY_DUMMY_Message *msg_dbg =
      (struct GNUNET_UNDERLAY_DUMMY_Message *) msg;
    LOG (GNUNET_ERROR_TYPE_DEBUG, "id: %" PRIu64 ", batch: %" PRIu64 "\n",
         GNUNET_ntohll (msg_dbg->id),
         GNUNET_ntohll (msg_dbg->batch));
  }
  connection->message_to_send = msg;
  GNUNET_assert (NULL == connection->write_task);
  connection->write_task =
    GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                    connection->sock,
                                    &write_cb,
                                    connection);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Scheduled sending of message\n");
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ntohll(), GNUNET_SCHEDULER_add_write_net(), GNUNET_TIME_UNIT_FOREVER_REL, id, LOG, Connection::message_to_send, msg, Connection::sock, write_cb(), and Connection::write_task.

Referenced by do_accept(), and do_connect_to_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_destroy_impl()

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

static

Callback to destroy the message queue.

Parameters

mq	message queue to destroy
impl_state	The handle of the underlay dummy

Definition at line 1003 of file gnunet_core_underlay_dummy.c.

{
  struct Connection *connection = impl_state;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "mq_destroy_impl\n");
  connection_destroy (connection);
}

References connection_destroy(), GNUNET_ERROR_TYPE_DEBUG, and LOG.

Referenced by do_accept(), and do_connect_to_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_cancel_impl()

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

static

Callback to cancel sending a message.

Parameters

mq	The message queue the message was supposed to be sent over.
impl_state	The handle of the underlay dummy

Definition at line 1019 of file gnunet_core_underlay_dummy.c.

{
  struct Connection *connection = impl_state;
 
  if (NULL != connection->write_task)
  {
    GNUNET_SCHEDULER_cancel (connection->write_task);
    connection->write_task = NULL;
  }
}

References GNUNET_SCHEDULER_cancel(), and Connection::write_task.

Referenced by do_accept(), and do_connect_to_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_error_handler_impl()

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

static

Handle mq errors.

This is currently a stub that only logs.

Parameters

cls	closure is unused
error	the kind of error

Definition at line 1040 of file gnunet_core_underlay_dummy.c.

{
  LOG (GNUNET_ERROR_TYPE_ERROR,
       "mq_error_handler_impl: %u\n",
       error);
}

References GNUNET_ERROR_TYPE_ERROR, and LOG.

Referenced by do_accept(), and do_connect_to_peer().

Here is the caller graph for this function:

do_accept()

static void do_accept ( void *  cls )

static

Accept a connection on the dummy's socket.

Parameters

cls	the handle to the dummy passed as closure

Definition at line 1054 of file gnunet_core_underlay_dummy.c.

{
  struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h = cls;
 
  struct Connection *connection;
  struct GNUNET_NETWORK_Handle *sock;
  struct sockaddr_un addr_other;
  socklen_t addr_other_len = sizeof(addr_other);
  memset (&addr_other, 0, sizeof (addr_other));
 
  h->listen_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                                  h->sock_listen,
                                                  do_accept,
                                                  h);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Handling incoming connection\n");
 
  GNUNET_assert (NULL != h->sock_listen);
 
  LOG (GNUNET_ERROR_TYPE_INFO, "Accepting incoming connection\n");
  sock = GNUNET_NETWORK_socket_accept (h->sock_listen,
                                       (struct sockaddr *) &addr_other,
                                       &addr_other_len);
  if (NULL == sock)
  {
    // LOG(GNUNET_ERROR_TYPE_ERROR, "Error accepting incoming connection, %s", strerror(errno));
    LOG (GNUNET_ERROR_TYPE_ERROR, "Error accepting incoming connection\n");
    return;
  }
  if (GNUNET_OK != GNUNET_NETWORK_socket_set_blocking (sock, GNUNET_NO))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Failed setting socket of incoming connection to non-blocking\n");
    return;
  }
  connection = GNUNET_new (struct Connection);
  connection->sock = sock;
  connection->peer_addr = NULL; // GNUNET_strdup (addr_other.sun_path); should
                                // be empty
  connection->handle = h;
  connection->notify_connect_called = GNUNET_NO;
  connection->client_ready_to_receive = GNUNET_NO;
  connection->status = CONNECTION_INITIALIZING;
  LOG (GNUNET_ERROR_TYPE_INFO, "Peer connected\n");
  GNUNET_CONTAINER_DLL_insert (h->connections_head,
                               h->connections_tail,
                               connection);
  connection->mq =
    GNUNET_MQ_queue_for_callbacks (mq_send_impl,
                                   mq_destroy_impl,
                                   mq_cancel_impl,
                                   connection, // impl_state - gets passed to _impls
                                   h->handlers,
                                   mq_error_handler_impl,
                                   connection->cls_mq);
  connection->recv_task =
    GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                   connection->sock,
                                   do_read,
                                   connection);
  send_init (connection);
}

References Connection::client_ready_to_receive, GNUNET_CORE_UNDERLAY_DUMMY_Handle::cls, Connection::cls_mq, CONNECTION_INITIALIZING, do_accept(), do_read(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_MQ_queue_for_callbacks(), GNUNET_NETWORK_socket_accept(), GNUNET_NETWORK_socket_set_blocking(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_UNIT_FOREVER_REL, h, Connection::handle, LOG, Connection::mq, mq_cancel_impl(), mq_destroy_impl(), mq_error_handler_impl(), mq_send_impl(), Connection::notify_connect_called, Connection::peer_addr, Connection::recv_task, send_init(), Connection::sock, and Connection::status.

Referenced by do_accept(), and do_open_listening_socket().

Here is the call graph for this function:

Here is the caller graph for this function:

do_connect_to_peer()

static void do_connect_to_peer ( void *  cls )

static

Connect to another peer.

This function is scheduled and pays attention that it's not called unnecessarily.

Parameters

cls

Definition at line 1127 of file gnunet_core_underlay_dummy.c.

{
  struct PeerConnectCls *pcc = cls;
 
  pcc->peer_connect_task = NULL;
  GNUNET_CONTAINER_DLL_remove (pcc->h->peer_connect_cls_head,
                               pcc->h->peer_connect_cls_tail,
                               pcc);
  {
    struct Connection *connection;
    struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h = pcc->h;
    struct sockaddr_un addr_other;
    memset (&addr_other, 0, sizeof (addr_other));
 
    connection = GNUNET_new (struct Connection);
    connection->handle = pcc->h;
    connection->sock = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
    connection->peer_addr = pcc->sock_name;
    connection->notify_connect_called = GNUNET_NO;
    connection->client_ready_to_receive = GNUNET_NO;
    connection->status = CONNECTION_INITIALIZING;
    if (NULL == connection->sock)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR, "Socket does not open\n");
      GNUNET_free (connection);
      return;
    }
    if (GNUNET_OK !=
        GNUNET_NETWORK_socket_set_blocking (connection->sock, GNUNET_NO))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR, "Failed setting socket to non-blocking\n");
      GNUNET_free (connection);
      return;
    }
 
    addr_other.sun_family = AF_UNIX;
    // strcpy (addr_other.sun_path, pcc->sock_name);
    GNUNET_memcpy (addr_other.sun_path, pcc->sock_name, strlen (pcc->sock_name))
    ;
    if (GNUNET_OK != GNUNET_NETWORK_socket_connect (connection->sock,
                                                    (struct sockaddr *) &
                                                    addr_other,
                                                    sizeof(addr_other)))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "failed to connect to the socket: %u %s (closing socket)\n",
           errno, strerror (errno));
      GNUNET_NETWORK_socket_close (connection->sock);
      GNUNET_free (connection);
      // LOG (GNUNET_ERROR_TYPE_INFO, "Sanity check: %s\n", addr_other.sun_path);
      return;
    }
    connection->peer_addr = GNUNET_strdup (pcc->sock_name);
    LOG (GNUNET_ERROR_TYPE_INFO, "Successfully connected to socket\n");
    connection->recv_task =
      GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                     connection->sock,
                                     do_read,
                                     connection);
    connection->mq =
      GNUNET_MQ_queue_for_callbacks (mq_send_impl,
                                     mq_destroy_impl,
                                     mq_cancel_impl,
                                     connection, // impl_state - gets passed to _impls
                                     h->handlers,
                                     mq_error_handler_impl,
                                     connection->cls_mq);
    GNUNET_CONTAINER_DLL_insert (h->connections_head,
                                 h->connections_tail,
                                 connection);
    send_init (connection);
 
    //  FIXME: proper array
    //  FIXME: proper address format ("dummy:<sock_name>")
  }
  GNUNET_free (pcc->sock_name);
  GNUNET_free (pcc);
}

References Connection::client_ready_to_receive, Connection::cls_mq, CONNECTION_INITIALIZING, do_read(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_memcpy, GNUNET_MQ_queue_for_callbacks(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_connect(), GNUNET_NETWORK_socket_create(), GNUNET_NETWORK_socket_set_blocking(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_REL, h, PeerConnectCls::h, Connection::handle, LOG, Connection::mq, mq_cancel_impl(), mq_destroy_impl(), mq_error_handler_impl(), mq_send_impl(), Connection::notify_connect_called, Connection::peer_addr, GNUNET_CORE_UNDERLAY_DUMMY_Handle::peer_connect_cls_head, GNUNET_CORE_UNDERLAY_DUMMY_Handle::peer_connect_cls_tail, PeerConnectCls::peer_connect_task, Connection::recv_task, send_init(), Connection::sock, PeerConnectCls::sock_name, and Connection::status.

Referenced by try_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

do_notify_address_change()

static void do_notify_address_change ( void *  cls )

static

Notify core about address change.

This is in an extra function so the callback gets called after the GNUNET_CORE_UNDERLAY_DUMMY_connect() finishes.

Parameters

cls	Closure: The handle of the dummy underlay.

Definition at line 1216 of file gnunet_core_underlay_dummy.c.

{
  struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h = cls;
  const char *addresses[1] = {h->sock_name}; // The dummy will only ever know
                                             // about this one address
 
  h->notify_address_change_task = NULL;
  h->notify_address_change (h->cls, 1, addresses);
}

References GNUNET_CORE_UNDERLAY_DUMMY_Handle::cls, and h.

Referenced by do_open_listening_socket().

Here is the caller graph for this function:

try_connect()

static void try_connect ( struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *  h, const char *  address  )

static

Check whether we are already connected to this peer

This is limited as we don't always have the socket name of the other peer

Definition at line 1228 of file gnunet_core_underlay_dummy.c.

{
  GNUNET_assert (0 != strcmp (address, ""));
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Trying to connect to socket: `%s'\n", address);
  if (0 == strcmp (address, h->sock_name))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Not going to connect to own address\n");
    return;
  }
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Discovered another peer with address `%s'\n",
       address);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "checking other connections:\n");
  for (struct Connection *conn_iter = h->connections_head;
       NULL != conn_iter;
       conn_iter = conn_iter->next)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "  %s (%s)\n",
         conn_iter->peer_addr,
         status2string (conn_iter->status));
    if ((NULL != conn_iter->peer_addr) &&
        (0 == strcmp (address, conn_iter->peer_addr)) &&
        (CONNECTION_LIVE == conn_iter->status))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Already connected to this peer - don't try to open another connection\n");
      return;
    }
  }
  for (struct PeerConnectCls *pcc_iter = h->peer_connect_cls_head;
       NULL != pcc_iter;
       pcc_iter = pcc_iter->next)
  {
    if (0 == strcmp (address,
                     pcc_iter->sock_name))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG, "Already waiting to connect to this peer\n")
      ;
      return;
    }
  }
 
  {
    struct PeerConnectCls *peer_connect_cls;
    peer_connect_cls = GNUNET_new (struct PeerConnectCls);
    peer_connect_cls->h = h;
    peer_connect_cls->sock_name = GNUNET_strdup (address);
    peer_connect_cls->peer_connect_task =
      GNUNET_SCHEDULER_add_now (do_connect_to_peer,
                                peer_connect_cls);
    GNUNET_CONTAINER_DLL_insert (h->peer_connect_cls_head,
                                 h->peer_connect_cls_tail,
                                 peer_connect_cls);
  }
}

References address, CONNECTION_LIVE, do_connect_to_peer(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, h, PeerConnectCls::h, LOG, PeerConnectCls::peer_connect_task, PeerConnectCls::sock_name, and status2string().

Referenced by discovered_socket_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

discovered_socket_cb()

static enum GNUNET_GenericReturnValue discovered_socket_cb ( void *  cls, const char *  filename  )

static

Handle the discovery of a certain socket.

This is called from within the discovery of file names with the correct pattern. It checks whether we are already connected to this socket, are waiting for a reply, it's our own socket. Issue a connection if the conditions are given.

Parameters

cls	handle to the dummy service
filename	the discovered filename

Returns

GNUNET_OK indicating that the iteration through filenames is supposed to continue

Definition at line 1308 of file gnunet_core_underlay_dummy.c.

{
  struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h = cls;
 
  try_connect (h, filename);
 
  return GNUNET_OK;
}

References GNUNET_CORE_UNDERLAY_DUMMY_Handle::cls, filename, GNUNET_OK, h, and try_connect().

Referenced by do_discover_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

do_discover_peers()

static void do_discover_peers ( void *  cls )

static

Discover sockets of other peers.

Sockets with a certain file name pattern are treated as candidates.

Parameters

cls

Definition at line 1327 of file gnunet_core_underlay_dummy.c.

{
  struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h = cls;
  int ret;
 
  ret = GNUNET_DISK_glob (SOCK_NAME_BASE "*" SOCK_EXTENSION,
                          discovered_socket_cb,
                          h);
  if (0 > ret)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING, "Scanning for unix domain sockets failed\n")
    ;
  }
 
  h->peer_discovery_task = GNUNET_SCHEDULER_add_delayed (
    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100),
    do_discover_peers,
    h);
}

References GNUNET_CORE_UNDERLAY_DUMMY_Handle::cls, discovered_socket_cb(), do_discover_peers(), GNUNET_DISK_glob(), GNUNET_ERROR_TYPE_WARNING, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MILLISECONDS, h, LOG, and ret.

Referenced by do_discover_peers(), and do_open_listening_socket().

Here is the call graph for this function:

Here is the caller graph for this function:

try_open_listening_socket()

static enum GNUNET_GenericReturnValue try_open_listening_socket ( struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *  h, char *  sock_name  )

static

Definition at line 1349 of file gnunet_core_underlay_dummy.c.

{
  struct sockaddr_un *addr_un;
  socklen_t addr_un_len;
  uint8_t ret = GNUNET_NO;
 
  h->sock_listen = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
  GNUNET_assert (NULL != h->sock_listen);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Opened socket, going to bind to address\n");
 
  addr_un = GNUNET_new (struct sockaddr_un);
  addr_un->sun_family = AF_UNIX;
  // TODO check that the string is not too long
  GNUNET_memcpy (&addr_un->sun_path, sock_name, strlen (sock_name));
  addr_un_len = sizeof (struct sockaddr_un);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Trying to bind to `%s'\n", addr_un->sun_path);
  ret = GNUNET_NETWORK_socket_bind (h->sock_listen,
                                    (struct sockaddr *) addr_un,
                                    addr_un_len);
  if ((GNUNET_OK != ret) && (98 != errno))
  {
    /* Error different from Address already in use - cancel */
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Failed binding to socket: %u %s (closing socket)\n",
         errno, strerror (errno));
    GNUNET_NETWORK_socket_close (h->sock_listen);
    h->sock_listen = NULL;
    GNUNET_free (addr_un);
    return GNUNET_SYSERR;
  }
  else if (GNUNET_OK != ret)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "  -> something went wrong (address is probably in use)\n");
    GNUNET_NETWORK_socket_close (h->sock_listen);
    h->sock_listen = NULL;
    GNUNET_free (addr_un);
  }
  else if (GNUNET_OK == ret)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "  -> succeeded! (binding to socket)\n");
    h->sock_name = GNUNET_strdup (sock_name);
  }
  GNUNET_free (addr_un);
  return ret;
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_memcpy, GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, h, LOG, and ret.

Referenced by do_open_listening_socket().

Here is the call graph for this function:

Here is the caller graph for this function:

do_open_listening_socket()

static void do_open_listening_socket ( void *  cls, uint64_t  sock_name_ctr_start  )

static

Opens UNIX domain socket.

It start trying with a default name and successively increases a number within it, when it encounters already used sockets.

Parameters

cls	Closure: The handle of the dummy underlay.
sock_name_ctr	TODO Append to the socket name to avoid collisions TODO

Definition at line 1410 of file gnunet_core_underlay_dummy.c.

{
  struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h = cls;
  char *sock_name;
  uint64_t sock_name_ctr = sock_name_ctr_start; // Append to the socket name to avoid collisions
  uint8_t ret = GNUNET_NO;
 
  /* Open a socket that's not occupied by another 'peer' yet:
   * Try opening sockets with an increasing counter in the socket name. */
  // TODO we might want to change this loop to schedule a new task
  do {
    GNUNET_asprintf (&sock_name,
                     SOCK_NAME_BASE "%" PRIu64 "" SOCK_EXTENSION "\0",
                     sock_name_ctr++);
    ret = try_open_listening_socket (h, sock_name);
    GNUNET_free (sock_name);
    if (GNUNET_SYSERR == ret)
      return;
  } while (GNUNET_YES != ret);
  LOG (GNUNET_ERROR_TYPE_INFO, "Bound to `%s'\n", h->sock_name);
  h->sock_name_index_start = sock_name_ctr_start;
  h->sock_name_index = sock_name_ctr;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Mark socket as accepting connections\n");
  if (GNUNET_OK != GNUNET_NETWORK_socket_listen (h->sock_listen, BACKLOG))
  {
    // LOG (GNUNET_ERROR_TYPE_ERROR, "Failed listening to socket: %s", strerror(errno));
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Failed listening to socket (closing socket)\n");
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (h->sock_listen));
    h->sock_listen = NULL;
    GNUNET_free (h->sock_name);
    return;
  }
 
  if (NULL != h->notify_address_change)
  {
    // TODO cancel and cleanup task on run and shutdown
    LOG (GNUNET_ERROR_TYPE_DEBUG, "schedlue do_notify_address_change()\n");
    h->notify_address_change_task =
      GNUNET_SCHEDULER_add_now (do_notify_address_change, h);
  }
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "scheudle do_discover_peers()\n");
  h->peer_discovery_task = GNUNET_SCHEDULER_add_delayed (
    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100),
    do_discover_peers,
    h);
 
  LOG (GNUNET_ERROR_TYPE_INFO, "Going to listen for connections\n");
  h->listen_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                                  h->sock_listen,
                                                  do_accept,
                                                  h);
}

References GNUNET_CORE_UNDERLAY_DUMMY_Handle::cls, do_accept(), do_discover_peers(), do_notify_address_change(), GNUNET_asprintf(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_listen(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_net(), GNUNET_SYSERR, GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_YES, h, LOG, ret, GNUNET_CORE_UNDERLAY_DUMMY_Handle::sock_name, and try_open_listening_socket().

Referenced by GNUNET_CORE_UNDERLAY_DUMMY_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

do_close_listening_socket()

static void do_close_listening_socket ( void *  cls )

static

Definition at line 1470 of file gnunet_core_underlay_dummy.c.

{
  struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h = cls;
  struct PeerConnectCls *pcc_next;
  struct Connection *conn_next;
 
  if (NULL != h->notify_address_change_task)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Cancelling notify address change task\n");
    GNUNET_SCHEDULER_cancel (h->notify_address_change_task);
    h->notify_address_change_task = NULL;
  }
  if (NULL != h->peer_discovery_task)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Cancelling peer discovery task\n");
    GNUNET_SCHEDULER_cancel (h->peer_discovery_task);
    h->peer_discovery_task = NULL;
  }
  for (struct PeerConnectCls *pcc = h->peer_connect_cls_head;
       NULL != pcc;
       pcc = pcc_next)
  {
    pcc_next = pcc->next;
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Cancelling peer connect task\n");
    GNUNET_SCHEDULER_cancel (pcc->peer_connect_task);
    GNUNET_CONTAINER_DLL_remove (h->peer_connect_cls_head,
                                 h->peer_connect_cls_tail,
                                 pcc);
    GNUNET_free (pcc->sock_name);
    GNUNET_free (pcc);
  }
  if (NULL != h->listen_task)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Cancelling listen task\n");
    GNUNET_SCHEDULER_cancel (h->listen_task);
    h->listen_task = NULL;
  }
  if (NULL != h->sock_listen)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "closing socket\n");
    GNUNET_NETWORK_socket_close (h->sock_listen);
    h->sock_listen = NULL;
  }
  for (struct Connection *conn_iter = h->connections_head;
       NULL != conn_iter;
       conn_iter = conn_next)
  {
    // TODO consider moving MQ_destroy() into connection_destroy(), but keep in
    // mind that connection_destroy() is also called from within
    // mq_destroy_impl()
    conn_next = conn_iter->next;
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying a connection - MQ_destroy()\n");
    conn_iter->status = CONNECTION_DESTROY;
    GNUNET_MQ_destroy (conn_iter->mq); // This triggers mq_destroy_impl()
  }
}

References GNUNET_CORE_UNDERLAY_DUMMY_Handle::cls, CONNECTION_DESTROY, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), h, LOG, PeerConnectCls::next, and Connection::next.

Referenced by GNUNET_CORE_UNDERLAY_DUMMY_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CORE_UNDERLAY_DUMMY_connect()

struct GNUNET_CORE_UNDERLAY_DUMMY_Handle * GNUNET_CORE_UNDERLAY_DUMMY_connect	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const struct GNUNET_MQ_MessageHandler *	handlers,
		void *	cls,
		GNUNET_CORE_UNDERLAY_DUMMY_NotifyConnect	nc,
		GNUNET_CORE_UNDERLAY_DUMMY_NotifyDisconnect	nd,
		GNUNET_CORE_UNDERLAY_DUMMY_NotifyAddressChange	na
	)

Connect to the core underlay dummy service.

Note that the connection may complete (or fail) asynchronously.

Parameters

cfg	configuration to use
handlers	array of message handlers or NULL; note that the closures provided will be ignored and replaced with the respective return value from nc
cls	closure for the nc, nd and na callbacks
nc	function to call on connect events, or NULL. Returns the closure for message handlers for this opened connection.
nd	function to call on disconnect events, or NULL
na	function to call on address changes, or NULL

Returns

NULL on error

Note that the connection may complete (or fail) asynchronously.

Parameters

cfg	configuration to use
handlers	array of message handlers or NULL; note that the closures provided will be ignored and replaced with the respective return value from nc
cls	closure for the nc, nd and na callbacks
nc	function to call on connect events, or NULL
nd	function to call on disconnect events, or NULL
na	function to call on address changes, or NULL

Returns

NULL on error

Definition at line 1544 of file gnunet_core_underlay_dummy.c.

{
  struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *h;
 
  h = GNUNET_malloc (sizeof (struct GNUNET_CORE_UNDERLAY_DUMMY_Handle));
  h->notify_connect = nc;
  h->notify_disconnect = nd;
  h->notify_address_change = na;
  if (NULL != handlers)
    h->handlers = GNUNET_MQ_copy_handlers (handlers);
  h->cls = cls;
 
  do_open_listening_socket (h, 0);
 
  // h->address_change_task = GNUNET_SCHEDULER_add_delayed (
  //    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
  //    do_change_address,
  //    h);
 
  LOG (GNUNET_ERROR_TYPE_INFO, "Core connected\n");
 
  return h;
}

References GNUNET_CORE_UNDERLAY_DUMMY_Handle::cls, do_open_listening_socket(), GNUNET_ERROR_TYPE_INFO, GNUNET_malloc, GNUNET_MQ_copy_handlers(), h, handlers, LOG, and nc.

Here is the call graph for this function:

GNUNET_CORE_UNDERLAY_DUMMY_disconnect()

void GNUNET_CORE_UNDERLAY_DUMMY_disconnect

(

struct GNUNET_CORE_UNDERLAY_DUMMY_Handle *

handle

)

Disconnect from the core underlay dummy service.

Parameters

handle

handle returned from connect

Definition at line 1581 of file gnunet_core_underlay_dummy.c.

{
  LOG (GNUNET_ERROR_TYPE_INFO, "Core disconnects\n");
  // TODO delete, free and close everything
  if (NULL != handle->address_change_task)
    GNUNET_SCHEDULER_cancel (handle->address_change_task);
  do_close_listening_socket (handle);
  if (NULL != handle->handlers)
    GNUNET_free (handle->handlers);
  GNUNET_free (handle->sock_name);
  GNUNET_free (handle);
  LOG (GNUNET_ERROR_TYPE_INFO, "  -> Disconnected\n");
}

References do_close_listening_socket(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_SCHEDULER_cancel(), handle, and LOG.

Here is the call graph for this function:

Variable Documentation

next [1/3]

struct PeerConnectCls* PeerConnectCls::next

Linked list next.

Definition at line 72 of file gnunet_core_underlay_dummy.c.

Referenced by do_close_listening_socket().

prev [1/3]

struct PeerConnectCls* PeerConnectCls::prev

Linked list previous.

Definition at line 77 of file gnunet_core_underlay_dummy.c.

h

struct GNUNET_CORE_UNDERLAY_DUMMY_Handle* PeerConnectCls::h

The handle for the service.

Definition at line 82 of file gnunet_core_underlay_dummy.c.

Referenced by do_connect_to_peer(), and try_connect().

sock_name [1/2]

char* PeerConnectCls::sock_name

The file name to connect to.

Definition at line 87 of file gnunet_core_underlay_dummy.c.

Referenced by do_connect_to_peer(), and try_connect().

peer_connect_task

struct GNUNET_SCHEDULER_Task* PeerConnectCls::peer_connect_task

Task to connect to another peer.

Definition at line 92 of file gnunet_core_underlay_dummy.c.

Referenced by do_connect_to_peer(), and try_connect().

next [2/3]

struct QueuedMessage* QueuedMessage::next

Definition at line 98 of file gnunet_core_underlay_dummy.c.

prev [2/3]

struct QueuedMessage* QueuedMessage::prev

Definition at line 99 of file gnunet_core_underlay_dummy.c.

msg

struct GNUNET_MessageHeader* QueuedMessage::msg

Definition at line 101 of file gnunet_core_underlay_dummy.c.

Referenced by do_handle_message(), and do_read().

next [3/3]

struct Connection* Connection::next

Linked list next.

Definition at line 132 of file gnunet_core_underlay_dummy.c.

Referenced by cancel_initiating_connections(), and do_close_listening_socket().

prev [3/3]

struct Connection* Connection::prev

Linked list previous.

Definition at line 137 of file gnunet_core_underlay_dummy.c.

mq

struct GNUNET_MQ_Handle* Connection::mq

Message queue towards the connected peer.

Definition at line 142 of file gnunet_core_underlay_dummy.c.

Referenced by do_accept(), do_connect_to_peer(), do_notify_connect(), do_read(), send_init(), and write_cb().

handlers [1/2]

struct GNUNET_MQ_MessageHandler* Connection::handlers

Handlers for mq.

Definition at line 147 of file gnunet_core_underlay_dummy.c.

Referenced by connection_destroy(), do_handle_message(), do_notify_connect(), and do_read().

cls_mq

void* Connection::cls_mq

Closure for the mq towards the client.

Connection-specific, given to handlers and disconnect_cb/notify_disconnect

Definition at line 154 of file gnunet_core_underlay_dummy.c.

Referenced by connection_destroy(), do_accept(), do_connect_to_peer(), and do_notify_connect().

sock

struct GNUNET_NETWORK_Handle* Connection::sock

Socket for the connected peer.

Definition at line 159 of file gnunet_core_underlay_dummy.c.

Referenced by check_for_messages(), connection_destroy(), do_accept(), do_connect_to_peer(), do_read(), mq_send_impl(), and write_cb().

peer_addr

char* Connection::peer_addr

Address of the connected peer.

Definition at line 164 of file gnunet_core_underlay_dummy.c.

Referenced by cancel_initiating_connections(), connection_destroy(), do_accept(), do_connect_to_peer(), do_notify_connect(), do_read(), try_notify_connect(), and write_cb().

recv_task

struct GNUNET_SCHEDULER_Task* Connection::recv_task

Task waiting for incoming messages.

Definition at line 169 of file gnunet_core_underlay_dummy.c.

Referenced by check_for_messages(), connection_destroy(), do_accept(), do_connect_to_peer(), and do_read().

write_task

struct GNUNET_SCHEDULER_Task* Connection::write_task

Task waiting until the socket becomes ready to be written to.

Definition at line 174 of file gnunet_core_underlay_dummy.c.

Referenced by connection_destroy(), mq_cancel_impl(), mq_send_impl(), and write_cb().

notify_connect_task

struct GNUNET_SCHEDULER_Task* Connection::notify_connect_task

Task to notify the client about an open connection.

Definition at line 179 of file gnunet_core_underlay_dummy.c.

Referenced by connection_destroy(), do_notify_connect(), and try_notify_connect().

handle_message_task

struct GNUNET_SCHEDULER_Task* Connection::handle_message_task

Task to pass the message to the client's handlers.

Definition at line 184 of file gnunet_core_underlay_dummy.c.

Referenced by check_for_messages(), connection_destroy(), and do_handle_message().

notify_connect_called

enum GNUNET_GenericReturnValue Connection::notify_connect_called

Whether notify_connect was called already It is used to check whether to call notify_disconnect or not.

Definition at line 190 of file gnunet_core_underlay_dummy.c.

Referenced by connection_destroy(), do_accept(), do_connect_to_peer(), do_notify_connect(), and do_read().

client_ready_to_receive

enum GNUNET_GenericReturnValue Connection::client_ready_to_receive

Indicating whether the client is ready to receive new messages.

This is set to GNUNET_YES after the client called #GNUNET_CORE_UNDERLAY_DUMMY_receive_continue() and to GNUNET_NO after GNUNET_MQ_handle_message() was called. TODO might be a duplicate to handle_message_task being NULL or not

Definition at line 199 of file gnunet_core_underlay_dummy.c.

Referenced by do_accept(), do_connect_to_peer(), do_handle_message(), do_notify_connect(), and do_read().

status

enum ConnectionStatus Connection::status

Status of the connection: Initializing, Live, Destroy.

Definition at line 204 of file gnunet_core_underlay_dummy.c.

Referenced by do_accept(), do_connect_to_peer(), do_read(), try_notify_connect(), and write_cb().

message_to_send

const struct GNUNET_MessageHeader* Connection::message_to_send

Message about to be sent, given by the message queue, waiting for the socket to be ready.

Definition at line 210 of file gnunet_core_underlay_dummy.c.

Referenced by mq_send_impl(), and write_cb().

queued_recv_messages_head

struct QueuedMessage* Connection::queued_recv_messages_head

Queued received messages in a DLL TODO implement cleanup TODO replace with a performant queue.

Definition at line 217 of file gnunet_core_underlay_dummy.c.

Referenced by check_for_messages(), do_handle_message(), and do_read().

queued_recv_messages_tail

struct QueuedMessage* Connection::queued_recv_messages_tail

Definition at line 218 of file gnunet_core_underlay_dummy.c.

Referenced by do_handle_message(), and do_read().

handle

struct GNUNET_CORE_UNDERLAY_DUMMY_Handle* Connection::handle

Handle to the service.

Definition at line 223 of file gnunet_core_underlay_dummy.c.

Referenced by connection_destroy(), do_accept(), do_connect_to_peer(), do_notify_connect(), do_read(), send_init(), try_notify_connect(), and write_cb().

notify_connect

GNUNET_CORE_UNDERLAY_DUMMY_NotifyConnect GNUNET_CORE_UNDERLAY_DUMMY_Handle::notify_connect

Callback (from/to client) to call when another peer connects.

Definition at line 235 of file gnunet_core_underlay_dummy.c.

Referenced by try_notify_connect().

notify_disconnect

GNUNET_CORE_UNDERLAY_DUMMY_NotifyDisconnect GNUNET_CORE_UNDERLAY_DUMMY_Handle::notify_disconnect

Callback (from/to client) to call when a peer disconnects.

Definition at line 240 of file gnunet_core_underlay_dummy.c.

Referenced by connection_destroy().

notify_address_change

GNUNET_CORE_UNDERLAY_DUMMY_NotifyAddressChange GNUNET_CORE_UNDERLAY_DUMMY_Handle::notify_address_change

Callback (from/to client) to call when our address changes.

Definition at line 245 of file gnunet_core_underlay_dummy.c.

handlers [2/2]

struct GNUNET_MQ_MessageHandler* GNUNET_CORE_UNDERLAY_DUMMY_Handle::handlers

Array of message handlers given by the client.

Don't use for handling of messages - this discards the per-mq-cls;

Definition at line 251 of file gnunet_core_underlay_dummy.c.

cls

void* GNUNET_CORE_UNDERLAY_DUMMY_Handle::cls

Closure for handlers given by the client - connection-independant (notify_connect, notify_disconnect, notify_address_change) TODO what's the doxygen way of linking to other members of this struct?

Definition at line 258 of file gnunet_core_underlay_dummy.c.

Referenced by connection_destroy(), discovered_socket_cb(), do_accept(), do_close_listening_socket(), do_discover_peers(), do_notify_address_change(), do_open_listening_socket(), and GNUNET_CORE_UNDERLAY_DUMMY_connect().

sock_name [2/2]

char* GNUNET_CORE_UNDERLAY_DUMMY_Handle::sock_name

Name of the listening socket.

Definition at line 263 of file gnunet_core_underlay_dummy.c.

Referenced by do_open_listening_socket(), and send_init().

sock_name_index_start

uint64_t GNUNET_CORE_UNDERLAY_DUMMY_Handle::sock_name_index_start

Definition at line 266 of file gnunet_core_underlay_dummy.c.

sock_name_index

uint64_t GNUNET_CORE_UNDERLAY_DUMMY_Handle::sock_name_index

Definition at line 268 of file gnunet_core_underlay_dummy.c.

sock_listen

struct GNUNET_NETWORK_Handle* GNUNET_CORE_UNDERLAY_DUMMY_Handle::sock_listen

Socket on which we listen for incoming connections.

Definition at line 273 of file gnunet_core_underlay_dummy.c.

listen_task

struct GNUNET_SCHEDULER_Task* GNUNET_CORE_UNDERLAY_DUMMY_Handle::listen_task

Task that waits for incoming connections.

Definition at line 278 of file gnunet_core_underlay_dummy.c.

notify_address_change_task

struct GNUNET_SCHEDULER_Task* GNUNET_CORE_UNDERLAY_DUMMY_Handle::notify_address_change_task

Task to notify core about address changes.

Definition at line 283 of file gnunet_core_underlay_dummy.c.

peer_discovery_task

struct GNUNET_SCHEDULER_Task* GNUNET_CORE_UNDERLAY_DUMMY_Handle::peer_discovery_task

Task to discover other peers.

Definition at line 288 of file gnunet_core_underlay_dummy.c.

address_change_task

struct GNUNET_SCHEDULER_Task* GNUNET_CORE_UNDERLAY_DUMMY_Handle::address_change_task

Definition at line 291 of file gnunet_core_underlay_dummy.c.

peer_connect_cls_head

struct PeerConnectCls* GNUNET_CORE_UNDERLAY_DUMMY_Handle::peer_connect_cls_head

Head of linked list with peer connect closures.

Definition at line 296 of file gnunet_core_underlay_dummy.c.

Referenced by do_connect_to_peer().

peer_connect_cls_tail

struct PeerConnectCls* GNUNET_CORE_UNDERLAY_DUMMY_Handle::peer_connect_cls_tail

Tail of linked list with peer connect closures.

Definition at line 301 of file gnunet_core_underlay_dummy.c.

Referenced by do_connect_to_peer().

connections_head

struct Connection* GNUNET_CORE_UNDERLAY_DUMMY_Handle::connections_head

Head of linked list with peer connect closures.

Definition at line 306 of file gnunet_core_underlay_dummy.c.

Referenced by connection_destroy(), and do_read().

connections_tail

struct Connection* GNUNET_CORE_UNDERLAY_DUMMY_Handle::connections_tail

Tail of linked list with peer connect closures.

Definition at line 311 of file gnunet_core_underlay_dummy.c.

Referenced by connection_destroy().