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_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...
 
static void return_agpl (void *cls, const struct GNUNET_MessageHeader *msg)
 Function to return link to AGPL source upon request. 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 131 of file cadet_api.c.

References GNUNET_CONTAINER_multihashmap_get(), and GNUNET_CADET_Handle::ports.

Referenced by handle_channel_created().

133 {
134  return GNUNET_CONTAINER_multihashmap_get (h->ports, hash);
135 }
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 146 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().

148 {
150  ntohl (ccn.channel_of_client));
151 }
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: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 162 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().

164 {
165  struct GNUNET_CADET_Channel *ch;
167 
168  ch = GNUNET_new (struct GNUNET_CADET_Channel);
169  ch->cadet = h;
170  if (NULL == ccnp)
171  {
172  while (NULL != find_channel (h, h->next_ccn))
175  | (1 + ntohl (h->next_ccn.channel_of_client)));
176  ccn = h->next_ccn;
177  }
178  else
179  {
180  ccn = *ccnp;
181  }
182  ch->ccn = ccn;
185  h->channels,
186  ntohl (ch->ccn.channel_of_client),
187  ch,
189  return ch;
190 }
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.h:116
#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:146
Number uniquely identifying a channel of a client.
Definition: cadet.h:101
#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 204 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().

205 {
206  struct GNUNET_CADET_Handle *h = ch->cadet;
207 
209  "Destroying channel %X of %p\n",
210  htonl (ch->ccn.channel_of_client),
211  h);
212  GNUNET_assert (
213  GNUNET_YES ==
215  ntohl (ch->ccn.channel_of_client),
216  ch));
217  if (NULL != ch->mq_cont)
218  {
220  ch->mq_cont = NULL;
221  }
222  /* signal channel destruction */
223  if (NULL != ch->disconnects)
224  ch->disconnects (ch->ctx, ch);
225  if (NULL != ch->pending_env)
227  GNUNET_MQ_destroy (ch->mq);
228  GNUNET_free (ch);
229 }
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet.h:165
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:99
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet.h:148
struct GNUNET_CADET_ClientChannelNumber ccn
Local ID of the channel, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI bit is set if outbound.
Definition: cadet.h:170
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.h:138
#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:323
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet.h:143
struct GNUNET_CADET_Handle * cadet
Handle to the cadet this channel belongs to.
Definition: cadet.h:127
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.h:155
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
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:972
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 715 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().

716 {
718  { GNUNET_MQ_hd_fixed_size (channel_created,
721  h),
725  h),
726  GNUNET_MQ_hd_var_size (local_data,
728  struct GNUNET_CADET_LocalData,
729  h),
730  GNUNET_MQ_hd_fixed_size (local_ack,
732  struct GNUNET_CADET_LocalAck,
733  h),
735 
736  GNUNET_assert (NULL == h->mq);
737  h->mq =
738  GNUNET_CLIENT_connect (h->cfg, "cadet", handlers, &handle_mq_error, h);
739 }
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:280
static void channel_destroy(struct CadetChannel *ch)
Destroy the given channel.
Message for or to a client to destroy tunnel.
Definition: cadet.h:235
#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:1063
#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:694
#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:201
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA
Payload client <-> service.
Message for cadet data traffic.
Definition: cadet.h:252
#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 252 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().

253 {
254  struct GNUNET_CADET_Handle *h = cls;
255  struct GNUNET_CADET_Port *port = value;
257  struct GNUNET_MQ_Envelope *env;
258 
259  (void) id;
261  msg->port = port->id;
262  GNUNET_MQ_send (h->mq, env);
263  return GNUNET_OK;
264 }
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:181
struct GNUNET_HashCode id
Port "number".
Definition: cadet_api.c:84
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
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:194
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static uint16_t port
Port number.
Definition: gnunet-bcd.c:82
Opaque handle to a port.
Definition: cadet_api.c:79
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:355
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 274 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().

275 {
276  struct GNUNET_CADET_Handle *h = cls;
277 
278  h->reconnect_task = NULL;
280  reconnect (h);
282 }
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:252
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:715
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 291 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().

292 {
293  if (NULL != ch->window_changes)
294  ch->window_changes (ch->ctx,
295  ch, /* FIXME: remove 'ch'? */
296  ch->allow_send);
297 }
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet.h:175
void * ctx
Any data the caller wants to put in here, used for the various callbacks (disconnects, window_changes, handlers).
Definition: cadet.h:138
GNUNET_CADET_WindowSizeEventHandler window_changes
Window change handler.
Definition: cadet.h:160
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 306 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().

307 {
308  struct GNUNET_CADET_Channel *ch = cls;
309  struct GNUNET_MQ_Envelope *env = ch->pending_env;
310 
311  ch->mq_cont = NULL;
312  if (0 == ch->allow_send)
313  {
314  /* how did we get here? */
315  GNUNET_break (0);
316  return;
317  }
318  if (NULL == env)
319  {
320  /* how did we get here? */
321  GNUNET_break (0);
322  return;
323  }
324  ch->allow_send--;
325  ch->pending_env = NULL;
327  "Sending message on channel %s to CADET, new window size is %u\n",
328  GNUNET_i2s (&ch->peer),
329  ch->allow_send);
330  GNUNET_MQ_send (ch->cadet->mq, env);
332 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
struct GNUNET_PeerIdentity peer
Other end of the channel.
Definition: cadet.h:122
Opaque handle to a channel.
Definition: cadet.h:116
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet.h:175
#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.h:148
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.h:143
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_CADET_Handle * cadet
Handle to the cadet this channel belongs to.
Definition: cadet.h:127
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.h:155
#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:355
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:499
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 348 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().

351 {
352  struct GNUNET_CADET_Channel *ch = impl_state;
353  struct GNUNET_CADET_Handle *h = ch->cadet;
354  uint16_t msize;
355  struct GNUNET_MQ_Envelope *orig_env;
356  struct GNUNET_MQ_Envelope *env;
357  struct GNUNET_CADET_LocalData *cadet_msg;
359 
360  if (NULL == h->mq)
361  {
362  /* We're currently reconnecting, pretend this worked */
364  return;
365  }
366  orig_env = GNUNET_MQ_get_current_envelope (mq);
367  pp = GNUNET_MQ_env_get_options (orig_env);
368 
369  /* check message size for sanity */
370  msize = ntohs (msg->size);
372  {
373  GNUNET_break (0);
375  return;
376  }
377  env = GNUNET_MQ_msg_nested_mh (cadet_msg,
379  msg);
380  cadet_msg->ccn = ch->ccn;
381  cadet_msg->pp = htonl ((uint32_t) pp);
382  GNUNET_assert (NULL == ch->pending_env);
383  ch->pending_env = env;
384  if (0 < ch->allow_send)
386 }
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:306
Opaque handle to a channel.
Definition: cadet.h:116
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.h:175
#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.h:148
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:1037
struct GNUNET_CADET_ClientChannelNumber ccn
Local ID of the channel, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI bit is set if outbound.
Definition: cadet.h:170
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:1296
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel.
Definition: cadet.h:262
#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.h:127
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.h:155
#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:991
Message for cadet data traffic.
Definition: cadet.h:252
uint32_t pp
Priority and preferences (an enum GNUNET_MQ_PriorityPreferences) of the message in NBO...
Definition: cadet.h:268
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:499
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 397 of file cadet_api.c.

References ch, GNUNET_assert, and GNUNET_CADET_Channel::mq.

Referenced by GNUNET_CADET_channel_create(), and handle_channel_created().

398 {
399  struct GNUNET_CADET_Channel *ch = impl_state;
400 
401  GNUNET_assert (mq == ch->mq);
402  ch->mq = NULL;
403 }
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.h:116
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet.h:143
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 415 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().

416 {
417  struct GNUNET_CADET_Channel *ch = cls;
418 
419  if (GNUNET_MQ_ERROR_NO_MATCH == error)
420  {
421  /* Got a message we did not understand, still try to continue! */
422  GNUNET_break_op (0);
424  }
425  else
426  {
428  "MQ error in communication with CADET: %d\n",
429  error);
430  if (NULL != ch->disconnects)
431  ch->disconnects (ch->ctx, ch);
433  }
434 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet.h:165
We received a message for which we have no matching handler.
Opaque handle to a channel.
Definition: cadet.h:116
#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.h:138
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:888
#define GNUNET_log(kind,...)
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:837
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 445 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().

446 {
447  struct GNUNET_CADET_Channel *ch = impl_state;
448 
449  (void) mq;
450  GNUNET_assert (NULL != ch->pending_env);
452  ch->pending_env = NULL;
453  if (NULL != ch->mq_cont)
454  {
456  ch->mq_cont = NULL;
457  }
458 }
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.h:116
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet.h:148
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:323
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.h:155
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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 468 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_Port::disconnects, GNUNET_CADET_Channel::disconnects, env, find_port(), GNUNET_assert, GNUNET_break, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY, GNUNET_MQ_msg, GNUNET_MQ_queue_for_callbacks(), GNUNET_MQ_send(), GNUNET_MQ_set_handlers_closure(), 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_Port::window_changes, and GNUNET_CADET_Channel::window_changes.

471 {
472  struct GNUNET_CADET_Handle *h = cls;
473  struct GNUNET_CADET_Channel *ch;
474  struct GNUNET_CADET_Port *port;
475  const struct GNUNET_HashCode *port_number;
477 
478  ccn = msg->ccn;
479  port_number = &msg->port;
480  if (ntohl (ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
481  {
482  GNUNET_break (0);
483  return;
484  }
485  port = find_port (h, port_number);
486  if (NULL == port)
487  {
488  /* We could have closed the port but the service didn't know about it yet
489  * This is not an error.
490  */
492  struct GNUNET_MQ_Envelope *env;
493 
495  "No handler for incoming channel %X (on port %s, recently closed?)\n",
496  ntohl (ccn.channel_of_client),
497  GNUNET_h2s (port_number));
498  env =
500  d_msg->ccn = msg->ccn;
501  GNUNET_MQ_send (h->mq, env);
502  return;
503  }
504 
505  ch = create_channel (h, &ccn);
506  ch->peer = msg->peer;
507  ch->incoming_port = port;
509  "Creating incoming channel %X [%s] %p\n",
510  ntohl (ccn.channel_of_client),
511  GNUNET_h2s (port_number),
512  ch);
513 
514  GNUNET_assert (NULL != port->connects);
515  ch->window_changes = port->window_changes;
516  ch->disconnects = port->disconnects;
520  ch,
521  port->handlers,
523  ch);
524  ch->ctx = port->connects (port->cls, ch, &msg->peer);
526 }
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:114
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:213
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet.h:165
Message for or to a client to destroy tunnel.
Definition: cadet.h:235
#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:109
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:397
#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.h:122
Opaque handle to a channel.
Definition: cadet.h:116
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:99
#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:596
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:565
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:162
void * ctx
Any data the caller wants to put in here, used for the various callbacks (disconnects, window_changes, handlers).
Definition: cadet.h:138
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:43
Number uniquely identifying a channel of a client.
Definition: cadet.h:101
#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:94
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:348
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:445
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet.h:143
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:245
static uint16_t port
Port number.
Definition: gnunet-bcd.c:82
struct GNUNET_MQ_MessageHandler * handlers
Payload handlers for incoming channels.
Definition: cadet_api.c:119
GNUNET_CADET_WindowSizeEventHandler window_changes
Window change handler.
Definition: cadet.h:160
struct GNUNET_CADET_Port * incoming_port
Channel&#39;s port, if incoming.
Definition: cadet.h:132
Opaque handle to a port.
Definition: cadet_api.c:79
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:131
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:415
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:355
struct GNUNET_PeerIdentity peer
Channel&#39;s peer.
Definition: cadet.h:218
struct GNUNET_HashCode port
Port of the channel.
Definition: cadet.h:223
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 536 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.

539 {
540  struct GNUNET_CADET_Handle *h = cls;
541  struct GNUNET_CADET_Channel *ch;
542 
543  ch = find_channel (h, msg->ccn);
544  if (NULL == ch)
545  {
547  "Received channel destroy for unknown channel %X from CADET service (recently close?)\n",
548  ntohl (msg->ccn.channel_of_client));
549  return;
550  }
552  "Received channel destroy for channel %X from CADET service\n",
553  ntohl (msg->ccn.channel_of_client));
554  destroy_channel (ch);
555 }
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.h:116
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:146
#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:204
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:245
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 567 of file cadet_api.c.

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

568 {
569  uint16_t size;
570 
571  (void) cls;
572  size = ntohs (message->header.size);
573  if (sizeof(*message) + sizeof(struct GNUNET_MessageHeader) > size)
574  {
575  GNUNET_break (0);
576  return GNUNET_SYSERR;
577  }
578  return GNUNET_OK;
579 }
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...
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:257

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

590 {
591  struct GNUNET_CADET_Handle *h = cls;
592  const struct GNUNET_MessageHeader *payload;
593  struct GNUNET_CADET_Channel *ch;
594  uint16_t type;
595  int fwd;
596 
597  ch = find_channel (h, message->ccn);
598  if (NULL == ch)
599  {
601  "Unknown channel %X for incoming data (recently closed?)\n",
602  ntohl (message->ccn.channel_of_client));
603  return;
604  }
605 
606  payload = (const struct GNUNET_MessageHeader *) &message[1];
607  type = ntohs (payload->type);
610  "Got a %s data on channel %s [%X] of type %u\n",
611  fwd ? "FWD" : "BWD",
612  GNUNET_i2s (&ch->peer),
613  ntohl (message->ccn.channel_of_client),
614  type);
615  GNUNET_MQ_inject_message (ch->mq, payload);
616 }
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.h:122
Opaque handle to a channel.
Definition: cadet.h:116
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.h:170
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:146
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:262
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet.h:143
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 627 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.

628 {
629  struct GNUNET_CADET_Handle *h = cls;
630  struct GNUNET_CADET_Channel *ch;
631 
632  ch = find_channel (h, message->ccn);
633  if (NULL == ch)
634  {
636  "ACK on unknown channel %X\n",
637  ntohl (message->ccn.channel_of_client));
638  return;
639  }
640  ch->allow_send++;
642  "Got an ACK on mq channel %X (peer %s); new window size is %u!\n",
643  ntohl (ch->ccn.channel_of_client),
644  GNUNET_i2s (&ch->peer),
645  ch->allow_send);
646  if (NULL == ch->pending_env)
647  {
649  "Got an ACK on mq channel %X, allow send now %u!\n",
650  ntohl (ch->ccn.channel_of_client),
651  ch->allow_send);
652  notify_window_size (ch);
653  return;
654  }
655  if (NULL != ch->mq_cont)
656  return; /* already working on it! */
658 }
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:306
struct GNUNET_PeerIdentity peer
Other end of the channel.
Definition: cadet.h:122
Opaque handle to a channel.
Definition: cadet.h:116
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet.h:175
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:291
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.h:148
struct GNUNET_CADET_ClientChannelNumber ccn
Local ID of the channel, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI bit is set if outbound.
Definition: cadet.h:170
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:146
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:1296
#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:290
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.h:155
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 671 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().

672 {
673  /* struct GNUNET_CADET_Handle *handle = cls; */
674  struct GNUNET_CADET_Channel *ch = value;
675 
676  (void) cls;
677  (void) cid;
679  "Destroying channel due to GNUNET_CADET_disconnect()\n");
680  destroy_channel (ch);
681  return GNUNET_OK;
682 }
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
Opaque handle to a channel.
Definition: cadet.h:116
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:204
#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 694 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().

695 {
696  struct GNUNET_CADET_Handle *h = cls;
697 
698  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error);
700  GNUNET_MQ_destroy (h->mq);
701  h->mq = NULL;
702  GNUNET_assert (NULL == h->reconnect_task);
703  h->reconnect_task =
705 }
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:274
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:1269
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:671
#define GNUNET_log(kind,...)
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
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 752 of file cadet_api.c.

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

Referenced by GNUNET_CADET_disconnect().

753 {
754  /* struct GNUNET_CADET_Handle *handle = cls; */
755  struct GNUNET_CADET_Port *port = value;
756 
757  (void) cls;
758  (void) id;
759  /* This is a warning, the app should have cleanly closed all open ports */
760  GNUNET_break (0);
762  return GNUNET_OK;
763 }
#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:94
static uint16_t port
Port number.
Definition: gnunet-bcd.c:82
Opaque handle to a port.
Definition: cadet_api.c:79
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:808
Here is the call graph for this function:
Here is the caller graph for this function:

◆ return_agpl()

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

Function to return link to AGPL source upon request.

Parameters
clsclosure with the identification of the client
msgAGPL request

Definition at line 938 of file cadet_api.c.

References GNUNET_OS_ProjectData::agpl_url, env, GNUNET_AGPL_URL, GNUNET_MESSAGE_TYPE_RESPONSE_AGPL, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_OS_project_data_get(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), GNUNET_CADET_Handle::mq, and res.

Referenced by GNUNET_CADET_open_port().

939 {
940  struct GNUNET_SERVICE_Client *client = cls;
941  struct GNUNET_MQ_Handle *mq;
942  struct GNUNET_MQ_Envelope *env;
943  struct GNUNET_MessageHeader *res;
944  size_t slen;
946 
947  (void) msg;
948  slen = strlen (pd->agpl_url) + 1;
950  memcpy (&res[1], GNUNET_AGPL_URL, slen);
951  mq = GNUNET_SERVICE_client_get_mq (client);
952  GNUNET_MQ_send (mq, env);
954 }
Project-specific data used to help the OS subsystem find installation paths.
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2436
Handle to a client that is connected to a service.
Definition: service.c:250
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
char * agpl_url
URL pointing to the source code of the application.
static int res
#define GNUNET_MESSAGE_TYPE_RESPONSE_AGPL
Source code link.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
Handle to a message queue.
Definition: mq.c:85
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
const struct GNUNET_OS_ProjectData * GNUNET_OS_project_data_get(void)
#define GNUNET_AGPL_URL
NOTE: You MUST adjust this URL to point to the location of a publicly accessible repository (or TGZ) ...
Header for all communications.
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:355
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2242
Here is the call graph for this function:
Here is the caller graph for this function: