GNUnet  0.10.x
Data Structures | Macros | Functions
cadet_api.c File Reference

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:

Go to the source code of this file.

Data Structures

struct  GNUNET_CADET_Handle
 Opaque handle to the service. More...
 
struct  GNUNET_CADET_Channel
 Opaque handle to a channel. 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_Portfind_port (const struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *hash)
 Find the Port struct for a hash. More...
 
static struct GNUNET_CADET_Channelfind_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. More...
 
static struct GNUNET_CADET_Channelcreate_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. More...
 
static void destroy_channel (struct GNUNET_CADET_Channel *ch)
 Destroy the specified channel. More...
 
static void reconnect (struct GNUNET_CADET_Handle *h)
 Reconnect to the service, retransmit all infomation to try to restore the original state. More...
 
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. More...
 
static void reconnect_cbk (void *cls)
 Reconnect callback: tries to reconnect again after a failer previous reconnecttion. More...
 
static void notify_window_size (struct GNUNET_CADET_Channel *ch)
 Notify the application about a change in the window size (if needed). More...
 
static void cadet_mq_send_now (void *cls)
 Transmit the next message from our queue. More...
 
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. More...
 
static void cadet_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Handle destruction of a message queue. More...
 
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. More...
 
static void cadet_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
 Implementation function that cancels the currently sent message. More...
 
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. More...
 
static void handle_channel_destroy (void *cls, const struct GNUNET_CADET_LocalChannelDestroyMessage *msg)
 Process the channel destroy notification and free associated resources. More...
 
static int check_local_data (void *cls, const struct GNUNET_CADET_LocalData *message)
 Check that message received from CADET service is well-formed. More...
 
static void handle_local_data (void *cls, const struct GNUNET_CADET_LocalData *message)
 Process the incoming data packets, call appropriate handlers. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
void GNUNET_CADET_disconnect (struct GNUNET_CADET_Handle *handle)
 Disconnect from the cadet service. More...
 
void GNUNET_CADET_close_port (struct GNUNET_CADET_Port *p)
 Close a port opened with GNUNET_CADET_open_port(). More...
 
void GNUNET_CADET_channel_destroy (struct GNUNET_CADET_Channel *channel)
 Destroy an existing channel. More...
 
const union GNUNET_CADET_ChannelInfoGNUNET_CADET_channel_get_info (struct GNUNET_CADET_Channel *channel, enum GNUNET_CADET_ChannelOption option,...)
 Get information about a channel. More...
 
void GNUNET_CADET_receive_done (struct GNUNET_CADET_Channel *channel)
 Send an ack on the channel to confirm the processing of a message. More...
 
struct GNUNET_CADET_HandleGNUNET_CADET_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
 Connect to the MQ-based cadet service. More...
 
struct GNUNET_CADET_PortGNUNET_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 incomming MQ-based channels. More...
 
struct GNUNET_CADET_ChannelGNUNET_CADET_channel_create (struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, enum GNUNET_CADET_ChannelOption options, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
 Create a new channel towards a remote peer. More...
 
struct GNUNET_MQ_HandleGNUNET_CADET_get_mq (const struct GNUNET_CADET_Channel *channel)
 Obtain the message queue for a connected peer. More...
 

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__)

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
hCADET handle.
hashHashCode for the port number.
Returns
The port handle if known, NULL otherwise.

Definition at line 204 of file cadet_api.c.

References GNUNET_CONTAINER_multihashmap_get(), and GNUNET_CADET_Handle::ports.

Referenced by handle_channel_created().

206 {
207  return GNUNET_CONTAINER_multihashmap_get (h->ports, hash);
208 }
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
struct GNUNET_CONTAINER_MultiHashMap * ports
Ports open.
Definition: cadet_api.c:48
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
hCadet handle
ccnID of the wanted channel
Returns
handle to the required channel or NULL if not found

Definition at line 219 of file cadet_api.c.

References GNUNET_CADET_ClientChannelNumber::channel_of_client, GNUNET_CADET_Handle::channels, and GNUNET_CONTAINER_multihashmap32_get().

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

221 {
223  ntohl (ccn.channel_of_client));
224 }
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
void * GNUNET_CONTAINER_multihashmap32_get(const struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key)
Given a key find a value in the map matching the key.
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Channels open.
Definition: cadet_api.c:53
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
hCadet handle
ccnppointer to desired ccn of the channel, NULL to assign one automatically.
Returns
Handle to the created channel.

Definition at line 235 of file cadet_api.c.

References ch, GNUNET_CADET_ClientChannelNumber::channel_of_client, GNUNET_CADET_Handle::channels, find_channel(), GNUNET_assert, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI, GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_new, GNUNET_OK, h, and GNUNET_CADET_Handle::next_ccn.

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

237 {
238  struct GNUNET_CADET_Channel *ch;
240 
241  ch = GNUNET_new (struct GNUNET_CADET_Channel);
242  ch->cadet = h;
243  if (NULL == ccnp)
244  {
245  while (NULL != find_channel (h, h->next_ccn))
248  (1 + ntohl (h->next_ccn.channel_of_client)));
249  ccn = h->next_ccn;
250  }
251  else
252  {
253  ccn = *ccnp;
254  }
255  ch->ccn = ccn;
258  h->channels,
259  ntohl (ch->ccn.channel_of_client),
260  ch,
262  return ch;
263 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Opaque handle to a channel.
Definition: cadet_api.c:80
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
int GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CADET_ClientChannelNumber next_ccn
child of the next channel to create (to avoid reusing IDs often)
Definition: cadet_api.c:58
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
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.
Definition: cadet_api.c:219
Number uniquely identifying a channel of a client.
Definition: cadet.h:102
#define GNUNET_CADET_LOCAL_CHANNEL_ID_CLI
Minimum value for channel IDs of local clients.
Definition: cadet.h:71
There must only be one value per key; storing a value should fail if a value under the same key alrea...
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Channels open.
Definition: cadet_api.c:53
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
chPointer to the channel.
call_cleanerWhether to call the cleaner handler.

Definition at line 277 of file cadet_api.c.

References GNUNET_CADET_Channel::cadet, GNUNET_CADET_Channel::ccn, GNUNET_CADET_ClientChannelNumber::channel_of_client, GNUNET_CADET_Handle::channels, 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, GNUNET_CADET_Channel::pending_env, and reconnect().

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

278 {
279  struct GNUNET_CADET_Handle *h = ch->cadet;
280 
282  "Destroying channel %X of %p\n",
283  htonl (ch->ccn.channel_of_client),
284  h);
285  GNUNET_assert (
286  GNUNET_YES ==
288  ntohl (ch->ccn.channel_of_client),
289  ch));
290  if (NULL != ch->mq_cont)
291  {
293  ch->mq_cont = NULL;
294  }
295  /* signal channel destruction */
296  if (NULL != ch->disconnects)
297  ch->disconnects (ch->ctx, ch);
298  if (NULL != ch->pending_env)
300  GNUNET_MQ_destroy (ch->mq);
301  GNUNET_free (ch);
302 }
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet_api.c:129
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
Opaque handle to the service.
Definition: cadet_api.c:38
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet_api.c:112
struct GNUNET_CADET_ClientChannelNumber ccn
Local ID of the channel, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI bit is set if outbound.
Definition: cadet_api.c:134
int GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
void * ctx
Any data the caller wants to put in here, used for the various callbacks (disconnects, window_changes, handlers).
Definition: cadet_api.c:102
#define LOG(kind,...)
Definition: cadet_api.c:33
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:321
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet_api.c:107
struct GNUNET_CADET_Handle * cadet
Handle to the cadet this channel belongs to.
Definition: cadet_api.c:91
struct GNUNET_MQ_Envelope * pending_env
Pending envelope with a message to be transmitted to the service as soon as we are allowed to...
Definition: cadet_api.c:119
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Channels open.
Definition: cadet_api.c:53
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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 infomation to try to restore the original state.

Parameters
hhandle to the cadet

Definition at line 789 of file cadet_api.c.

References GNUNET_CADET_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, handle_mq_error(), and GNUNET_CADET_Handle::mq.

Referenced by destroy_channel(), GNUNET_CADET_connect(), and reconnect_cbk().

790 {
792  {GNUNET_MQ_hd_fixed_size (channel_created,
795  h),
799  h),
800  GNUNET_MQ_hd_var_size (local_data,
802  struct GNUNET_CADET_LocalData,
803  h),
804  GNUNET_MQ_hd_fixed_size (local_ack,
806  struct GNUNET_CADET_LocalAck,
807  h),
809 
810  GNUNET_assert (NULL == h->mq);
811  h->mq =
812  GNUNET_CLIENT_connect (h->cfg, "cadet", handlers, &handle_mq_error, h);
813 }
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration given by the client, in case of reconnection.
Definition: cadet_api.c:63
Message to allow the client send more data to the service (always service -> client).
Definition: cadet.h:217
static void channel_destroy(struct CadetChannel *ch)
Destroy the given channel.
Message for or to a client to destroy tunnel.
Definition: cadet.h:172
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY
Tell client that a channel was destroyed.
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:901
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE
Ask the cadet service to create a new channel.
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 c...
Definition: cadet_api.c:768
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK
Local ACK for data.
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:43
Message handler for a specific message type.
Message for a client to create channels.
Definition: cadet.h:138
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA
Payload client <-> service.
Message for cadet data traffic.
Definition: cadet.h:189
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
Here is the call graph for this function:
Here is the caller 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
clsthe struct GNUNET_CADET_Handle
idport ID
valuea struct GNUNET_CADET_Channel to open
Returns
GNUNET_OK (continue to iterate)

Definition at line 325 of file cadet_api.c.

References env, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_OK, GNUNET_CADET_Port::id, GNUNET_CADET_Handle::mq, msg, port, GNUNET_CADET_PortMessage::port, and value.

Referenced by GNUNET_CADET_open_port(), and reconnect_cbk().

326 {
327  struct GNUNET_CADET_Handle *h = cls;
328  struct GNUNET_CADET_Port *port = value;
330  struct GNUNET_MQ_Envelope *env;
331 
332  (void) id;
334  msg->port = port->id;
335  GNUNET_MQ_send (h->mq, env);
336  return GNUNET_OK;
337 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
Opaque handle to the service.
Definition: cadet_api.c:38
Message for a client to create and destroy channels.
Definition: cadet.h:118
struct GNUNET_HashCode id
Port "number".
Definition: cadet_api.c:157
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
static char * value
Value of the record to add/remove.
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:43
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN
Start listening on a port.
struct GNUNET_HashCode port
Port to open/close.
Definition: cadet.h:131
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static uint16_t port
Port number.
Definition: gnunet-bcd.c:79
Opaque handle to a port.
Definition: cadet_api.c:151
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
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 failer previous reconnecttion.

Parameters
clsclosure (cadet handle)

Definition at line 347 of file cadet_api.c.

References GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_TIME_STD_BACKOFF, open_port_cb(), GNUNET_CADET_Handle::ports, reconnect(), GNUNET_CADET_Handle::reconnect_task, and GNUNET_CADET_Handle::reconnect_time.

Referenced by handle_mq_error().

348 {
349  struct GNUNET_CADET_Handle *h = cls;
350 
351  h->reconnect_task = NULL;
353  reconnect (h);
355 }
Opaque handle to the service.
Definition: cadet_api.c:38
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. ...
Definition: cadet_api.c:325
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_HashMapIterator it, void *it_cls)
Iterate over all entries in the map.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_CONTAINER_MultiHashMap * ports
Ports open.
Definition: cadet_api.c:48
static void reconnect(struct GNUNET_CADET_Handle *h)
Reconnect to the service, retransmit all infomation to try to restore the original state...
Definition: cadet_api.c:789
struct GNUNET_TIME_Relative reconnect_time
Time to the next reconnect in case one reconnect fails.
Definition: cadet_api.c:73
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
struct GNUNET_SCHEDULER_Task * reconnect_task
Task for trying to reconnect.
Definition: cadet_api.c:68
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
chChannel to notify about.

Definition at line 364 of file cadet_api.c.

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

Referenced by handle_local_ack().

365 {
366  if (NULL != ch->window_changes)
367  ch->window_changes (ch->ctx,
368  ch, /* FIXME: remove 'ch'? */
369  ch->allow_send);
370 }
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet_api.c:144
void * ctx
Any data the caller wants to put in here, used for the various callbacks (disconnects, window_changes, handlers).
Definition: cadet_api.c:102
GNUNET_CADET_WindowSizeEventHandler window_changes
Window change handler.
Definition: cadet_api.c:124
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
clsClosure (channel whose mq to activate).

Definition at line 379 of file cadet_api.c.

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_Handle::mq, GNUNET_CADET_Channel::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().

380 {
381  struct GNUNET_CADET_Channel *ch = cls;
382  struct GNUNET_MQ_Envelope *env = ch->pending_env;
383 
384  ch->mq_cont = NULL;
385  if (0 == ch->allow_send)
386  {
387  /* how did we get here? */
388  GNUNET_break (0);
389  return;
390  }
391  if (NULL == env)
392  {
393  /* how did we get here? */
394  GNUNET_break (0);
395  return;
396  }
397  ch->allow_send--;
398  ch->pending_env = NULL;
400  "Sending message on channel %s to CADET, new window size is %u\n",
401  GNUNET_i2s (&ch->peer),
402  ch->allow_send);
403  GNUNET_MQ_send (ch->cadet->mq, env);
405 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
struct GNUNET_PeerIdentity peer
Other end of the channel.
Definition: cadet_api.c:86
Opaque handle to a channel.
Definition: cadet_api.c:80
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet_api.c:144
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet_api.c:112
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:43
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet_api.c:107
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_CADET_Handle * cadet
Handle to the cadet this channel belongs to.
Definition: cadet_api.c:91
struct GNUNET_MQ_Envelope * pending_env
Pending envelope with a message to be transmitted to the service as soon as we are allowed to...
Definition: cadet_api.c:119
#define GNUNET_log(kind,...)
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:486
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
mqthe message queue
msgthe message to send
impl_statestate of the implementation

Definition at line 421 of file cadet_api.c.

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(), GNUNET_CADET_Handle::mq, GNUNET_CADET_Channel::mq_cont, GNUNET_CADET_Channel::pending_env, GNUNET_CADET_LocalData::pp, and GNUNET_MessageHeader::size.

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

424 {
425  struct GNUNET_CADET_Channel *ch = impl_state;
426  struct GNUNET_CADET_Handle *h = ch->cadet;
427  uint16_t msize;
428  struct GNUNET_MQ_Envelope *orig_env;
429  struct GNUNET_MQ_Envelope *env;
430  struct GNUNET_CADET_LocalData *cadet_msg;
432 
433  if (NULL == h->mq)
434  {
435  /* We're currently reconnecting, pretend this worked */
437  return;
438  }
439  orig_env = GNUNET_MQ_get_current_envelope (mq);
440  pp = GNUNET_MQ_env_get_options (orig_env);
441 
442  /* check message size for sanity */
443  msize = ntohs (msg->size);
445  {
446  GNUNET_break (0);
448  return;
449  }
450  env = GNUNET_MQ_msg_nested_mh (cadet_msg,
452  msg);
453  cadet_msg->ccn = ch->ccn;
454  cadet_msg->pp = htonl ((uint32_t) pp);
455  GNUNET_assert (NULL == ch->pending_env);
456  ch->pending_env = env;
457  if (0 < ch->allow_send)
459 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
Opaque handle to the service.
Definition: cadet_api.c:38
#define GNUNET_MQ_msg_nested_mh(mvar, type, mh)
Allocate a GNUNET_MQ_Envelope, and append a payload message after the given message struct...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void cadet_mq_send_now(void *cls)
Transmit the next message from our queue.
Definition: cadet_api.c:379
Opaque handle to a channel.
Definition: cadet_api.c:80
GNUNET_MQ_PriorityPreferences
Per envelope preferences and priorities.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet_api.c:144
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet_api.c:112
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:1020
struct GNUNET_CADET_ClientChannelNumber ccn
Local ID of the channel, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI bit is set if outbound.
Definition: cadet_api.c:134
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:43
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel.
Definition: cadet.h:199
#define GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
Maximum message size that can be sent on CADET.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_CADET_Handle * cadet
Handle to the cadet this channel belongs to.
Definition: cadet_api.c:91
struct GNUNET_MQ_Envelope * pending_env
Pending envelope with a message to be transmitted to the service as soon as we are allowed to...
Definition: cadet_api.c:119
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA
Payload client <-> service.
struct GNUNET_MQ_Envelope * GNUNET_MQ_get_current_envelope(struct GNUNET_MQ_Handle *mq)
Function to obtain the current envelope from within GNUNET_MQ_SendImpl implementations.
Definition: mq.c:974
Message for cadet data traffic.
Definition: cadet.h:189
uint32_t pp
Priority and preferences (an enum GNUNET_MQ_PriorityPreferences) of the message in NBO...
Definition: cadet.h:205
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:486
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
mqthe message queue to destroy
impl_statestate of the implementation

Definition at line 470 of file cadet_api.c.

References ch, GNUNET_assert, and GNUNET_CADET_Channel::mq.

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

471 {
472  struct GNUNET_CADET_Channel *ch = impl_state;
473 
474  GNUNET_assert (mq == ch->mq);
475  ch->mq = NULL;
476 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Opaque handle to a channel.
Definition: cadet_api.c:80
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet_api.c:107
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
clsclosure with our struct GNUNET_CADET_Channel
errorerror code

Definition at line 488 of file cadet_api.c.

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

489 {
490  struct GNUNET_CADET_Channel *ch = cls;
491 
492  if (GNUNET_MQ_ERROR_NO_MATCH == error)
493  {
494  /* Got a message we did not understand, still try to continue! */
495  GNUNET_break_op (0);
497  }
498  else
499  {
501  "MQ error in communication with CADET: %d\n",
502  error);
503  if (NULL != ch->disconnects)
504  ch->disconnects (ch->ctx, ch);
506  }
507 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet_api.c:129
We received a message for which we have no matching handler.
Opaque handle to a channel.
Definition: cadet_api.c:80
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void * ctx
Any data the caller wants to put in here, used for the various callbacks (disconnects, window_changes, handlers).
Definition: cadet_api.c:102
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:973
#define GNUNET_log(kind,...)
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:911
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
mqmessage queue
impl_statestate specific to the implementation

Definition at line 518 of file cadet_api.c.

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

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

519 {
520  struct GNUNET_CADET_Channel *ch = impl_state;
521 
522  (void) mq;
523  GNUNET_assert (NULL != ch->pending_env);
525  ch->pending_env = NULL;
526  if (NULL != ch->mq_cont)
527  {
529  ch->mq_cont = NULL;
530  }
531 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Opaque handle to a channel.
Definition: cadet_api.c:80
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet_api.c:112
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:321
struct GNUNET_MQ_Envelope * pending_env
Pending envelope with a message to be transmitted to the service as soon as we are allowed to...
Definition: cadet_api.c:119
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
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
hThe cadet handle
msgA message with the details of the new incoming channel

Definition at line 541 of file cadet_api.c.

References cadet_mq_cancel_impl(), cadet_mq_destroy_impl(), cadet_mq_error_handler(), cadet_mq_send_impl(), GNUNET_CADET_LocalChannelCreateMessage::ccn, GNUNET_CADET_LocalChannelDestroyMessage::ccn, ch, GNUNET_CADET_Port::cls, GNUNET_CADET_Port::connects, create_channel(), GNUNET_CADET_Channel::ctx, GNUNET_CADET_Channel::disconnects, GNUNET_CADET_Port::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(), GNUNET_CADET_Port::handlers, GNUNET_CADET_Channel::incoming_port, LOG, GNUNET_CADET_Handle::mq, GNUNET_CADET_Channel::mq, GNUNET_CADET_LocalChannelCreateMessage::opt, GNUNET_CADET_Channel::options, GNUNET_CADET_Channel::peer, GNUNET_CADET_LocalChannelCreateMessage::peer, port, GNUNET_CADET_LocalChannelCreateMessage::port, GNUNET_CADET_Channel::window_changes, and GNUNET_CADET_Port::window_changes.

544 {
545  struct GNUNET_CADET_Handle *h = cls;
546  struct GNUNET_CADET_Channel *ch;
547  struct GNUNET_CADET_Port *port;
548  const struct GNUNET_HashCode *port_number;
550 
551  ccn = msg->ccn;
552  port_number = &msg->port;
553  if (ntohl (ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
554  {
555  GNUNET_break (0);
556  return;
557  }
558  port = find_port (h, port_number);
559  if (NULL == port)
560  {
561  /* We could have closed the port but the service didn't know about it yet
562  * This is not an error.
563  */
565  struct GNUNET_MQ_Envelope *env;
566 
568  "No handler for incoming channel %X (on port %s, recently closed?)\n",
569  ntohl (ccn.channel_of_client),
570  GNUNET_h2s (port_number));
571  env =
573  d_msg->ccn = msg->ccn;
574  GNUNET_MQ_send (h->mq, env);
575  return;
576  }
577 
578  ch = create_channel (h, &ccn);
579  ch->peer = msg->peer;
580  ch->incoming_port = port;
581  ch->options = ntohl (msg->opt);
583  "Creating incoming channel %X [%s] %p\n",
584  ntohl (ccn.channel_of_client),
585  GNUNET_h2s (port_number),
586  ch);
587 
588  GNUNET_assert (NULL != port->connects);
589  ch->window_changes = port->window_changes;
590  ch->disconnects = port->disconnects;
594  ch,
595  port->handlers,
597  ch);
598  ch->ctx = port->connects (port->cls, ch, &msg->peer);
600 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
GNUNET_CADET_DisconnectEventHandler disconnects
Handler called when an incoming channel is destroyed.
Definition: cadet_api.c:187
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:150
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet_api.c:129
Message for or to a client to destroy tunnel.
Definition: cadet.h:172
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY
Tell client that a channel was destroyed.
GNUNET_CADET_WindowSizeEventHandler window_changes
Window size change handler.
Definition: cadet_api.c:182
Opaque handle to the service.
Definition: cadet_api.c:38
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void cadet_mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Handle destruction of a message queue.
Definition: cadet_api.c:470
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_PeerIdentity peer
Other end of the channel.
Definition: cadet_api.c:86
Opaque handle to a channel.
Definition: cadet_api.c:80
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
GNUNET_CADET_ConnectEventHandler connects
Handler for incoming channels on this port.
Definition: cadet_api.c:172
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
void GNUNET_MQ_set_handlers_closure(struct GNUNET_MQ_Handle *mq, void *handlers_cls)
Change the closure argument in all of the handlers of the mq.
Definition: mq.c:583
struct GNUNET_MQ_Handle * GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send, GNUNET_MQ_DestroyImpl destroy, GNUNET_MQ_CancelImpl cancel, void *impl_state, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *cls)
Create a message queue for the specified handlers.
Definition: mq.c:552
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.
Definition: cadet_api.c:235
void * ctx
Any data the caller wants to put in here, used for the various callbacks (disconnects, window_changes, handlers).
Definition: cadet_api.c:102
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:43
Number uniquely identifying a channel of a client.
Definition: cadet.h:102
#define GNUNET_CADET_LOCAL_CHANNEL_ID_CLI
Minimum value for channel IDs of local clients.
Definition: cadet.h:71
#define LOG(kind,...)
Definition: cadet_api.c:33
A 512-bit hashcode.
void * cls
Closure for handler.
Definition: cadet_api.c:167
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.
Definition: cadet_api.c:421
static void cadet_mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
Definition: cadet_api.c:518
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet_api.c:107
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
enum GNUNET_CADET_ChannelOption options
Channel options: reliability, etc.
Definition: cadet_api.c:139
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:182
static uint16_t port
Port number.
Definition: gnunet-bcd.c:79
struct GNUNET_MQ_MessageHandler * handlers
Payload handlers for incoming channels.
Definition: cadet_api.c:192
GNUNET_CADET_WindowSizeEventHandler window_changes
Window change handler.
Definition: cadet_api.c:124
struct GNUNET_CADET_Port * incoming_port
Channel&#39;s port, if incoming.
Definition: cadet_api.c:96
Opaque handle to a port.
Definition: cadet_api.c:151
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.
Definition: cadet_api.c:204
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.
Definition: cadet_api.c:488
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
struct GNUNET_PeerIdentity peer
Channel&#39;s peer.
Definition: cadet.h:155
struct GNUNET_HashCode port
Port of the channel.
Definition: cadet.h:160
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
hThe cadet handle
msgA message with the details of the channel being destroyed

Definition at line 610 of file cadet_api.c.

References GNUNET_CADET_LocalChannelDestroyMessage::ccn, ch, GNUNET_CADET_ClientChannelNumber::channel_of_client, destroy_channel(), find_channel(), GNUNET_ERROR_TYPE_DEBUG, and LOG.

613 {
614  struct GNUNET_CADET_Handle *h = cls;
615  struct GNUNET_CADET_Channel *ch;
616 
617  ch = find_channel (h, msg->ccn);
618  if (NULL == ch)
619  {
621  "Received channel destroy for unknown channel %X from CADET service (recently close?)\n",
622  ntohl (msg->ccn.channel_of_client));
623  return;
624  }
626  "Received channel destroy for channel %X from CADET service\n",
627  ntohl (msg->ccn.channel_of_client));
628  destroy_channel (ch);
629 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
Opaque handle to the service.
Definition: cadet_api.c:38
Opaque handle to a channel.
Definition: cadet_api.c:80
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
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.
Definition: cadet_api.c:219
#define LOG(kind,...)
Definition: cadet_api.c:33
static void destroy_channel(struct GNUNET_CADET_Channel *ch)
Destroy the specified channel.
Definition: cadet_api.c:277
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:182
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
clsthe struct GNUNET_CADET_Handle
messagethe message we got
Returns
GNUNET_OK if the message is well-formed, GNUNET_SYSERR otherwise

Definition at line 641 of file cadet_api.c.

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

642 {
643  uint16_t size;
644 
645  (void) cls;
646  size = ntohs (message->header.size);
647  if (sizeof (*message) + sizeof (struct GNUNET_MessageHeader) > size)
648  {
649  GNUNET_break (0);
650  return GNUNET_SYSERR;
651  }
652  return GNUNET_OK;
653 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
static unsigned int size
Size of the "table".
Definition: peer.c:67
Header for all communications.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA.
Definition: cadet.h:194

◆ 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
hThe cadet handle
messageA message encapsulating the data

Definition at line 663 of file cadet_api.c.

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(), LOG, GNUNET_CADET_Channel::mq, payload, GNUNET_CADET_Channel::peer, type, and GNUNET_MessageHeader::type.

664 {
665  struct GNUNET_CADET_Handle *h = cls;
666  const struct GNUNET_MessageHeader *payload;
667  struct GNUNET_CADET_Channel *ch;
668  uint16_t type;
669  int fwd;
670 
671  ch = find_channel (h, message->ccn);
672  if (NULL == ch)
673  {
675  "Unknown channel %X for incoming data (recently closed?)\n",
676  ntohl (message->ccn.channel_of_client));
677  return;
678  }
679 
680  payload = (const struct GNUNET_MessageHeader *) &message[1];
681  type = ntohs (payload->type);
684  "Got a %s data on channel %s [%X] of type %u\n",
685  fwd ? "FWD" : "BWD",
686  GNUNET_i2s (&ch->peer),
687  ntohl (message->ccn.channel_of_client),
688  type);
689  GNUNET_MQ_inject_message (ch->mq, payload);
690 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
Opaque handle to the service.
Definition: cadet_api.c:38
struct GNUNET_PeerIdentity peer
Other end of the channel.
Definition: cadet_api.c:86
Opaque handle to a channel.
Definition: cadet_api.c:80
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_CADET_ClientChannelNumber ccn
Local ID of the channel, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI bit is set if outbound.
Definition: cadet_api.c:134
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
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.
Definition: cadet_api.c:219
void GNUNET_MQ_inject_message(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *mh)
Call the message message handler that was registered for the type of the given message in the given m...
Definition: mq.c:202
#define GNUNET_CADET_LOCAL_CHANNEL_ID_CLI
Minimum value for channel IDs of local clients.
Definition: cadet.h:71
#define LOG(kind,...)
Definition: cadet_api.c:33
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel.
Definition: cadet.h:199
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet_api.c:107
static unsigned long long payload
How much data are we currently storing in the database?
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Header for all communications.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
hCadet handle.
messageMessage itself.

Definition at line 701 of file cadet_api.c.

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(), LOG, GNUNET_CADET_Channel::mq_cont, notify_window_size(), GNUNET_CADET_Channel::peer, and GNUNET_CADET_Channel::pending_env.

702 {
703  struct GNUNET_CADET_Handle *h = cls;
704  struct GNUNET_CADET_Channel *ch;
705 
706  ch = find_channel (h, message->ccn);
707  if (NULL == ch)
708  {
710  "ACK on unknown channel %X\n",
711  ntohl (message->ccn.channel_of_client));
712  return;
713  }
714  ch->allow_send++;
716  "Got an ACK on mq channel %X (peer %s); new window size is %u!\n",
717  ntohl (ch->ccn.channel_of_client),
718  GNUNET_i2s (&ch->peer),
719  ch->allow_send);
720  if (NULL == ch->pending_env)
721  {
723  "Got an ACK on mq channel %X, allow send now %u!\n",
724  ntohl (ch->ccn.channel_of_client),
725  ch->allow_send);
726  notify_window_size (ch);
727  return;
728  }
729  if (NULL != ch->mq_cont)
730  return; /* already working on it! */
732 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:111
Opaque handle to the service.
Definition: cadet_api.c:38
static void cadet_mq_send_now(void *cls)
Transmit the next message from our queue.
Definition: cadet_api.c:379
struct GNUNET_PeerIdentity peer
Other end of the channel.
Definition: cadet_api.c:86
Opaque handle to a channel.
Definition: cadet_api.c:80
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet_api.c:144
static void notify_window_size(struct GNUNET_CADET_Channel *ch)
Notify the application about a change in the window size (if needed).
Definition: cadet_api.c:364
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet_api.c:112
struct GNUNET_CADET_ClientChannelNumber ccn
Local ID of the channel, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI bit is set if outbound.
Definition: cadet_api.c:134
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.
Definition: cadet_api.c:219
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1273
#define LOG(kind,...)
Definition: cadet_api.c:33
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel allowed to send more data.
Definition: cadet.h:227
struct GNUNET_MQ_Envelope * pending_env
Pending envelope with a message to be transmitted to the service as soon as we are allowed to...
Definition: cadet_api.c:119
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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
clsthe struct GNUNET_CADET_Handle
cidchanenl ID
valuea struct GNUNET_CADET_Channel to destroy
Returns
GNUNET_OK (continue to iterate)

Definition at line 745 of file cadet_api.c.

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

Referenced by GNUNET_CADET_disconnect(), and handle_mq_error().

746 {
747  /* struct GNUNET_CADET_Handle *handle = cls; */
748  struct GNUNET_CADET_Channel *ch = value;
749 
750  (void) cls;
751  (void) cid;
753  "Destroying channel due to GNUNET_CADET_disconnect()\n");
754  destroy_channel (ch);
755  return GNUNET_OK;
756 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
Opaque handle to a channel.
Definition: cadet_api.c:80
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
static char * value
Value of the record to add/remove.
static void destroy_channel(struct GNUNET_CADET_Channel *ch)
Destroy the specified channel.
Definition: cadet_api.c:277
#define GNUNET_log(kind,...)
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
clsclosure, a struct GNUNET_CORE_Handle *
errorerror code

Definition at line 768 of file cadet_api.c.

References GNUNET_CADET_Handle::channels, destroy_channel_cb(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_CADET_Handle::mq, reconnect_cbk(), GNUNET_CADET_Handle::reconnect_task, and GNUNET_CADET_Handle::reconnect_time.

Referenced by reconnect().

769 {
770  struct GNUNET_CADET_Handle *h = cls;
771 
772  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error);
774  GNUNET_MQ_destroy (h->mq);
775  h->mq = NULL;
776  GNUNET_assert (NULL == h->reconnect_task);
777  h->reconnect_task =
779 }
Opaque handle to the service.
Definition: cadet_api.c:38
static void reconnect_cbk(void *cls)
Reconnect callback: tries to reconnect again after a failer previous reconnecttion.
Definition: cadet_api.c:347
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1246
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:43
struct GNUNET_TIME_Relative reconnect_time
Time to the next reconnect in case one reconnect fails.
Definition: cadet_api.c:73
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...
Definition: cadet_api.c:745
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_HashMapIterator32 it, void *it_cls)
Iterate over all entries in the map.
#define GNUNET_log(kind,...)
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
struct GNUNET_SCHEDULER_Task * reconnect_task
Task for trying to reconnect.
Definition: cadet_api.c:68
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Channels open.
Definition: cadet_api.c:53
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
clsthe struct GNUNET_CADET_Handle
idport ID
valuea struct GNUNET_CADET_Channel to destroy
Returns
GNUNET_OK (continue to iterate)

Definition at line 826 of file cadet_api.c.

References GNUNET_break, GNUNET_CADET_close_port(), GNUNET_OK, port, and value.

Referenced by GNUNET_CADET_disconnect().

827 {
828  /* struct GNUNET_CADET_Handle *handle = cls; */
829  struct GNUNET_CADET_Port *port = value;
830 
831  (void) cls;
832  (void) id;
833  /* This is a warning, the app should have cleanly closed all open ports */
834  GNUNET_break (0);
836  return GNUNET_OK;
837 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static char * value
Value of the record to add/remove.
void * cls
Closure for handler.
Definition: cadet_api.c:167
static uint16_t port
Port number.
Definition: gnunet-bcd.c:79
Opaque handle to a port.
Definition: cadet_api.c:151
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:882
Here is the call graph for this function:
Here is the caller graph for this function: