GNUnet  0.11.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_ChannelInfoOption 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, 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 197 of file cadet_api.c.

References GNUNET_CONTAINER_multihashmap_get(), and GNUNET_CADET_Handle::ports.

Referenced by handle_channel_created().

199 {
200  return GNUNET_CONTAINER_multihashmap_get (h->ports, hash);
201 }
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 212 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().

214 {
216  ntohl (ccn.channel_of_client));
217 }
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 228 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().

230 {
231  struct GNUNET_CADET_Channel *ch;
233 
234  ch = GNUNET_new (struct GNUNET_CADET_Channel);
235  ch->cadet = h;
236  if (NULL == ccnp)
237  {
238  while (NULL != find_channel (h, h->next_ccn))
241  | (1 + ntohl (h->next_ccn.channel_of_client)));
242  ccn = h->next_ccn;
243  }
244  else
245  {
246  ccn = *ccnp;
247  }
248  ch->ccn = ccn;
251  h->channels,
252  ntohl (ch->ccn.channel_of_client),
253  ch,
255  return ch;
256 }
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:75
#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:99
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:212
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 270 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().

271 {
272  struct GNUNET_CADET_Handle *h = ch->cadet;
273 
275  "Destroying channel %X of %p\n",
276  htonl (ch->ccn.channel_of_client),
277  h);
278  GNUNET_assert (
279  GNUNET_YES ==
281  ntohl (ch->ccn.channel_of_client),
282  ch));
283  if (NULL != ch->mq_cont)
284  {
286  ch->mq_cont = NULL;
287  }
288  /* signal channel destruction */
289  if (NULL != ch->disconnects)
290  ch->disconnects (ch->ctx, ch);
291  if (NULL != ch->pending_env)
293  GNUNET_MQ_destroy (ch->mq);
294  GNUNET_free (ch);
295 }
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet_api.c:128
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:99
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet_api.c:111
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:133
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:101
#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:106
struct GNUNET_CADET_Handle * cadet
Handle to the cadet this channel belongs to.
Definition: cadet_api.c:90
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:118
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
#define GNUNET_YES
Definition: gnunet_common.h:77
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:966
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 781 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().

782 {
784  { GNUNET_MQ_hd_fixed_size (channel_created,
787  h),
791  h),
792  GNUNET_MQ_hd_var_size (local_data,
794  struct GNUNET_CADET_LocalData,
795  h),
796  GNUNET_MQ_hd_fixed_size (local_ack,
798  struct GNUNET_CADET_LocalAck,
799  h),
801 
802  GNUNET_assert (NULL == h->mq);
803  h->mq =
804  GNUNET_CLIENT_connect (h->cfg, "cadet", handlers, &handle_mq_error, h);
805 }
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:1057
#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:760
#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 318 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().

319 {
320  struct GNUNET_CADET_Handle *h = cls;
321  struct GNUNET_CADET_Port *port = value;
323  struct GNUNET_MQ_Envelope *env;
324 
325  (void) id;
327  msg->port = port->id;
328  GNUNET_MQ_send (h->mq, env);
329  return GNUNET_OK;
330 }
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:150
#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:75
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
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:81
Opaque handle to a port.
Definition: cadet_api.c:145
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 340 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().

341 {
342  struct GNUNET_CADET_Handle *h = cls;
343 
344  h->reconnect_task = NULL;
346  reconnect (h);
348 }
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:318
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
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:781
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...
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
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 357 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().

358 {
359  if (NULL != ch->window_changes)
360  ch->window_changes (ch->ctx,
361  ch, /* FIXME: remove 'ch'? */
362  ch->allow_send);
363 }
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet_api.c:138
void * ctx
Any data the caller wants to put in here, used for the various callbacks (disconnects, window_changes, handlers).
Definition: cadet_api.c:101
GNUNET_CADET_WindowSizeEventHandler window_changes
Window change handler.
Definition: cadet_api.c:123
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 372 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().

373 {
374  struct GNUNET_CADET_Channel *ch = cls;
375  struct GNUNET_MQ_Envelope *env = ch->pending_env;
376 
377  ch->mq_cont = NULL;
378  if (0 == ch->allow_send)
379  {
380  /* how did we get here? */
381  GNUNET_break (0);
382  return;
383  }
384  if (NULL == env)
385  {
386  /* how did we get here? */
387  GNUNET_break (0);
388  return;
389  }
390  ch->allow_send--;
391  ch->pending_env = NULL;
393  "Sending message on channel %s to CADET, new window size is %u\n",
394  GNUNET_i2s (&ch->peer),
395  ch->allow_send);
396  GNUNET_MQ_send (ch->cadet->mq, env);
398 }
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:85
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:138
#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:111
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:106
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:90
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:118
#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 414 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().

417 {
418  struct GNUNET_CADET_Channel *ch = impl_state;
419  struct GNUNET_CADET_Handle *h = ch->cadet;
420  uint16_t msize;
421  struct GNUNET_MQ_Envelope *orig_env;
422  struct GNUNET_MQ_Envelope *env;
423  struct GNUNET_CADET_LocalData *cadet_msg;
425 
426  if (NULL == h->mq)
427  {
428  /* We're currently reconnecting, pretend this worked */
430  return;
431  }
432  orig_env = GNUNET_MQ_get_current_envelope (mq);
433  pp = GNUNET_MQ_env_get_options (orig_env);
434 
435  /* check message size for sanity */
436  msize = ntohs (msg->size);
438  {
439  GNUNET_break (0);
441  return;
442  }
443  env = GNUNET_MQ_msg_nested_mh (cadet_msg,
445  msg);
446  cadet_msg->ccn = ch->ccn;
447  cadet_msg->pp = htonl ((uint32_t) pp);
448  GNUNET_assert (NULL == ch->pending_env);
449  ch->pending_env = env;
450  if (0 < ch->allow_send)
452 }
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:372
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:138
#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:99
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet_api.c:111
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:133
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:1280
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:90
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:118
#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 463 of file cadet_api.c.

References ch, GNUNET_assert, and GNUNET_CADET_Channel::mq.

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

464 {
465  struct GNUNET_CADET_Channel *ch = impl_state;
466 
467  GNUNET_assert (mq == ch->mq);
468  ch->mq = NULL;
469 }
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:106
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 481 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().

482 {
483  struct GNUNET_CADET_Channel *ch = cls;
484 
485  if (GNUNET_MQ_ERROR_NO_MATCH == error)
486  {
487  /* Got a message we did not understand, still try to continue! */
488  GNUNET_break_op (0);
490  }
491  else
492  {
494  "MQ error in communication with CADET: %d\n",
495  error);
496  if (NULL != ch->disconnects)
497  ch->disconnects (ch->ctx, ch);
499  }
500 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet_api.c:128
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:101
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:954
#define GNUNET_log(kind,...)
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:903
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 511 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().

512 {
513  struct GNUNET_CADET_Channel *ch = impl_state;
514 
515  (void) mq;
516  GNUNET_assert (NULL != ch->pending_env);
518  ch->pending_env = NULL;
519  if (NULL != ch->mq_cont)
520  {
522  ch->mq_cont = NULL;
523  }
524 }
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:111
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:118
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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 534 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_Channel::peer, GNUNET_CADET_LocalChannelCreateMessage::peer, port, GNUNET_CADET_LocalChannelCreateMessage::port, GNUNET_CADET_Channel::window_changes, and GNUNET_CADET_Port::window_changes.

537 {
538  struct GNUNET_CADET_Handle *h = cls;
539  struct GNUNET_CADET_Channel *ch;
540  struct GNUNET_CADET_Port *port;
541  const struct GNUNET_HashCode *port_number;
543 
544  ccn = msg->ccn;
545  port_number = &msg->port;
546  if (ntohl (ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
547  {
548  GNUNET_break (0);
549  return;
550  }
551  port = find_port (h, port_number);
552  if (NULL == port)
553  {
554  /* We could have closed the port but the service didn't know about it yet
555  * This is not an error.
556  */
558  struct GNUNET_MQ_Envelope *env;
559 
561  "No handler for incoming channel %X (on port %s, recently closed?)\n",
562  ntohl (ccn.channel_of_client),
563  GNUNET_h2s (port_number));
564  env =
566  d_msg->ccn = msg->ccn;
567  GNUNET_MQ_send (h->mq, env);
568  return;
569  }
570 
571  ch = create_channel (h, &ccn);
572  ch->peer = msg->peer;
573  ch->incoming_port = port;
575  "Creating incoming channel %X [%s] %p\n",
576  ntohl (ccn.channel_of_client),
577  GNUNET_h2s (port_number),
578  ch);
579 
580  GNUNET_assert (NULL != port->connects);
581  ch->window_changes = port->window_changes;
582  ch->disconnects = port->disconnects;
586  ch,
587  port->handlers,
589  ch);
590  ch->ctx = port->connects (port->cls, ch, &msg->peer);
592 }
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:180
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:128
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:175
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:463
#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:85
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:165
#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:99
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:228
void * ctx
Any data the caller wants to put in here, used for the various callbacks (disconnects, window_changes, handlers).
Definition: cadet_api.c:101
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:160
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:414
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:511
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet_api.c:106
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
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:81
struct GNUNET_MQ_MessageHandler * handlers
Payload handlers for incoming channels.
Definition: cadet_api.c:185
GNUNET_CADET_WindowSizeEventHandler window_changes
Window change handler.
Definition: cadet_api.c:123
struct GNUNET_CADET_Port * incoming_port
Channel&#39;s port, if incoming.
Definition: cadet_api.c:95
Opaque handle to a port.
Definition: cadet_api.c:145
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:197
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:481
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 602 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.

605 {
606  struct GNUNET_CADET_Handle *h = cls;
607  struct GNUNET_CADET_Channel *ch;
608 
609  ch = find_channel (h, msg->ccn);
610  if (NULL == ch)
611  {
613  "Received channel destroy for unknown channel %X from CADET service (recently close?)\n",
614  ntohl (msg->ccn.channel_of_client));
615  return;
616  }
618  "Received channel destroy for channel %X from CADET service\n",
619  ntohl (msg->ccn.channel_of_client));
620  destroy_channel (ch);
621 }
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:99
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:212
#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:270
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 633 of file cadet_api.c.

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

634 {
635  uint16_t size;
636 
637  (void) cls;
638  size = ntohs (message->header.size);
639  if (sizeof(*message) + sizeof(struct GNUNET_MessageHeader) > size)
640  {
641  GNUNET_break (0);
642  return GNUNET_SYSERR;
643  }
644  return GNUNET_OK;
645 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:76
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 655 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.

656 {
657  struct GNUNET_CADET_Handle *h = cls;
658  const struct GNUNET_MessageHeader *payload;
659  struct GNUNET_CADET_Channel *ch;
660  uint16_t type;
661  int fwd;
662 
663  ch = find_channel (h, message->ccn);
664  if (NULL == ch)
665  {
667  "Unknown channel %X for incoming data (recently closed?)\n",
668  ntohl (message->ccn.channel_of_client));
669  return;
670  }
671 
672  payload = (const struct GNUNET_MessageHeader *) &message[1];
673  type = ntohs (payload->type);
676  "Got a %s data on channel %s [%X] of type %u\n",
677  fwd ? "FWD" : "BWD",
678  GNUNET_i2s (&ch->peer),
679  ntohl (message->ccn.channel_of_client),
680  type);
681  GNUNET_MQ_inject_message (ch->mq, payload);
682 }
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:85
Opaque handle to a channel.
Definition: cadet_api.c:80
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
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:133
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:212
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:106
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 693 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.

694 {
695  struct GNUNET_CADET_Handle *h = cls;
696  struct GNUNET_CADET_Channel *ch;
697 
698  ch = find_channel (h, message->ccn);
699  if (NULL == ch)
700  {
702  "ACK on unknown channel %X\n",
703  ntohl (message->ccn.channel_of_client));
704  return;
705  }
706  ch->allow_send++;
708  "Got an ACK on mq channel %X (peer %s); new window size is %u!\n",
709  ntohl (ch->ccn.channel_of_client),
710  GNUNET_i2s (&ch->peer),
711  ch->allow_send);
712  if (NULL == ch->pending_env)
713  {
715  "Got an ACK on mq channel %X, allow send now %u!\n",
716  ntohl (ch->ccn.channel_of_client),
717  ch->allow_send);
718  notify_window_size (ch);
719  return;
720  }
721  if (NULL != ch->mq_cont)
722  return; /* already working on it! */
724 }
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:372
struct GNUNET_PeerIdentity peer
Other end of the channel.
Definition: cadet_api.c:85
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:138
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:357
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet_api.c:111
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:133
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:212
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:1280
#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:118
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 737 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().

738 {
739  /* struct GNUNET_CADET_Handle *handle = cls; */
740  struct GNUNET_CADET_Channel *ch = value;
741 
742  (void) cls;
743  (void) cid;
745  "Destroying channel due to GNUNET_CADET_disconnect()\n");
746  destroy_channel (ch);
747  return GNUNET_OK;
748 }
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:75
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:270
#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 760 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().

761 {
762  struct GNUNET_CADET_Handle *h = cls;
763 
764  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error);
766  GNUNET_MQ_destroy (h->mq);
767  h->mq = NULL;
768  GNUNET_assert (NULL == h->reconnect_task);
769  h->reconnect_task =
771 }
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:340
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
#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:99
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:1253
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:737
#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 818 of file cadet_api.c.

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

Referenced by GNUNET_CADET_disconnect().

819 {
820  /* struct GNUNET_CADET_Handle *handle = cls; */
821  struct GNUNET_CADET_Port *port = value;
822 
823  (void) cls;
824  (void) id;
825  /* This is a warning, the app should have cleanly closed all open ports */
826  GNUNET_break (0);
828  return GNUNET_OK;
829 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#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:160
static uint16_t port
Port number.
Definition: gnunet-bcd.c:81
Opaque handle to a port.
Definition: cadet_api.c:145
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:874
Here is the call graph for this function:
Here is the caller graph for this function: