cadet api: client implementation of cadet service More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_cadet_service.h"
#include "cadet.h"
#include "cadet_protocol.h"

Include dependency graph for cadet_api.c:

Data Structures
struct	GNUNET_CADET_Handle
	Opaque handle to the service. More...

struct	GNUNET_CADET_Port
	Opaque handle to a port. More...

Macros
#define	LOG(kind, ...) GNUNET_log_from (kind, "cadet-api", __VA_ARGS__)

Functions
static struct GNUNET_CADET_Port *	find_port (const struct GNUNET_CADET_Handle h, const struct GNUNET_HashCode hash)
	Find the Port struct for a hash.

static struct GNUNET_CADET_Channel *	find_channel (struct GNUNET_CADET_Handle *h, struct GNUNET_CADET_ClientChannelNumber ccn)
	Get the channel handler for the channel specified by id from the given handle.

static struct GNUNET_CADET_Channel *	create_channel (struct GNUNET_CADET_Handle h, const struct GNUNET_CADET_ClientChannelNumber ccnp)
	Create a new channel and insert it in the channel list of the cadet handle.

static void	destroy_channel (struct GNUNET_CADET_Channel *ch)
	Destroy the specified channel.

static void	reconnect (struct GNUNET_CADET_Handle *h)
	Reconnect to the service, retransmit all information to try to restore the original state.

static int	open_port_cb (void cls, const struct GNUNET_HashCode id, void *value)
	Function called during reconnect_cbk() to (re)open all ports that are still open.

static void	reconnect_cbk (void *cls)
	Reconnect callback: tries to reconnect again after a failed previous connection.

static void	notify_window_size (struct GNUNET_CADET_Channel *ch)
	Notify the application about a change in the window size (if needed).

static void	cadet_mq_send_now (void *cls)
	Transmit the next message from our queue.

static void	cadet_mq_send_impl (struct GNUNET_MQ_Handle mq, const struct GNUNET_MessageHeader msg, void *impl_state)
	Implement sending functionality of a message queue for us sending messages to a peer.

static void	cadet_mq_destroy_impl (struct GNUNET_MQ_Handle mq, void impl_state)
	Handle destruction of a message queue.

static void	cadet_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	We had an error processing a message we forwarded from a peer to the CADET service.

static void	cadet_mq_cancel_impl (struct GNUNET_MQ_Handle mq, void impl_state)
	Implementation function that cancels the currently sent message.

static void	handle_channel_created (void cls, const struct GNUNET_CADET_LocalChannelCreateMessage msg)
	Process the new channel notification and add it to the channels in the handle.

static void	handle_channel_destroy (void cls, const struct GNUNET_CADET_LocalChannelDestroyMessage msg)
	Process the channel destroy notification and free associated resources.

static int	check_local_data (void cls, const struct GNUNET_CADET_LocalData message)
	Check that message received from CADET service is well-formed.

static void	handle_local_data (void cls, const struct GNUNET_CADET_LocalData message)
	Process the incoming data packets, call appropriate handlers.

static void	handle_local_ack (void cls, const struct GNUNET_CADET_LocalAck message)
	Process a local ACK message, enabling the client to send more data to the service.

static int	destroy_channel_cb (void cls, uint32_t cid, void value)
	Function called during GNUNET_CADET_disconnect() to destroy all channels that are still open.

static void	handle_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.

static int	destroy_port_cb (void cls, const struct GNUNET_HashCode id, void *value)
	Function called during GNUNET_CADET_disconnect() to destroy all ports that are still open.

void	GNUNET_CADET_disconnect (struct GNUNET_CADET_Handle *handle)
	Disconnect from the cadet service.

void	GNUNET_CADET_close_port (struct GNUNET_CADET_Port *p)
	Close a port opened with GNUNET_CADET_open_port.

void	GNUNET_CADET_channel_destroy (struct GNUNET_CADET_Channel *channel)
	Destroy an existing channel.

const union GNUNET_CADET_ChannelInfo *	GNUNET_CADET_channel_get_info (struct GNUNET_CADET_Channel *channel, enum GNUNET_CADET_ChannelInfoOption option,...)
	Get information about a channel.

void	GNUNET_CADET_receive_done (struct GNUNET_CADET_Channel *channel)
	Send an ack on the channel to confirm the processing of a message.

struct GNUNET_CADET_Handle *	GNUNET_CADET_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Connect to the MQ-based cadet service.

static void	return_agpl (void cls, const struct GNUNET_MessageHeader msg)
	Function to return link to AGPL source upon request.

struct GNUNET_CADET_Port *	GNUNET_CADET_open_port (struct GNUNET_CADET_Handle h, const struct GNUNET_HashCode port, GNUNET_CADET_ConnectEventHandler connects, void connects_cls, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler handlers)
	Open a port to receive incoming MQ-based channels.

struct GNUNET_CADET_Channel *	GNUNET_CADET_channel_create (struct GNUNET_CADET_Handle h, void channel_cls, const struct GNUNET_PeerIdentity destination, const struct GNUNET_HashCode port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
	Create a new channel towards a remote peer.

struct GNUNET_MQ_Handle *	GNUNET_CADET_get_mq (const struct GNUNET_CADET_Channel *channel)
	Obtain the message queue for a connected peer.

Detailed Description

cadet api: client implementation of cadet service

Author: Bartlomiej Polot; Christian Grothoff

Definition in file cadet_api.c.

Macro Definition Documentation

◆ LOG

#define LOG	(	kind,
		...
	)	GNUNET_log_from (kind, "cadet-api", __VA_ARGS__)

Definition at line 33 of file cadet_api.c.

Function Documentation

◆ find_port()

static struct GNUNET_CADET_Port * find_port	(	const struct GNUNET_CADET_Handle *	h,
		const struct GNUNET_HashCode *	hash
	)

static

Find the Port struct for a hash.

Parameters

h	CADET handle.
hash	HashCode for the port number.

Returns: The port handle if known, NULL otherwise.

Definition at line 131 of file cadet_api.c.

{
  return GNUNET_CONTAINER_multihashmap_get (h->ports, hash);
}

References GNUNET_CONTAINER_multihashmap_get(), and h.

Referenced by handle_channel_created().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_channel()

static struct GNUNET_CADET_Channel * find_channel	(	struct GNUNET_CADET_Handle *	h,
		struct GNUNET_CADET_ClientChannelNumber	ccn
	)

static

Get the channel handler for the channel specified by id from the given handle.

Parameters

h	Cadet handle
ccn	ID of the wanted channel

Returns: handle to the required channel or NULL if not found

Definition at line 146 of file cadet_api.c.

{
  return GNUNET_CONTAINER_multihashmap32_get (h->channels,
                                              ntohl (ccn.channel_of_client));
}

References GNUNET_CADET_Channel::ccn, GNUNET_CADET_ClientChannelNumber::channel_of_client, GNUNET_CONTAINER_multihashmap32_get(), and h.

Referenced by create_channel(), handle_channel_destroy(), handle_local_ack(), and handle_local_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_channel()

static struct GNUNET_CADET_Channel * create_channel	(	struct GNUNET_CADET_Handle *	h,
		const struct GNUNET_CADET_ClientChannelNumber *	ccnp
	)

static

Create a new channel and insert it in the channel list of the cadet handle.

Parameters

h	Cadet handle
ccnp	pointer to desired ccn of the channel, NULL to assign one automatically.

Returns: Handle to the created channel.

Definition at line 162 of file cadet_api.c.

{
  struct GNUNET_CADET_Channel *ch;
  struct GNUNET_CADET_ClientChannelNumber ccn;
 
  ch = GNUNET_new (struct GNUNET_CADET_Channel);
  ch->cadet = h;
  if (NULL == ccnp)
  {
    while (NULL != find_channel (h, h->next_ccn))
      h->next_ccn.channel_of_client =
        htonl (GNUNET_CADET_LOCAL_CHANNEL_ID_CLI
               | (1 + ntohl (h->next_ccn.channel_of_client)));
    ccn = h->next_ccn;
  }
  else
  {
    ccn = *ccnp;
  }
  ch->ccn = ccn;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap32_put (
                   h->channels,
                   ntohl (ch->ccn.channel_of_client),
                   ch,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  return ch;
}

References GNUNET_CADET_Channel::cadet, GNUNET_CADET_Channel::ccn, ch, GNUNET_CADET_ClientChannelNumber::channel_of_client, find_channel(), GNUNET_assert, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI, GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_new, GNUNET_OK, and h.

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_channel()

static void destroy_channel ( struct GNUNET_CADET_Channel * ch )

static

Destroy the specified channel.

Destroys all peers, calling the disconnect callback on each if needed
Cancels all outgoing traffic for that channel, calling respective notifys
Calls cleaner if channel was inbound
Frees all memory used

Parameters

ch	Pointer to the channel.

Definition at line 203 of file cadet_api.c.

{
  struct GNUNET_CADET_Handle *h = ch->cadet;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Destroying channel %X of %p\n",
       htonl (ch->ccn.channel_of_client),
       h);
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multihashmap32_remove (h->channels,
                                            ntohl (ch->ccn.channel_of_client),
                                            ch));
  if (NULL != ch->mq_cont)
  {
    GNUNET_SCHEDULER_cancel (ch->mq_cont);
    ch->mq_cont = NULL;
  }
  /* signal channel destruction */
  if (NULL != ch->disconnects)
    ch->disconnects (ch->ctx, ch);
  if (NULL != ch->pending_env)
    GNUNET_MQ_discard (ch->pending_env);
  GNUNET_MQ_destroy (ch->mq);
  GNUNET_free (ch);
}

References GNUNET_CADET_Channel::cadet, GNUNET_CADET_Channel::ccn, ch, GNUNET_CADET_ClientChannelNumber::channel_of_client, GNUNET_CADET_Channel::ctx, GNUNET_CADET_Channel::disconnects, GNUNET_assert, GNUNET_CONTAINER_multihashmap32_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_MQ_discard(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, h, LOG, GNUNET_CADET_Channel::mq, GNUNET_CADET_Channel::mq_cont, and GNUNET_CADET_Channel::pending_env.

Referenced by destroy_channel_cb(), GNUNET_CADET_channel_destroy(), and handle_channel_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reconnect()

static void reconnect ( struct GNUNET_CADET_Handle * h )

static

Reconnect to the service, retransmit all information to try to restore the original state.

Parameters

h	handle to the cadet

Definition at line 717 of file cadet_api.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_fixed_size (channel_created,
                             GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE,
                             struct GNUNET_CADET_LocalChannelCreateMessage,
                             h),
    GNUNET_MQ_hd_fixed_size (channel_destroy,
                             GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY,
                             struct GNUNET_CADET_LocalChannelDestroyMessage,
                             h),
    GNUNET_MQ_hd_var_size (local_data,
                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
                           struct GNUNET_CADET_LocalData,
                           h),
    GNUNET_MQ_hd_fixed_size (local_ack,
                             GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK,
                             struct GNUNET_CADET_LocalAck,
                             h),
    GNUNET_MQ_handler_end () };
 
  GNUNET_assert (NULL == h->mq);
  h->mq =
    GNUNET_CLIENT_connect (h->cfg, "cadet", handlers, &handle_mq_error, h);
}

References GNUNET_ARM_Handle::cfg, channel_destroy(), GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, h, handle_mq_error(), handlers, and GNUNET_ARM_Handle::mq.

Here is the call graph for this function:

◆ open_port_cb()

static int open_port_cb	(	void *	cls,
		const struct GNUNET_HashCode *	id,
		void *	value
	)

static

Function called during reconnect_cbk() to (re)open all ports that are still open.

Parameters

cls	the `struct GNUNET_CADET_Handle`
id	port ID
value	a `struct GNUNET_CADET_Channel` to open

Returns: GNUNET_OK (continue to iterate)

Definition at line 251 of file cadet_api.c.

{
  struct GNUNET_CADET_Handle *h = cls;
  struct GNUNET_CADET_Port *port = value;
  struct GNUNET_CADET_PortMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  (void) id;
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN);
  msg->port = port->id;
  GNUNET_MQ_send (h->mq, env);
  return GNUNET_OK;
}

References env, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_OK, h, GNUNET_ARM_Handle::mq, msg, port, and value.

Referenced by GNUNET_CADET_open_port(), and reconnect_cbk().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ reconnect_cbk()

static void reconnect_cbk ( void * cls )

static

Reconnect callback: tries to reconnect again after a failed previous connection.

Parameters

cls	closure (cadet handle)

Definition at line 273 of file cadet_api.c.

{
  struct GNUNET_CADET_Handle *h = cls;
 
  h->reconnect_task = NULL;
  h->reconnect_time = GNUNET_TIME_STD_BACKOFF (h->reconnect_time);
  reconnect (h);
  GNUNET_CONTAINER_multihashmap_iterate (h->ports, &open_port_cb, h);
}

References GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_TIME_STD_BACKOFF, h, open_port_cb(), reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by handle_mq_error().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_window_size()

static void notify_window_size ( struct GNUNET_CADET_Channel * ch )

static

Notify the application about a change in the window size (if needed).

Parameters

ch	Channel to notify about.

Definition at line 290 of file cadet_api.c.

{
  if (NULL != ch->window_changes)
    ch->window_changes (ch->ctx,
                        ch, /* FIXME: remove 'ch'? */
                        ch->allow_send);
}

References GNUNET_CADET_Channel::allow_send, ch, GNUNET_CADET_Channel::ctx, and GNUNET_CADET_Channel::window_changes.

Referenced by handle_local_ack().

Here is the caller graph for this function:

◆ cadet_mq_send_now()

static void cadet_mq_send_now ( void * cls )

static

Transmit the next message from our queue.

Parameters

cls	Closure (channel whose mq to activate).

Definition at line 305 of file cadet_api.c.

{
  struct GNUNET_CADET_Channel *ch = cls;
  struct GNUNET_MQ_Envelope *env = ch->pending_env;
 
  ch->mq_cont = NULL;
  if (0 == ch->allow_send)
  {
    /* how did we get here? */
    GNUNET_break (0);
    return;
  }
  if (NULL == env)
  {
    /* how did we get here? */
    GNUNET_break (0);
    return;
  }
  ch->allow_send--;
  ch->pending_env = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending message on channel %s to CADET, new window size is %u\n",
              GNUNET_i2s (&ch->peer),
              ch->allow_send);
  GNUNET_MQ_send (ch->cadet->mq, env);
  GNUNET_MQ_impl_send_continue (ch->mq);
}

References GNUNET_CADET_Channel::allow_send, GNUNET_CADET_Channel::cadet, ch, env, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MQ_impl_send_continue(), GNUNET_MQ_send(), GNUNET_CADET_Channel::mq, GNUNET_CADET_Handle::mq, GNUNET_CADET_Channel::mq_cont, GNUNET_CADET_Channel::peer, and GNUNET_CADET_Channel::pending_env.

Referenced by cadet_mq_send_impl(), and handle_local_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cadet_mq_send_impl()

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

static

Implement sending functionality of a message queue for us sending messages to a peer.

Encapsulates the payload message in a GNUNET_CADET_LocalData message in order to label the message with the channel ID and send the encapsulated message to the service.

Parameters

mq	the message queue
msg	the message to send
impl_state	state of the implementation

Definition at line 347 of file cadet_api.c.

{
  struct GNUNET_CADET_Channel *ch = impl_state;
  struct GNUNET_CADET_Handle *h = ch->cadet;
  uint16_t msize;
  struct GNUNET_MQ_Envelope *orig_env;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_CADET_LocalData *cadet_msg;
  enum GNUNET_MQ_PriorityPreferences pp;
 
  if (NULL == h->mq)
  {
    /* We're currently reconnecting, pretend this worked */
    GNUNET_MQ_impl_send_continue (mq);
    return;
  }
  orig_env = GNUNET_MQ_get_current_envelope (mq);
  pp = GNUNET_MQ_env_get_options (orig_env);
 
  /* check message size for sanity */
  msize = ntohs (msg->size);
  if (msize > GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    GNUNET_MQ_impl_send_continue (mq);
    return;
  }
  env = GNUNET_MQ_msg_nested_mh (cadet_msg,
                                 GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
                                 msg);
  cadet_msg->ccn = ch->ccn;
  cadet_msg->pp = htonl ((uint32_t) pp);
  GNUNET_assert (NULL == ch->pending_env);
  ch->pending_env = env;
  if (0 < ch->allow_send)
    ch->mq_cont = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now, ch);
}

References GNUNET_CADET_Channel::allow_send, GNUNET_CADET_Channel::cadet, cadet_mq_send_now(), GNUNET_CADET_Channel::ccn, GNUNET_CADET_LocalData::ccn, ch, env, GNUNET_assert, GNUNET_break, GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE, GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA, GNUNET_MQ_env_get_options(), GNUNET_MQ_get_current_envelope(), GNUNET_MQ_impl_send_continue(), GNUNET_MQ_msg_nested_mh, GNUNET_SCHEDULER_add_now(), h, mq, GNUNET_ARM_Handle::mq, GNUNET_CADET_Channel::mq_cont, msg, GNUNET_CADET_Channel::pending_env, GNUNET_CADET_LocalData::pp, and GNUNET_MessageHeader::size.

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cadet_mq_destroy_impl()

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

static

Handle destruction of a message queue.

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

Parameters

mq	the message queue to destroy
impl_state	state of the implementation

Definition at line 396 of file cadet_api.c.

{
  struct GNUNET_CADET_Channel *ch = impl_state;
 
  GNUNET_assert (mq == ch->mq);
  ch->mq = NULL;
}

References ch, GNUNET_assert, mq, and GNUNET_CADET_Channel::mq.

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

Here is the caller graph for this function:

◆ cadet_mq_error_handler()

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

static

We had an error processing a message we forwarded from a peer to the CADET service.

We should just complain about it but otherwise continue processing.

Parameters

cls	closure with our `struct GNUNET_CADET_Channel`
error	error code

Definition at line 414 of file cadet_api.c.

{
  struct GNUNET_CADET_Channel *ch = cls;
 
  if (GNUNET_MQ_ERROR_NO_MATCH == error)
  {
    /* Got a message we did not understand, still try to continue! */
    GNUNET_break_op (0);
    GNUNET_CADET_receive_done (ch);
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "MQ error in communication with CADET: %d\n",
                error);
    if (NULL != ch->disconnects)
      ch->disconnects (ch->ctx, ch);
    GNUNET_CADET_channel_destroy (ch);
  }
}

References ch, GNUNET_CADET_Channel::ctx, GNUNET_CADET_Channel::disconnects, GNUNET_break_op, GNUNET_CADET_channel_destroy(), GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, and GNUNET_MQ_ERROR_NO_MATCH.

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cadet_mq_cancel_impl()

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

static

Implementation function that cancels the currently sent message.

Should basically undo whatever mq_send_impl() did.

Parameters

mq	message queue
impl_state	state specific to the implementation

Definition at line 444 of file cadet_api.c.

{
  struct GNUNET_CADET_Channel *ch = impl_state;
 
  (void) mq;
  GNUNET_assert (NULL != ch->pending_env);
  GNUNET_MQ_discard (ch->pending_env);
  ch->pending_env = NULL;
  if (NULL != ch->mq_cont)
  {
    GNUNET_SCHEDULER_cancel (ch->mq_cont);
    ch->mq_cont = NULL;
  }
}

References ch, GNUNET_assert, GNUNET_MQ_discard(), GNUNET_SCHEDULER_cancel(), mq, GNUNET_CADET_Channel::mq_cont, and GNUNET_CADET_Channel::pending_env.

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_channel_created()

static void handle_channel_created	(	void *	cls,
		const struct GNUNET_CADET_LocalChannelCreateMessage *	msg
	)

static

Process the new channel notification and add it to the channels in the handle.

Parameters

cls	The cadet handle
msg	A message with the details of the new incoming channel

Definition at line 467 of file cadet_api.c.

{
  struct GNUNET_CADET_Handle *h = cls;
  struct GNUNET_CADET_Channel *ch;
  struct GNUNET_CADET_Port *port;
  const struct GNUNET_HashCode *port_number;
  struct GNUNET_CADET_ClientChannelNumber ccn;
 
  ccn = msg->ccn;
  port_number = &msg->port;
  if (ntohl (ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
  {
    GNUNET_break (0);
    return;
  }
  port = find_port (h, port_number);
  if (NULL == port)
  {
    /* We could have closed the port but the service didn't know about it yet
     * This is not an error.
     */
    struct GNUNET_CADET_LocalChannelDestroyMessage *d_msg;
    struct GNUNET_MQ_Envelope *env;
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "No handler for incoming channel %X (on port %s, recently closed?)\n",
         ntohl (ccn.channel_of_client),
         GNUNET_h2s (port_number));
    env =
      GNUNET_MQ_msg (d_msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
    d_msg->ccn = msg->ccn;
    GNUNET_MQ_send (h->mq, env);
    return;
  }
 
  ch = create_channel (h, &ccn);
  ch->peer = msg->peer;
  ch->incoming_port = port;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Creating incoming channel %X [%s] %p\n",
       ntohl (ccn.channel_of_client),
       GNUNET_h2s (port_number),
       ch);
 
  GNUNET_assert (NULL != port->connects);
  ch->window_changes = port->window_changes;
  ch->disconnects = port->disconnects;
  ch->mq = GNUNET_MQ_queue_for_callbacks (&cadet_mq_send_impl,
                                          &cadet_mq_destroy_impl,
                                          &cadet_mq_cancel_impl,
                                          ch,
                                          port->handlers,
                                          &cadet_mq_error_handler,
                                          ch);
  ch->ctx = port->connects (port->cls, ch, &msg->peer);
  GNUNET_MQ_set_handlers_closure (ch->mq, ch->ctx);
}

References cadet_mq_cancel_impl(), cadet_mq_destroy_impl(), cadet_mq_error_handler(), cadet_mq_send_impl(), GNUNET_CADET_LocalChannelDestroyMessage::ccn, ch, GNUNET_CADET_ClientChannelNumber::channel_of_client, create_channel(), GNUNET_CADET_Channel::ctx, GNUNET_CADET_Channel::disconnects, env, find_port(), GNUNET_assert, GNUNET_break, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, GNUNET_MQ_msg, GNUNET_MQ_queue_for_callbacks(), GNUNET_MQ_send(), GNUNET_MQ_set_handlers_closure(), h, GNUNET_CADET_Channel::incoming_port, LOG, GNUNET_ARM_Handle::mq, GNUNET_CADET_Channel::mq, msg, GNUNET_CADET_Channel::peer, port, and GNUNET_CADET_Channel::window_changes.

Here is the call graph for this function:

◆ handle_channel_destroy()

static void handle_channel_destroy	(	void *	cls,
		const struct GNUNET_CADET_LocalChannelDestroyMessage *	msg
	)

static

Process the channel destroy notification and free associated resources.

Parameters

cls	The cadet handle
msg	A message with the details of the channel being destroyed

Definition at line 535 of file cadet_api.c.

{
  struct GNUNET_CADET_Handle *h = cls;
  struct GNUNET_CADET_Channel *ch;
 
  ch = find_channel (h, msg->ccn);
  if (NULL == ch)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received channel destroy for unknown channel %X from CADET service (recently close?)\n",
         ntohl (msg->ccn.channel_of_client));
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received channel destroy for channel %X from CADET service\n",
       ntohl (msg->ccn.channel_of_client));
  destroy_channel (ch);
}

References ch, destroy_channel(), find_channel(), GNUNET_ERROR_TYPE_DEBUG, h, LOG, and msg.

Here is the call graph for this function:

◆ check_local_data()

static int check_local_data	(	void *	cls,
		const struct GNUNET_CADET_LocalData *	message
	)

static

Check that message received from CADET service is well-formed.

Parameters

cls	the `struct GNUNET_CADET_Handle`
message	the message we got

Returns: GNUNET_OK if the message is well-formed, GNUNET_SYSERR otherwise

Definition at line 566 of file cadet_api.c.

{
  uint16_t size;
 
  (void) cls;
  size = ntohs (message->header.size);
  if (sizeof(*message) + sizeof(struct GNUNET_MessageHeader) > size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, GNUNET_CADET_LocalData::header, GNUNET_MessageHeader::size, and size.

◆ handle_local_data()

static void handle_local_data	(	void *	cls,
		const struct GNUNET_CADET_LocalData *	message
	)

static

Process the incoming data packets, call appropriate handlers.

Parameters

cls	The cadet handle
message	A message encapsulating the data

Definition at line 589 of file cadet_api.c.

{
  struct GNUNET_CADET_Handle *h = cls;
  const struct GNUNET_MessageHeader *payload;
  struct GNUNET_CADET_Channel *ch;
  uint16_t type;
  int fwd;
 
  ch = find_channel (h, message->ccn);
  if (NULL == ch)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Unknown channel %X for incoming data (recently closed?)\n",
         ntohl (message->ccn.channel_of_client));
    return;
  }
 
  payload = (const struct GNUNET_MessageHeader *) &message[1];
  type = ntohs (payload->type);
  fwd = ntohl (ch->ccn.channel_of_client) <= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got a %s data on channel %s [%X] of type %u\n",
       fwd ? "FWD" : "BWD",
       GNUNET_i2s (&ch->peer),
       ntohl (message->ccn.channel_of_client),
       type);
  GNUNET_MQ_inject_message (ch->mq, payload);
}

References GNUNET_CADET_Channel::ccn, GNUNET_CADET_LocalData::ccn, ch, GNUNET_CADET_ClientChannelNumber::channel_of_client, find_channel(), GNUNET_CADET_LOCAL_CHANNEL_ID_CLI, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MQ_inject_message(), h, LOG, GNUNET_CADET_Channel::mq, payload, GNUNET_CADET_Channel::peer, and type.

Here is the call graph for this function:

◆ handle_local_ack()

static void handle_local_ack	(	void *	cls,
		const struct GNUNET_CADET_LocalAck *	message
	)

static

Process a local ACK message, enabling the client to send more data to the service.

Parameters

cls	Cadet handle.
message	Message itself.

Definition at line 628 of file cadet_api.c.

{
  struct GNUNET_CADET_Handle *h = cls;
  struct GNUNET_CADET_Channel *ch;
 
  ch = find_channel (h, message->ccn);
  if (NULL == ch)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "ACK on unknown channel %X\n",
         ntohl (message->ccn.channel_of_client));
    return;
  }
  ch->allow_send++;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got an ACK on mq channel %X (peer %s); new window size is %u!\n",
       ntohl (ch->ccn.channel_of_client),
       GNUNET_i2s (&ch->peer),
       ch->allow_send);
  if (NULL == ch->pending_env)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Got an ACK on mq channel %X, allow send now %u!\n",
         ntohl (ch->ccn.channel_of_client),
         ch->allow_send);
    notify_window_size (ch);
    return;
  }
  if (NULL != ch->mq_cont)
    return; /* already working on it! */
  ch->mq_cont = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now, ch);
}

References GNUNET_CADET_Channel::allow_send, cadet_mq_send_now(), GNUNET_CADET_Channel::ccn, GNUNET_CADET_LocalAck::ccn, ch, GNUNET_CADET_ClientChannelNumber::channel_of_client, find_channel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_SCHEDULER_add_now(), h, LOG, GNUNET_CADET_Channel::mq_cont, notify_window_size(), GNUNET_CADET_Channel::peer, and GNUNET_CADET_Channel::pending_env.

Here is the call graph for this function:

◆ destroy_channel_cb()

static int destroy_channel_cb	(	void *	cls,
		uint32_t	cid,
		void *	value
	)

static

Function called during GNUNET_CADET_disconnect() to destroy all channels that are still open.

Parameters

cls	the `struct GNUNET_CADET_Handle`
cid	chanenl ID
value	a `struct GNUNET_CADET_Channel` to destroy

Returns: GNUNET_OK (continue to iterate)

Definition at line 673 of file cadet_api.c.

{
  /* struct GNUNET_CADET_Handle *handle = cls; */
  struct GNUNET_CADET_Channel *ch = value;
 
  (void) cls;
  (void) cid;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Destroying channel due to GNUNET_CADET_disconnect()\n");
  destroy_channel (ch);
  return GNUNET_OK;
}

References ch, destroy_channel(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_OK, and value.

Referenced by GNUNET_CADET_disconnect(), and handle_mq_error().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_mq_error()

static void handle_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

cls	closure, a `struct GNUNET_CORE_Handle *`
error	error code

Definition at line 696 of file cadet_api.c.

{
  struct GNUNET_CADET_Handle *h = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error);
  GNUNET_CONTAINER_multihashmap32_iterate (h->channels, &destroy_channel_cb, h);
  GNUNET_MQ_destroy (h->mq);
  h->mq = NULL;
  GNUNET_assert (NULL == h->reconnect_task);
  h->reconnect_task =
    GNUNET_SCHEDULER_add_delayed (h->reconnect_time, &reconnect_cbk, h);
}

References destroy_channel_cb(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), h, GNUNET_ARM_Handle::mq, reconnect_cbk(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_port_cb()

static int destroy_port_cb	(	void *	cls,
		const struct GNUNET_HashCode *	id,
		void *	value
	)

static

Function called during GNUNET_CADET_disconnect() to destroy all ports that are still open.

Parameters

cls	the `struct GNUNET_CADET_Handle`
id	port ID
value	a `struct GNUNET_CADET_Channel` to destroy

Returns: GNUNET_OK (continue to iterate)

Definition at line 754 of file cadet_api.c.

{
  /* struct GNUNET_CADET_Handle *handle = cls; */
  struct GNUNET_CADET_Port *port = value;
 
  (void) cls;
  (void) id;
  /* This is a warning, the app should have cleanly closed all open ports */
  GNUNET_break (0);
  GNUNET_CADET_close_port (port);
  return GNUNET_OK;
}

References GNUNET_CADET_Port::cls, GNUNET_break, GNUNET_CADET_close_port(), GNUNET_OK, port, and value.

Referenced by GNUNET_CADET_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ return_agpl()

static void return_agpl	(	void *	cls,
		const struct GNUNET_MessageHeader *	msg
	)

static

Function to return link to AGPL source upon request.

Parameters

cls	closure with the identification of the client
msg	AGPL request

Definition at line 925 of file cadet_api.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_MQ_Handle *mq;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *res;
  size_t slen;
  /* FIXME: this is a bug, uses always GNUnet PD while we would
     actually WANT to use the PD of the CADET application here! */
  const struct GNUNET_OS_ProjectData *pd =
    GNUNET_OS_project_data_gnunet ();
 
  (void) msg;
  slen = strlen (pd->agpl_url) + 1;
  env = GNUNET_MQ_msg_extra (res,
                             GNUNET_MESSAGE_TYPE_RESPONSE_AGPL,
                             slen);
  memcpy (&res[1],
          pd->agpl_url,
          slen);
  mq = GNUNET_SERVICE_client_get_mq (client);
  GNUNET_MQ_send (mq,
                  env);
  GNUNET_SERVICE_client_continue (client);
}

References GNUNET_OS_ProjectData::agpl_url, env, GNUNET_MESSAGE_TYPE_RESPONSE_AGPL, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_OS_project_data_gnunet(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), mq, msg, and res.

Referenced by GNUNET_CADET_open_port().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG

Function Documentation

◆ find_port()

◆ find_channel()

◆ create_channel()

◆ destroy_channel()

◆ reconnect()

◆ open_port_cb()

◆ reconnect_cbk()

◆ notify_window_size()

◆ cadet_mq_send_now()

◆ cadet_mq_send_impl()

◆ cadet_mq_destroy_impl()

◆ cadet_mq_error_handler()

◆ cadet_mq_cancel_impl()

◆ handle_channel_created()

◆ handle_channel_destroy()

◆ check_local_data()

◆ handle_local_data()

◆ handle_local_ack()

◆ destroy_channel_cb()

◆ handle_mq_error()

◆ destroy_port_cb()

◆ return_agpl()