CADET service

Confidential Ad-hoc Decentralized End-to-End Transport. More...

Collaboration diagram for CADET service:

Data Structures
struct	GNUNET_CADET_ConnectionTunnelIdentifier
	Hash uniquely identifying a connection below a tunnel. More...
struct	GNUNET_CADET_ChannelTunnelNumber
	Number identifying a CADET channel within a tunnel. More...
union	GNUNET_CADET_ChannelInfo
	Union to retrieve info about a channel. More...
struct	GNUNET_CADET_ChannelInternals
	Internal details about a channel. More...
struct	GNUNET_CADET_PeerListEntry
	Information we return per peer. More...
struct	GNUNET_CADET_PeerPathDetail
	Detailed information we return per peer. More...
struct	GNUNET_CADET_TunnelDetails
	Details about a tunnel managed by CADET. More...

Macros
#define	GNUNET_CADET_VERSION   0x00000005
	Version number of GNUnet-cadet API. More...

Typedefs
typedef void *(*	GNUNET_CADET_ConnectEventHandler) (void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *source)
	Method called whenever a peer connects to a port in MQ-based CADET. More...
typedef void(*	GNUNET_CADET_DisconnectEventHandler) (void *cls, const struct GNUNET_CADET_Channel *channel)
	Function called whenever an MQ-channel is destroyed, unless the destruction was requested by GNUNET_CADET_channel_destroy. More...
typedef void(*	GNUNET_CADET_WindowSizeEventHandler) (void *cls, const struct GNUNET_CADET_Channel *channel, int window_size)
	Function called whenever an MQ-channel's transmission window size changes. More...
typedef void(*	GNUNET_CADET_ChannelCB) (void *cls, const struct GNUNET_CADET_ChannelInternals *info)
	Method called to retrieve information about a specific channel the cadet peer is aware of, including all transit nodes. More...
typedef void(*	GNUNET_CADET_PeersCB) (void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
	Method called to retrieve information about all peers in CADET, called once per peer. More...
typedef void(*	GNUNET_CADET_PathCB) (void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
	Method called to retrieve information about a specific path known to the service. More...
typedef void(*	GNUNET_CADET_TunnelsCB) (void *cls, const struct GNUNET_CADET_TunnelDetails *td)
	Method called to retrieve information about all tunnels in CADET, called once per tunnel. More...

Enumerations
enum	GNUNET_CADET_ChannelInfoOption { GNUNET_CADET_OPTION_PEER = 0x0 }

Functions
struct GNUNET_CADET_Handle *	GNUNET_CADET_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Connect to the MQ-based cadet service. More...
void	GNUNET_CADET_disconnect (struct GNUNET_CADET_Handle *handle)
	Disconnect from the cadet service. More...
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. More...
void	GNUNET_CADET_close_port (struct GNUNET_CADET_Port *p)
	Close a port opened with GNUNET_CADET_open_port. More...
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. More...
void	GNUNET_CADET_channel_destroy (struct GNUNET_CADET_Channel *channel)
	Destroy an existing channel. More...
struct GNUNET_MQ_Handle *	GNUNET_CADET_get_mq (const struct GNUNET_CADET_Channel *channel)
	Obtain the message queue for a connected channel. More...
void	GNUNET_CADET_receive_done (struct GNUNET_CADET_Channel *channel)
	Indicate readiness to receive the next message on a channel. More...
const struct GNUNET_HashCode *	GC_u2h (uint32_t port)
	Transitional function to convert an unsigned int port to a hash value. More...
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. More...
struct GNUNET_CADET_ChannelMonitor *	GNUNET_CADET_get_channel (const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_PeerIdentity *peer, GNUNET_CADET_ChannelCB callback, void *callback_cls)
	Request information about channels to peer from the local peer. More...
void *	GNUNET_CADET_get_channel_cancel (struct GNUNET_CADET_ChannelMonitor *cm)
	Cancel a channel monitor request. More...
struct GNUNET_CADET_PeersLister *	GNUNET_CADET_list_peers (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CADET_PeersCB callback, void *callback_cls)
	Request information about peers known to the running cadet service. More...
void *	GNUNET_CADET_list_peers_cancel (struct GNUNET_CADET_PeersLister *pl)
	Cancel a peer info request. More...
struct GNUNET_CADET_GetPath *	GNUNET_CADET_get_path (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *id, GNUNET_CADET_PathCB callback, void *callback_cls)
	Request information about a peer known to the running cadet peer. More...
void *	GNUNET_CADET_get_path_cancel (struct GNUNET_CADET_GetPath *gp)
	Cancel gp operation. More...
struct GNUNET_CADET_ListTunnels *	GNUNET_CADET_list_tunnels (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CADET_TunnelsCB callback, void *callback_cls)
	Request information about tunnels of the running cadet peer. More...
void *	GNUNET_CADET_list_tunnels_cancel (struct GNUNET_CADET_ListTunnels *lt)
	Cancel a monitor request. More...

Detailed Description

Confidential Ad-hoc Decentralized End-to-End Transport.

See also

Documentation

Paper

Macro Definition Documentation

GNUNET_CADET_VERSION

#define GNUNET_CADET_VERSION   0x00000005

Version number of GNUnet-cadet API.

Definition at line 54 of file gnunet_cadet_service.h.

Typedef Documentation

GNUNET_CADET_ConnectEventHandler

typedef void *(* GNUNET_CADET_ConnectEventHandler) (void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *source)

Method called whenever a peer connects to a port in MQ-based CADET.

Parameters

cls	Closure from GNUNET_CADET_open_port.
channel	New handle to the channel.
source	Peer that started this channel.

Returns

Closure for the incoming channel. It's given to:

• The GNUNET_CADET_DisconnectEventHandler (given to GNUNET_CADET_open_port) when the channel dies.
• Each the GNUNET_MQ_MessageCallback handlers for each message received on the channel.

Definition at line 111 of file gnunet_cadet_service.h.

GNUNET_CADET_DisconnectEventHandler

typedef void(* GNUNET_CADET_DisconnectEventHandler) (void *cls, const struct GNUNET_CADET_Channel *channel)

Function called whenever an MQ-channel is destroyed, unless the destruction was requested by GNUNET_CADET_channel_destroy.

It must NOT call GNUNET_CADET_channel_destroy on the channel.

It should clean up any associated state, including cancelling any pending transmission on this channel.

Parameters

cls	Channel closure.
channel	Connection to the other end (henceforth invalid).

Definition at line 128 of file gnunet_cadet_service.h.

GNUNET_CADET_WindowSizeEventHandler

typedef void(* GNUNET_CADET_WindowSizeEventHandler) (void *cls, const struct GNUNET_CADET_Channel *channel, int window_size)

Function called whenever an MQ-channel's transmission window size changes.

The first callback in an outgoing channel will be with a non-zero value and will mean the channel is connected to the destination.

For an incoming channel it will be called immediately after the GNUNET_CADET_ConnectEventHandler, also with a non-zero value.

Parameters

cls	Channel closure.
channel	Connection to the other end — FIXME: drop?
window_size	New window size. If the is more messages than buffer size this value will be negative. – FIXME: make unsigned, we never call negative?

Definition at line 147 of file gnunet_cadet_service.h.

GNUNET_CADET_ChannelCB

typedef void(* GNUNET_CADET_ChannelCB) (void *cls, const struct GNUNET_CADET_ChannelInternals *info)

Method called to retrieve information about a specific channel the cadet peer is aware of, including all transit nodes.

Parameters

cls	Closure.
info	internal details, NULL for end of list

Definition at line 362 of file gnunet_cadet_service.h.

GNUNET_CADET_PeersCB

typedef void(* GNUNET_CADET_PeersCB) (void *cls, const struct GNUNET_CADET_PeerListEntry *ple)

Method called to retrieve information about all peers in CADET, called once per peer.

After last peer has been reported, an additional call with NULL is done.

Parameters

cls	Closure.
ple	information about a peer, or NULL on "EOF".

Definition at line 434 of file gnunet_cadet_service.h.

GNUNET_CADET_PathCB

typedef void(* GNUNET_CADET_PathCB) (void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)

Method called to retrieve information about a specific path known to the service.

Parameters

cls	Closure.
ppd	details about a path to the peer, NULL for end of information

Definition at line 507 of file gnunet_cadet_service.h.

GNUNET_CADET_TunnelsCB

typedef void(* GNUNET_CADET_TunnelsCB) (void *cls, const struct GNUNET_CADET_TunnelDetails *td)

Method called to retrieve information about all tunnels in CADET, called once per tunnel.

After last tunnel has been reported, an additional call with NULL is done.

Parameters

cls	Closure.
td	tunnel details, NULL for end of list

Definition at line 585 of file gnunet_cadet_service.h.

Enumeration Type Documentation

GNUNET_CADET_ChannelInfoOption

enum GNUNET_CADET_ChannelInfoOption

Enumerator
GNUNET_CADET_OPTION_PEER	Who is the peer at the other end of the channel. Only for use in GNUNET_CADET_channel_get_info struct GNUNET_PeerIdentity *peer

Definition at line 283 of file gnunet_cadet_service.h.

{
  GNUNET_CADET_OPTION_PEER = 0x0
};

Function Documentation

GNUNET_CADET_connect()

struct GNUNET_CADET_Handle * GNUNET_CADET_connect

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Connect to the MQ-based cadet service.

Parameters

cfg	Configuration to use.

Returns

Handle to the cadet service NULL on error.

Definition at line 897 of file cadet_api.c.

{
  struct GNUNET_CADET_Handle *h;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CADET_connect()\n");
  h = GNUNET_new (struct GNUNET_CADET_Handle);
  h->cfg = cfg;
  h->ports = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_YES);
  h->channels = GNUNET_CONTAINER_multihashmap32_create (4);
  reconnect (h);
  if (NULL == h->mq)
  {
    GNUNET_break (0);
    GNUNET_CADET_disconnect (h);
    return NULL;
  }
  h->next_ccn.channel_of_client = htonl (GNUNET_CADET_LOCAL_CHANNEL_ID_CLI);
  return h;
}

References cfg, GNUNET_ARM_Handle::cfg, GNUNET_break, GNUNET_CADET_disconnect(), GNUNET_CADET_LOCAL_CHANNEL_ID_CLI, GNUNET_CONTAINER_multihashmap32_create(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_YES, h, LOG, GNUNET_ARM_Handle::mq, and reconnect().

Referenced by create_service(), GSF_cadet_start_server(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_disconnect()

void GNUNET_CADET_disconnect

(

struct GNUNET_CADET_Handle *

handle

)

Disconnect from the cadet service.

All channels will be destroyed. All channel disconnect callbacks will be called on any still connected peers, notifying about their disconnection. The registered inbound channel cleaner will be called should any inbound channels still exist.

Parameters

handle

connection to cadet to disconnect

Definition at line 777 of file cadet_api.c.

{
  GNUNET_CONTAINER_multihashmap_iterate (handle->ports,
                                         &destroy_port_cb,
                                         handle);
  GNUNET_CONTAINER_multihashmap_destroy (handle->ports);
  handle->ports = NULL;
  GNUNET_CONTAINER_multihashmap32_iterate (handle->channels,
                                           &destroy_channel_cb,
                                           handle);
  GNUNET_CONTAINER_multihashmap32_destroy (handle->channels);
  handle->channels = NULL;
  if (NULL != handle->mq)
  {
    GNUNET_MQ_destroy (handle->mq);
    handle->mq = NULL;
  }
  if (NULL != handle->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
    handle->reconnect_task = NULL;
  }
  GNUNET_free (handle);
}

References destroy_channel_cb(), destroy_port_cb(), GNUNET_CONTAINER_multihashmap32_destroy(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), handle, and GNUNET_VPN_Handle::mq.

Referenced by cleanup(), client_disconnect_cb(), destroy_service(), do_shutdown(), GNUNET_CADET_connect(), GSF_cadet_stop_server(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_open_port()

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.

Parameters

h	CADET handle.
port	Hash identifying the port.
connects	Function called when an incoming channel is connected.
connects_cls	Closure for the connects handler.
window_changes	Function called when the transmit window size changes. Can be NULL.
disconnects	Function called when a channel is disconnected.
handlers	Callbacks for messages we care about, NULL-terminated.

Returns

Port handle, NULL if port is in use

Parameters

h	CADET handle.
port	Hash identifying the port.
connects	Function called when an incoming channel is connected.
connects_cls	Closure for the connects handler.
window_changes	Function called when the transmit window size changes.
disconnects	Function called when a channel is disconnected.
handlers	Callbacks for messages we care about, NULL-terminated.

Returns

Port handle, NULL if port is in use

Definition at line 966 of file cadet_api.c.

{
  struct GNUNET_CADET_Port *p;
  /* 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 ();
 
  GNUNET_assert (NULL != connects);
  GNUNET_assert (NULL != disconnects);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Listening to CADET port %s\n",
              GNUNET_h2s (port));
 
  p = GNUNET_new (struct GNUNET_CADET_Port);
  p->cadet = h;
  p->id = *port;
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
        h->ports,
        &p->id,
        p,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
  {
    GNUNET_free (p);
    return NULL;
  }
  p->connects = connects;
  p->cls = connects_cls;
  p->window_changes = window_changes;
  p->disconnects = disconnects;
  p->handlers = (NULL == pd->agpl_url)
                ? GNUNET_MQ_copy_handlers (handlers)
                : GNUNET_MQ_copy_handlers2 (handlers, &return_agpl, NULL);
 
  GNUNET_assert (GNUNET_OK == open_port_cb (h, &p->id, p));
  return p;
}

References GNUNET_OS_ProjectData::agpl_url, connects(), disconnects(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_MQ_copy_handlers(), GNUNET_MQ_copy_handlers2(), GNUNET_new, GNUNET_OK, GNUNET_OS_project_data_gnunet(), h, handlers, open_port_cb(), p, port, and return_agpl().

Referenced by advertise_dns_exit(), GSF_cadet_start_server(), handle_bob_client_message(), handle_client_listen(), handle_client_register_message(), new_sub(), open_srv_room(), run(), and store_service().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_close_port()

void GNUNET_CADET_close_port

(

struct GNUNET_CADET_Port *

p

)

Close a port opened with GNUNET_CADET_open_port.

The new_channel callback will no longer be called.

Parameters

p	Port handle.

Definition at line 804 of file cadet_api.c.

{
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multihashmap_remove (p->cadet->ports, &p->id, p));
  if (NULL != p->cadet->mq)
  {
    struct GNUNET_CADET_PortMessage *msg;
    struct GNUNET_MQ_Envelope *env;
 
    env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE);
    msg->port = p->id;
    GNUNET_MQ_send (p->cadet->mq, env);
  }
  GNUNET_free (p->handlers);
  GNUNET_free (p);
}

References env, GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_YES, msg, and p.

Referenced by cb_channel_incoming(), channel_incoming(), cleanup(), client_disconnect_cb(), close_srv_room(), destroy_port_cb(), destroy_service_session(), destroy_sub(), free_service_record(), GSF_cadet_stop_server(), shutdown_task(), and store_service().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_channel_create()

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.

If the destination peer closes the channel after accepting it, disconnects will be called for this channel (unless GNUNET_CADET_channel_destroy() was called on this end first).

Parameters

h	CADET handle.
channel_cls	Closure for the channel. It's given to: The management handler window_changes. The disconnect handler disconnects Each message type callback in handlers
destination	Peer identity the channel should go to.
port	Identification of the destination port.
window_changes	Function called when the transmit window size changes. Can be NULL if this data is of no interest.
disconnects	Function called when the channel is disconnected.
handlers	Callbacks for messages we care about, NULL-terminated.

Returns

Handle to the channel.

If the destination peer closes the channel after accepting it, disconnects will be called for this channel (unless GNUNET_CADET_channel_destroy() was called on this end first).

Parameters

h	CADET handle.
channel_cls	Closure for the channel. It's given to: The disconnect handler disconnects Each message type callback in handlers
destination	Peer identity the channel should go to.
port	Identification of the destination port.
window_changes	Function called when the transmit window size changes.
disconnects	Function called when the channel is disconnected.
handlers	Callbacks for messages we care about, NULL-terminated.

Returns

Handle to the channel.

Definition at line 1030 of file cadet_api.c.

{
  struct GNUNET_CADET_Channel *ch;
  struct GNUNET_CADET_LocalChannelCreateMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  GNUNET_assert (NULL != disconnects);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Creating channel to peer %s at port %s\n",
              GNUNET_i2s (destination),
              GNUNET_h2s (port));
  ch = create_channel (h, NULL);
  ch->ctx = channel_cls;
  ch->peer = *destination;
  ch->window_changes = window_changes;
  ch->disconnects = disconnects;
 
  /* Create MQ for channel */
  ch->mq = GNUNET_MQ_queue_for_callbacks (&cadet_mq_send_impl,
                                          &cadet_mq_destroy_impl,
                                          &cadet_mq_cancel_impl,
                                          ch,
                                          handlers,
                                          &cadet_mq_error_handler,
                                          ch);
  GNUNET_MQ_set_handlers_closure (ch->mq, channel_cls);
 
  /* Request channel creation to service */
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE);
  msg->ccn = ch->ccn;
  msg->port = *port;
  msg->peer = *destination;
  GNUNET_MQ_send (h->mq, env);
  return ch;
}

References cadet_mq_cancel_impl(), cadet_mq_destroy_impl(), cadet_mq_error_handler(), cadet_mq_send_impl(), GNUNET_CADET_Channel::ccn, ch, create_channel(), GNUNET_CADET_Channel::ctx, disconnects(), GNUNET_CADET_Channel::disconnects, env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE, GNUNET_MQ_msg, GNUNET_MQ_queue_for_callbacks(), GNUNET_MQ_send(), GNUNET_MQ_set_handlers_closure(), h, handlers, GNUNET_ARM_Handle::mq, GNUNET_CADET_Channel::mq, msg, GNUNET_CADET_Channel::peer, port, and GNUNET_CADET_Channel::window_changes.

Referenced by client_request_complete_alice(), connect_tunnel(), create_channel(), get_cadet(), get_channel(), handle_client_call_message(), handle_client_evaluate(), reset_cadet(), run(), and try_open_exit().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_channel_destroy()

void GNUNET_CADET_channel_destroy

(

struct GNUNET_CADET_Channel *

channel

)

Destroy an existing channel.

The existing end callback for the channel will NOT be called. Any pending outgoing messages will be sent but no incoming messages will be accepted and no data callbacks will be called.

Parameters

channel

Channel handle, becomes invalid after this call.

Definition at line 833 of file cadet_api.c.

{
  struct GNUNET_CADET_Handle *h = channel->cadet;
  struct GNUNET_CADET_LocalChannelDestroyMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  if (NULL != h->mq)
  {
    env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
    msg->ccn = channel->ccn;
    GNUNET_MQ_send (h->mq, env);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Destroying channel due to GNUNET_CADET_channel_destroy()\n");
  channel->disconnects = NULL;
  destroy_channel (channel);
}

References GNUNET_CADET_Channel::cadet, GNUNET_CADET_Channel::ccn, destroy_channel(), GNUNET_CADET_Channel::disconnects, env, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, GNUNET_MQ_msg, GNUNET_MQ_send(), h, GNUNET_ARM_Handle::mq, and msg.

Referenced by _GSS_operation_destroy(), _GSS_operation_destroy2(), cadet_mq_error_handler(), cadet_timeout(), callback_close_channel(), cleanup(), client_request_complete_alice(), connect_cb(), destroy_channel(), destroy_line_cadet_channels(), destroy_service_session(), destroy_tunnel(), free_channel_state(), GSF_cadet_release_clients(), reset_cadet(), setup_state_record(), shutdown_task(), timeout_cadet_task(), timeout_request(), and transmit_cryptographic_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_get_mq()

struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq

(

const struct GNUNET_CADET_Channel *

channel

)

Obtain the message queue for a connected channel.

Parameters

channel

The channel handle from which to get the MQ.

Returns

The message queue of the channel.

Obtain the message queue for a connected channel.

Parameters

channel

The channel handle from which to get the MQ.

Returns

NULL if channel is not yet connected.

Definition at line 1081 of file cadet_api.c.

{
  return channel->mq;
}

References GNUNET_CADET_Channel::mq.

Referenced by cadet_channel_end_cb(), cb_channel_incoming(), channel_new_cb(), client_request_complete_alice(), continue_writing(), dns_pre_request_handler(), get_mq(), handle_client_call_message(), handle_client_evaluate(), handle_data(), handle_datastore_reply(), inbound_channel(), process_dns_result(), read_stdio(), send_echo(), send_packet_to_cadet_channel(), send_to_channel(), send_tunnel_envelope(), and transmit_pending().

Here is the caller graph for this function:

GNUNET_CADET_receive_done()

void GNUNET_CADET_receive_done

(

struct GNUNET_CADET_Channel *

channel

)

Indicate readiness to receive the next message on a channel.

Should only be called once per handler called.

Parameters

channel

Channel that will be allowed to call another handler.

Indicate readiness to receive the next message on a channel.

Parameters

ch	Channel on which to send the ACK.

Definition at line 875 of file cadet_api.c.

{
  struct GNUNET_CADET_LocalAck *msg;
  struct GNUNET_MQ_Envelope *env;
 
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending ACK on channel %X\n",
       ntohl (channel->ccn.channel_of_client));
  msg->ccn = channel->ccn;
  GNUNET_MQ_send (channel->cadet->mq, env);
}

References GNUNET_CADET_Channel::cadet, GNUNET_CADET_Channel::ccn, GNUNET_CADET_ClientChannelNumber::channel_of_client, env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK, GNUNET_MQ_msg, GNUNET_MQ_send(), LOG, GNUNET_CADET_Handle::mq, and msg.

Referenced by cadet_mq_error_handler(), cb_intersection_element_removed(), continue_writing(), handle_alices_cryptodata_message(), handle_bobs_cryptodata_message(), handle_bobs_cryptodata_multipart(), handle_cadet_audio_message(), handle_cadet_hangup_message(), handle_cadet_pickup_message(), handle_cadet_resume_message(), handle_cadet_ring_message(), handle_cadet_suspend_message(), handle_client_accept(), handle_data(), handle_dns_request(), handle_icmp_back(), handle_icmp_remote(), handle_icmp_service(), handle_intersection_p2p_bf(), handle_intersection_p2p_done(), handle_intersection_p2p_element_info(), handle_peer_check(), handle_peer_pull_reply(), handle_peer_pull_request(), handle_peer_push(), handle_reply(), handle_tcp_back(), handle_tcp_data(), handle_tcp_remote(), handle_tcp_service(), handle_tunnel_message(), handle_udp_back(), handle_udp_remote(), handle_udp_service(), handle_union_p2p_demand(), handle_union_p2p_done(), handle_union_p2p_elements(), handle_union_p2p_full_done(), handle_union_p2p_full_element(), handle_union_p2p_ibf(), handle_union_p2p_inquiry(), handle_union_p2p_offer(), handle_union_p2p_request_full(), and handle_union_p2p_strata_estimator().

Here is the call graph for this function:

Here is the caller graph for this function:

GC_u2h()

const struct GNUNET_HashCode * GC_u2h

(

uint32_t

port

)

Transitional function to convert an unsigned int port to a hash value.

WARNING: local static value returned, NOT reentrant! WARNING: do not use this function for new code!

Parameters

port	Numerical port (unsigned int format).

Returns

A GNUNET_HashCode usable for the new CADET API.

Definition at line 44 of file cadet_api_helper.c.

{
  static struct GNUNET_HashCode hash;
 
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "This is a transitional function, use proper crypto hashes as CADET ports\n");
  GNUNET_CRYPTO_hash (&port,
                      sizeof(port),
                      &hash);
  return &hash;
}

References GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, and port.

Here is the call graph for this function:

GNUNET_CADET_channel_get_info()

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.

Parameters

channel	Channel handle.
option	Query (GNUNET_CADET_OPTION_*)
...	dependent on option, currently not used

Returns

Union with an answer to the query.

Definition at line 853 of file cadet_api.c.

{
  switch (option)
  {
  case GNUNET_CADET_OPTION_PEER:
    return (const union GNUNET_CADET_ChannelInfo *) &channel->peer;
 
  default:
    GNUNET_break (0);
    return NULL;
  }
}

References GNUNET_break, GNUNET_CADET_OPTION_PEER, and GNUNET_CADET_Channel::peer.

GNUNET_CADET_get_channel()

struct GNUNET_CADET_ChannelMonitor * GNUNET_CADET_get_channel	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		struct GNUNET_PeerIdentity *	peer,
		GNUNET_CADET_ChannelCB	callback,
		void *	callback_cls
	)

Request information about channels to peer from the local peer.

Parameters

cfg	configuration to use
peer	ID of the other end of the channel.
callback	Function to call with the requested data.
callback_cls	Closure for callback.

Request information about channels to peer from the local peer.

Parameters

cfg	configuration to use
peer	ID of the other end of the channel.
callback	Function to call with the requested data.
callback_cls	Closure for callback.

Returns

NULL on error

Definition at line 213 of file cadet_api_get_channel.c.

{
  struct GNUNET_CADET_ChannelMonitor *cm;
 
  if (NULL == callback)
  {
    GNUNET_break (0);
    return NULL;
  }
  cm = GNUNET_new (struct GNUNET_CADET_ChannelMonitor);
  cm->channel_cb = callback;
  cm->channel_cb_cls = callback_cls;
  cm->cfg = cfg;
  cm->peer = *peer;
  reconnect (cm);
  if (NULL == cm->mq)
  {
    GNUNET_free (cm);
    return NULL;
  }
  return cm;
}

References cfg, GNUNET_CADET_ChannelMonitor::cfg, GNUNET_CADET_ChannelMonitor::channel_cb, GNUNET_CADET_ChannelMonitor::channel_cb_cls, GNUNET_break, GNUNET_free, GNUNET_new, GNUNET_CADET_ChannelMonitor::mq, GNUNET_CADET_ChannelMonitor::peer, and reconnect().

Here is the call graph for this function:

GNUNET_CADET_get_channel_cancel()

void * GNUNET_CADET_get_channel_cancel

(

struct GNUNET_CADET_ChannelMonitor *

cm

)

Cancel a channel monitor request.

The callback will not be called (anymore).

Parameters

h	Cadet handle.

Returns

Closure that was given to GNUNET_CADET_get_channel().

Definition at line 247 of file cadet_api_get_channel.c.

{
  void *ret = cm->channel_cb_cls;
 
  if (NULL != cm->mq)
    GNUNET_MQ_destroy (cm->mq);
  if (NULL != cm->reconnect_task)
    GNUNET_SCHEDULER_cancel (cm->reconnect_task);
  GNUNET_free (cm);
  return ret;
}

References GNUNET_CADET_ChannelMonitor::channel_cb_cls, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_CADET_ChannelMonitor::mq, GNUNET_CADET_ChannelMonitor::reconnect_task, and ret.

Referenced by handle_channel_info(), and handle_channel_info_end().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_list_peers()

struct GNUNET_CADET_PeersLister * GNUNET_CADET_list_peers	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_CADET_PeersCB	callback,
		void *	callback_cls
	)

Request information about peers known to the running cadet service.

The callback will be called for every peer known to the service. Only one info request (of any kind) can be active at once.

Parameters

cfg	configuration to use
callback	Function to call with the requested data.
callback_cls	Closure for callback.

Returns

NULL on error

Definition at line 193 of file cadet_api_list_peers.c.

{
  struct GNUNET_CADET_PeersLister *pl;
 
  if (NULL == callback)
  {
    GNUNET_break (0);
    return NULL;
  }
  pl = GNUNET_new (struct GNUNET_CADET_PeersLister);
  pl->peers_cb = callback;
  pl->peers_cb_cls = callback_cls;
  pl->cfg = cfg;
  reconnect (pl);
  if (NULL == pl->mq)
  {
    GNUNET_free (pl);
    return NULL;
  }
  return pl;
}

References cfg, GNUNET_CADET_PeersLister::cfg, GNUNET_break, GNUNET_free, GNUNET_new, GNUNET_CADET_PeersLister::mq, GNUNET_CADET_PeersLister::peers_cb, GNUNET_CADET_PeersLister::peers_cb_cls, and reconnect().

Referenced by get_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_list_peers_cancel()

void * GNUNET_CADET_list_peers_cancel

(

struct GNUNET_CADET_PeersLister *

pl

)

Cancel a peer info request.

The callback will not be called (anymore).

Parameters

pl	operation handle

Returns

Closure that was given to GNUNET_CADET_list_peers().

The callback will not be called (anymore).

Parameters

pl	operation handle

Returns

Closure given to GNUNET_CADET_get_peers().

Definition at line 225 of file cadet_api_list_peers.c.

{
  void *ret = pl->peers_cb_cls;
 
  if (NULL != pl->mq)
    GNUNET_MQ_destroy (pl->mq);
  if (NULL != pl->reconnect_task)
    GNUNET_SCHEDULER_cancel (pl->reconnect_task);
  GNUNET_free (pl);
  return ret;
}

References GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_CADET_PeersLister::mq, GNUNET_CADET_PeersLister::peers_cb_cls, GNUNET_CADET_PeersLister::reconnect_task, and ret.

Referenced by handle_get_peers_end(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_get_path()

struct GNUNET_CADET_GetPath * GNUNET_CADET_get_path	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const struct GNUNET_PeerIdentity *	id,
		GNUNET_CADET_PathCB	callback,
		void *	callback_cls
	)

Request information about a peer known to the running cadet peer.

Parameters

cfg	configuration to use
id	Peer whose paths we want to examine.
callback	Function to call with the requested data.
callback_cls	Closure for callback.

Returns

NULL on error

Definition at line 220 of file cadet_api_get_path.c.

{
  struct GNUNET_CADET_GetPath *gp;
 
  if (NULL == callback)
  {
    GNUNET_break (0);
    return NULL;
  }
  gp = GNUNET_new (struct GNUNET_CADET_GetPath);
  gp->path_cb = callback;
  gp->path_cb_cls = callback_cls;
  gp->cfg = cfg;
  gp->id = *id;
  reconnect (gp);
  if (NULL == gp->mq)
  {
    GNUNET_free (gp);
    return NULL;
  }
  return gp;
}

References cfg, GNUNET_CADET_GetPath::cfg, GNUNET_break, GNUNET_free, GNUNET_new, id, GNUNET_CADET_GetPath::id, GNUNET_CADET_GetPath::mq, GNUNET_CADET_GetPath::path_cb, GNUNET_CADET_GetPath::path_cb_cls, and reconnect().

Referenced by show_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_get_path_cancel()

void * GNUNET_CADET_get_path_cancel

(

struct GNUNET_CADET_GetPath *

gp

)

Cancel gp operation.

Parameters

gp	operation to cancel

Returns

closure from GNUNET_CADET_get_path().

Definition at line 254 of file cadet_api_get_path.c.

{
  void *ret = gp->path_cb_cls;
 
  if (NULL != gp->mq)
    GNUNET_MQ_destroy (gp->mq);
  if (NULL != gp->reconnect_task)
    GNUNET_SCHEDULER_cancel (gp->reconnect_task);
  GNUNET_free (gp);
  return ret;
}

References GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_CADET_GetPath::mq, GNUNET_CADET_GetPath::path_cb_cls, GNUNET_CADET_GetPath::reconnect_task, and ret.

Referenced by handle_get_path_end(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_list_tunnels()

struct GNUNET_CADET_ListTunnels * GNUNET_CADET_list_tunnels	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_CADET_TunnelsCB	callback,
		void *	callback_cls
	)

Request information about tunnels of the running cadet peer.

The callback will be called for every tunnel of the service. Only one info request (of any kind) can be active at once.

Parameters

cfg	configuration to use
callback	Function to call with the requested data.
callback_cls	Closure for callback.

Returns

NULL on error

Definition at line 194 of file cadet_api_list_tunnels.c.

{
  struct GNUNET_CADET_ListTunnels *lt;
 
  if (NULL == callback)
  {
    GNUNET_break (0);
    return NULL;
  }
  lt = GNUNET_new (struct GNUNET_CADET_ListTunnels);
  lt->tunnels_cb = callback;
  lt->tunnels_cb_cls = callback_cls;
  lt->cfg = cfg;
  reconnect (lt);
  if (NULL == lt->mq)
  {
    GNUNET_free (lt);
    return NULL;
  }
  return lt;
}

References cfg, GNUNET_CADET_ListTunnels::cfg, GNUNET_break, GNUNET_free, GNUNET_new, GNUNET_CADET_ListTunnels::mq, reconnect(), GNUNET_CADET_ListTunnels::tunnels_cb, and GNUNET_CADET_ListTunnels::tunnels_cb_cls.

Referenced by get_tunnels().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_CADET_list_tunnels_cancel()

void * GNUNET_CADET_list_tunnels_cancel

(

struct GNUNET_CADET_ListTunnels *

lt

)

Cancel a monitor request.

The monitor callback will not be called.

Parameters

lt	operation handle

Returns

Closure given to GNUNET_CADET_list_tunnels(), if any.

The monitor callback will not be called.

Parameters

lt	operation handle

Returns

Closure given to GNUNET_CADET_list_tunnels().

Definition at line 226 of file cadet_api_list_tunnels.c.

{
  void *ret = lt->tunnels_cb_cls;
 
  if (NULL != lt->mq)
    GNUNET_MQ_destroy (lt->mq);
  if (NULL != lt->reconnect_task)
    GNUNET_SCHEDULER_cancel (lt->reconnect_task);
  GNUNET_free (lt);
  return ret;
}

References GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_CADET_ListTunnels::mq, GNUNET_CADET_ListTunnels::reconnect_task, ret, and GNUNET_CADET_ListTunnels::tunnels_cb_cls.

Referenced by handle_get_tunnels_end(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function: