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_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 194 of file cadet_api.c.

References GNUNET_CONTAINER_multihashmap_get(), and GNUNET_CADET_Handle::ports.

Referenced by handle_channel_created().

196 {
197  return GNUNET_CONTAINER_multihashmap_get(h->ports, hash);
198 }
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:47
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 209 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().

211 {
213  ntohl(ccn.channel_of_client));
214 }
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:110
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:52
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 225 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().

227 {
228  struct GNUNET_CADET_Channel *ch;
230 
231  ch = GNUNET_new(struct GNUNET_CADET_Channel);
232  ch->cadet = h;
233  if (NULL == ccnp)
234  {
235  while (NULL != find_channel(h, h->next_ccn))
238  (1 + ntohl(h->next_ccn.channel_of_client)));
239  ccn = h->next_ccn;
240  }
241  else
242  {
243  ccn = *ccnp;
244  }
245  ch->ccn = ccn;
248  h->channels,
249  ntohl(ch->ccn.channel_of_client),
250  ch,
252  return ch;
253 }
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:110
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Opaque handle to a channel.
Definition: cadet_api.c:79
#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:57
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:209
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:52
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 267 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().

268 {
269  struct GNUNET_CADET_Handle *h = ch->cadet;
270 
272  "Destroying channel %X of %p\n",
273  htonl(ch->ccn.channel_of_client),
274  h);
276  GNUNET_YES ==
278  ntohl(ch->ccn.channel_of_client),
279  ch));
280  if (NULL != ch->mq_cont)
281  {
283  ch->mq_cont = NULL;
284  }
285  /* signal channel destruction */
286  if (NULL != ch->disconnects)
287  ch->disconnects(ch->ctx, ch);
288  if (NULL != ch->pending_env)
290  GNUNET_MQ_destroy(ch->mq);
291  GNUNET_free(ch);
292 }
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet_api.c:126
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:110
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:109
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:131
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:99
#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:319
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet_api.c:104
struct GNUNET_CADET_Handle * cadet
Handle to the cadet this channel belongs to.
Definition: cadet_api.c:88
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:116
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:821
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Channels open.
Definition: cadet_api.c:52
#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:956
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 778 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().

779 {
781  { GNUNET_MQ_hd_fixed_size(channel_created,
784  h),
788  h),
789  GNUNET_MQ_hd_var_size(local_data,
791  struct GNUNET_CADET_LocalData,
792  h),
793  GNUNET_MQ_hd_fixed_size(local_ack,
795  struct GNUNET_CADET_LocalAck,
796  h),
798 
799  GNUNET_assert(NULL == h->mq);
800  h->mq =
801  GNUNET_CLIENT_connect(h->cfg, "cadet", handlers, &handle_mq_error, h);
802 }
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration given by the client, in case of reconnection.
Definition: cadet_api.c:62
Message to allow the client send more data to the service (always service -> client).
Definition: cadet.h:212
static void channel_destroy(struct CadetChannel *ch)
Destroy the given channel.
Message for or to a client to destroy tunnel.
Definition: cadet.h:169
#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:900
#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:757
#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:42
Message handler for a specific message type.
Message for a client to create channels.
Definition: cadet.h:136
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA
Payload client <-> service.
Message for cadet data traffic.
Definition: cadet.h:185
#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 315 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().

316 {
317  struct GNUNET_CADET_Handle *h = cls;
318  struct GNUNET_CADET_Port *port = value;
320  struct GNUNET_MQ_Envelope *env;
321 
322  (void)id;
324  msg->port = port->id;
325  GNUNET_MQ_send(h->mq, env);
326  return GNUNET_OK;
327 }
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:117
struct GNUNET_HashCode id
Port "number".
Definition: cadet_api.c:147
#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:94
static char * value
Value of the record to add/remove.
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:42
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN
Start listening on a port.
struct GNUNET_HashCode port
Port to open/close.
Definition: cadet.h:129
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:143
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:351
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 337 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().

338 {
339  struct GNUNET_CADET_Handle *h = cls;
340 
341  h->reconnect_task = NULL;
343  reconnect(h);
345 }
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:315
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:47
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:778
struct GNUNET_TIME_Relative reconnect_time
Time to the next reconnect in case one reconnect fails.
Definition: cadet_api.c:72
#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:67
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 354 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().

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

370 {
371  struct GNUNET_CADET_Channel *ch = cls;
372  struct GNUNET_MQ_Envelope *env = ch->pending_env;
373 
374  ch->mq_cont = NULL;
375  if (0 == ch->allow_send)
376  {
377  /* how did we get here? */
378  GNUNET_break(0);
379  return;
380  }
381  if (NULL == env)
382  {
383  /* how did we get here? */
384  GNUNET_break(0);
385  return;
386  }
387  ch->allow_send--;
388  ch->pending_env = NULL;
390  "Sending message on channel %s to CADET, new window size is %u\n",
391  GNUNET_i2s(&ch->peer),
392  ch->allow_send);
393  GNUNET_MQ_send(ch->cadet->mq, env);
395 }
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:83
Opaque handle to a channel.
Definition: cadet_api.c:79
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet_api.c:136
#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:109
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:42
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet_api.c:104
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:88
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:116
#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:351
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:484
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 411 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().

414 {
415  struct GNUNET_CADET_Channel *ch = impl_state;
416  struct GNUNET_CADET_Handle *h = ch->cadet;
417  uint16_t msize;
418  struct GNUNET_MQ_Envelope *orig_env;
419  struct GNUNET_MQ_Envelope *env;
420  struct GNUNET_CADET_LocalData *cadet_msg;
422 
423  if (NULL == h->mq)
424  {
425  /* We're currently reconnecting, pretend this worked */
427  return;
428  }
429  orig_env = GNUNET_MQ_get_current_envelope(mq);
430  pp = GNUNET_MQ_env_get_options(orig_env);
431 
432  /* check message size for sanity */
433  msize = ntohs(msg->size);
435  {
436  GNUNET_break(0);
438  return;
439  }
440  env = GNUNET_MQ_msg_nested_mh(cadet_msg,
442  msg);
443  cadet_msg->ccn = ch->ccn;
444  cadet_msg->pp = htonl((uint32_t)pp);
445  GNUNET_assert(NULL == ch->pending_env);
446  ch->pending_env = env;
447  if (0 < ch->allow_send)
449 }
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:369
Opaque handle to a channel.
Definition: cadet_api.c:79
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:136
#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:109
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:1017
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:131
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:42
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:1264
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel.
Definition: cadet.h:194
#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:88
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:116
#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:971
Message for cadet data traffic.
Definition: cadet.h:185
uint32_t pp
Priority and preferences (an enum GNUNET_MQ_PriorityPreferences) of the message in NBO...
Definition: cadet.h:200
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:484
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 460 of file cadet_api.c.

References ch, GNUNET_assert, and GNUNET_CADET_Channel::mq.

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

461 {
462  struct GNUNET_CADET_Channel *ch = impl_state;
463 
464  GNUNET_assert(mq == ch->mq);
465  ch->mq = NULL;
466 }
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:79
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet_api.c:104
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 478 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().

479 {
480  struct GNUNET_CADET_Channel *ch = cls;
481 
482  if (GNUNET_MQ_ERROR_NO_MATCH == error)
483  {
484  /* Got a message we did not understand, still try to continue! */
485  GNUNET_break_op(0);
487  }
488  else
489  {
491  "MQ error in communication with CADET: %d\n",
492  error);
493  if (NULL != ch->disconnects)
494  ch->disconnects(ch->ctx, ch);
496  }
497 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet_api.c:126
We received a message for which we have no matching handler.
Opaque handle to a channel.
Definition: cadet_api.c:79
#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:99
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:951
#define GNUNET_log(kind,...)
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:900
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 508 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().

509 {
510  struct GNUNET_CADET_Channel *ch = impl_state;
511 
512  (void)mq;
513  GNUNET_assert(NULL != ch->pending_env);
515  ch->pending_env = NULL;
516  if (NULL != ch->mq_cont)
517  {
519  ch->mq_cont = NULL;
520  }
521 }
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:79
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet_api.c:109
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:319
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:116
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
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 531 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.

534 {
535  struct GNUNET_CADET_Handle *h = cls;
536  struct GNUNET_CADET_Channel *ch;
537  struct GNUNET_CADET_Port *port;
538  const struct GNUNET_HashCode *port_number;
540 
541  ccn = msg->ccn;
542  port_number = &msg->port;
543  if (ntohl(ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
544  {
545  GNUNET_break(0);
546  return;
547  }
548  port = find_port(h, port_number);
549  if (NULL == port)
550  {
551  /* We could have closed the port but the service didn't know about it yet
552  * This is not an error.
553  */
555  struct GNUNET_MQ_Envelope *env;
556 
558  "No handler for incoming channel %X (on port %s, recently closed?)\n",
559  ntohl(ccn.channel_of_client),
560  GNUNET_h2s(port_number));
561  env =
563  d_msg->ccn = msg->ccn;
564  GNUNET_MQ_send(h->mq, env);
565  return;
566  }
567 
568  ch = create_channel(h, &ccn);
569  ch->peer = msg->peer;
570  ch->incoming_port = port;
572  "Creating incoming channel %X [%s] %p\n",
573  ntohl(ccn.channel_of_client),
574  GNUNET_h2s(port_number),
575  ch);
576 
577  GNUNET_assert(NULL != port->connects);
578  ch->window_changes = port->window_changes;
579  ch->disconnects = port->disconnects;
583  ch,
584  port->handlers,
586  ch);
587  ch->ctx = port->connects(port->cls, ch, &msg->peer);
589 }
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:177
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:147
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet_api.c:126
Message for or to a client to destroy tunnel.
Definition: cadet.h:169
#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:172
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:460
#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:83
Opaque handle to a channel.
Definition: cadet_api.c:79
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:162
#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:581
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:550
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:225
void * ctx
Any data the caller wants to put in here, used for the various callbacks (disconnects, window_changes, handlers).
Definition: cadet_api.c:99
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:42
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:157
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:411
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:508
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet_api.c:104
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:178
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:182
GNUNET_CADET_WindowSizeEventHandler window_changes
Window change handler.
Definition: cadet_api.c:121
struct GNUNET_CADET_Port * incoming_port
Channel&#39;s port, if incoming.
Definition: cadet_api.c:93
Opaque handle to a port.
Definition: cadet_api.c:143
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:194
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:478
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:351
struct GNUNET_PeerIdentity peer
Channel&#39;s peer.
Definition: cadet.h:152
struct GNUNET_HashCode port
Port of the channel.
Definition: cadet.h:157
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 599 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.

602 {
603  struct GNUNET_CADET_Handle *h = cls;
604  struct GNUNET_CADET_Channel *ch;
605 
606  ch = find_channel(h, msg->ccn);
607  if (NULL == ch)
608  {
610  "Received channel destroy for unknown channel %X from CADET service (recently close?)\n",
611  ntohl(msg->ccn.channel_of_client));
612  return;
613  }
615  "Received channel destroy for channel %X from CADET service\n",
616  ntohl(msg->ccn.channel_of_client));
617  destroy_channel(ch);
618 }
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:110
Opaque handle to the service.
Definition: cadet_api.c:38
Opaque handle to a channel.
Definition: cadet_api.c:79
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:209
#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:267
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:178
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 630 of file cadet_api.c.

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

631 {
632  uint16_t size;
633 
634  (void)cls;
635  size = ntohs(message->header.size);
636  if (sizeof(*message) + sizeof(struct GNUNET_MessageHeader) > size)
637  {
638  GNUNET_break(0);
639  return GNUNET_SYSERR;
640  }
641  return GNUNET_OK;
642 }
#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:66
Header for all communications.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA.
Definition: cadet.h:189

◆ 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 652 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.

653 {
654  struct GNUNET_CADET_Handle *h = cls;
655  const struct GNUNET_MessageHeader *payload;
656  struct GNUNET_CADET_Channel *ch;
657  uint16_t type;
658  int fwd;
659 
660  ch = find_channel(h, message->ccn);
661  if (NULL == ch)
662  {
664  "Unknown channel %X for incoming data (recently closed?)\n",
665  ntohl(message->ccn.channel_of_client));
666  return;
667  }
668 
669  payload = (const struct GNUNET_MessageHeader *)&message[1];
670  type = ntohs(payload->type);
673  "Got a %s data on channel %s [%X] of type %u\n",
674  fwd ? "FWD" : "BWD",
675  GNUNET_i2s(&ch->peer),
676  ntohl(message->ccn.channel_of_client),
677  type);
678  GNUNET_MQ_inject_message(ch->mq, payload);
679 }
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:110
Opaque handle to the service.
Definition: cadet_api.c:38
struct GNUNET_PeerIdentity peer
Other end of the channel.
Definition: cadet_api.c:83
Opaque handle to a channel.
Definition: cadet_api.c:79
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:131
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:209
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:200
#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:194
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet_api.c:104
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 690 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.

691 {
692  struct GNUNET_CADET_Handle *h = cls;
693  struct GNUNET_CADET_Channel *ch;
694 
695  ch = find_channel(h, message->ccn);
696  if (NULL == ch)
697  {
699  "ACK on unknown channel %X\n",
700  ntohl(message->ccn.channel_of_client));
701  return;
702  }
703  ch->allow_send++;
705  "Got an ACK on mq channel %X (peer %s); new window size is %u!\n",
706  ntohl(ch->ccn.channel_of_client),
707  GNUNET_i2s(&ch->peer),
708  ch->allow_send);
709  if (NULL == ch->pending_env)
710  {
712  "Got an ACK on mq channel %X, allow send now %u!\n",
713  ntohl(ch->ccn.channel_of_client),
714  ch->allow_send);
715  notify_window_size(ch);
716  return;
717  }
718  if (NULL != ch->mq_cont)
719  return; /* already working on it! */
721 }
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:110
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:369
struct GNUNET_PeerIdentity peer
Other end of the channel.
Definition: cadet_api.c:83
Opaque handle to a channel.
Definition: cadet_api.c:79
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet_api.c:136
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:354
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:109
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:131
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:209
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:1264
#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:221
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:116
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 734 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().

735 {
736  /* struct GNUNET_CADET_Handle *handle = cls; */
737  struct GNUNET_CADET_Channel *ch = value;
738 
739  (void)cls;
740  (void)cid;
742  "Destroying channel due to GNUNET_CADET_disconnect()\n");
743  destroy_channel(ch);
744  return GNUNET_OK;
745 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
Opaque handle to a channel.
Definition: cadet_api.c:79
#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:267
#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 757 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().

758 {
759  struct GNUNET_CADET_Handle *h = cls;
760 
761  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error);
763  GNUNET_MQ_destroy(h->mq);
764  h->mq = NULL;
765  GNUNET_assert(NULL == h->reconnect_task);
766  h->reconnect_task =
768 }
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:337
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: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:1237
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:42
struct GNUNET_TIME_Relative reconnect_time
Time to the next reconnect in case one reconnect fails.
Definition: cadet_api.c:72
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:734
#define GNUNET_log(kind,...)
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:821
struct GNUNET_SCHEDULER_Task * reconnect_task
Task for trying to reconnect.
Definition: cadet_api.c:67
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Channels open.
Definition: cadet_api.c:52
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 815 of file cadet_api.c.

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

Referenced by GNUNET_CADET_disconnect().

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