GNUnet  0.11.x
Data Structures | Macros | Functions | Variables
gnunet-service-fs_cadet_client.c File Reference

non-anonymous file-transfer More...

#include "platform.h"
#include "gnunet_constants.h"
#include "gnunet_util_lib.h"
#include "gnunet_cadet_service.h"
#include "gnunet_protocols.h"
#include "gnunet_applications.h"
#include "gnunet-service-fs.h"
#include "gnunet-service-fs_indexing.h"
#include "gnunet-service-fs_cadet.h"
Include dependency graph for gnunet-service-fs_cadet_client.c:

Go to the source code of this file.

Data Structures

struct  GSF_CadetRequest
 Handle for a request that is going out via cadet API. More...
 
struct  CadetHandle
 Handle for a cadet to another peer. More...
 
struct  HandleReplyClosure
 Closure for handle_reply(). More...
 

Macros

#define CLIENT_RETRY_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
 After how long do we reset connections without replies? More...
 

Functions

static void transmit_pending (void *cls)
 Transmit pending requests via the cadet. More...
 
static int move_to_pending (void *cls, const struct GNUNET_HashCode *key, void *value)
 Iterator called on each entry in a waiting map to move it back to the pending list. More...
 
static int check_reply (void *cls, const struct CadetReplyMessage *srm)
 Functions with this signature are called whenever a complete reply is received. More...
 
static void reset_cadet_task (void *cls)
 Task called when it is time to reset an cadet. More...
 
static void reset_cadet_async (struct CadetHandle *mh)
 We had a serious error, tear down and re-create cadet from scratch, but do so asynchronously. More...
 
static int process_reply (void *cls, const struct GNUNET_HashCode *key, void *value)
 Iterator called on each entry in a waiting map to process a result. More...
 
static int free_waiting_entry (void *cls, const struct GNUNET_HashCode *key, void *value)
 Iterator called on each entry in a waiting map to call the 'proc' continuation and release associated resources. More...
 
static void handle_reply (void *cls, const struct CadetReplyMessage *srm)
 Functions with this signature are called whenever a complete reply is received. More...
 
static void disconnect_cb (void *cls, const struct GNUNET_CADET_Channel *channel)
 Function called by cadet when a client disconnects. More...
 
static void window_change_cb (void *cls, const struct GNUNET_CADET_Channel *channel, int window_size)
 Function called whenever an MQ-channel's transmission window size changes. More...
 
static void reset_cadet (struct CadetHandle *mh)
 We had a serious error, tear down and re-create cadet from scratch. More...
 
static void cadet_timeout (void *cls)
 Task called when it is time to destroy an inactive cadet channel. More...
 
static struct CadetHandleget_cadet (const struct GNUNET_PeerIdentity *target)
 Get (or create) a cadet to talk to the given peer. More...
 
struct GSF_CadetRequestGSF_cadet_query (const struct GNUNET_PeerIdentity *target, const struct GNUNET_HashCode *query, enum GNUNET_BLOCK_Type type, GSF_CadetReplyProcessor proc, void *proc_cls)
 Look for a block by directly contacting a particular peer. More...
 
void GSF_cadet_query_cancel (struct GSF_CadetRequest *sr)
 Cancel an active request; must not be called after 'proc' was calld. More...
 
int GSF_cadet_release_clients (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 Function called on each active cadets to shut them down. More...
 

Variables

struct GNUNET_CADET_Handlecadet_handle
 Cadet channel for creating outbound channels. More...
 
struct GNUNET_CONTAINER_MultiPeerMapcadet_map
 Map from peer identities to 'struct CadetHandles' with cadet channels to those peers. More...
 

Detailed Description

non-anonymous file-transfer

Author
Christian Grothoff

TODO:

Definition in file gnunet-service-fs_cadet_client.c.

Macro Definition Documentation

◆ CLIENT_RETRY_TIMEOUT

#define CLIENT_RETRY_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)

After how long do we reset connections without replies?

Definition at line 44 of file gnunet-service-fs_cadet_client.c.

Referenced by get_cadet().

Function Documentation

◆ transmit_pending()

static void transmit_pending ( void *  cls)
static

Transmit pending requests via the cadet.

Parameters
clsstruct CadetHandle to process

Definition at line 528 of file gnunet-service-fs_cadet_client.c.

References CadetHandle::channel, env, GNUNET_assert, GNUNET_CADET_get_mq(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_FS_CADET_QUERY, GNUNET_MQ_env_set_options(), GNUNET_MQ_get_length(), GNUNET_MQ_msg, GNUNET_MQ_notify_sent(), GNUNET_MQ_PREF_CORK_ALLOWED, GNUNET_MQ_PREF_GOODPUT, GNUNET_MQ_PREF_OUT_OF_ORDER, GNUNET_MQ_send(), GNUNET_OK, GNUNET_YES, GSF_CadetRequest::mh, mq, CadetHandle::pending_head, CadetHandle::pending_tail, GSF_CadetRequest::query, CadetQueryMessage::query, CadetHandle::target, GSF_CadetRequest::type, CadetQueryMessage::type, CadetHandle::waiting_map, and GSF_CadetRequest::was_transmitted.

Referenced by GSF_cadet_query(), reset_cadet(), and window_change_cb().

529 {
530  struct CadetHandle *mh = cls;
532  struct GSF_CadetRequest *sr;
533  struct GNUNET_MQ_Envelope *env;
534  struct CadetQueryMessage *sqm;
535 
536  if ((0 != GNUNET_MQ_get_length (mq)) || (NULL == (sr = mh->pending_head)))
537  return;
540  mh->waiting_map,
541  &sr->query,
542  sr,
546  "Sending query for %s via cadet to %s\n",
547  GNUNET_h2s (&sr->query),
548  GNUNET_i2s (&mh->target));
554  sqm->type = htonl (sr->type);
555  sqm->query = sr->query;
557  GNUNET_MQ_send (mq, env);
558 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Query from one peer, asking the other for CHK-data.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
Handle for a cadet to another peer.
void GNUNET_MQ_env_set_options(struct GNUNET_MQ_Envelope *env, enum GNUNET_MQ_PriorityPreferences pp)
Set application-specific options for this envelope.
Definition: mq.c:1005
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
uint32_t type
Block type must be DBLOCK or IBLOCK.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_HashCode query
Query to transmit to the other peer.
Flag to indicate that high bandwidth is desired.
struct GNUNET_HashCode query
Query hash from CHK (hash of encrypted block).
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore...
Definition: mq.c:774
int was_transmitted
Did we transmit this request already? GNUNET_YES if we are in the 'waiting_map', GNUNET_NO if we are ...
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition: mq.c:335
struct GNUNET_PeerIdentity target
Which peer does this cadet go to?
Handle for a request that is going out via cadet API.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
Allow multiple values with the same key.
Handle to a message queue.
Definition: mq.c:85
struct GNUNET_CADET_Channel * channel
Channel to the other peer.
struct GSF_CadetRequest * pending_head
Head of DLL of pending requests on this cadet.
struct GSF_CadetRequest * pending_tail
Tail of DLL of pending requests on this cadet.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_MESSAGE_TYPE_FS_CADET_QUERY
P2P request for content (one FS to another via a cadet).
#define GNUNET_log(kind,...)
Flag to indicate that out-of-order delivery is OK.
Flag to indicate that CORKing is acceptable.
#define GNUNET_YES
Definition: gnunet_common.h:77
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
static void transmit_pending(void *cls)
Transmit pending requests via the cadet.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_CONTAINER_MultiHashMap * waiting_map
Map from query to struct GSF_CadetRequests waiting for a reply.
enum GNUNET_BLOCK_Type type
Desired type for the reply.
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected peer.
Definition: cadet_api.c:1119
Here is the call graph for this function:
Here is the caller graph for this function:

◆ move_to_pending()

static int move_to_pending ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Iterator called on each entry in a waiting map to move it back to the pending list.

Parameters
clsthe struct CadetHandle
keythe key of the entry in the map (the query)
valuethe struct GSF_CadetRequest to move to pending
Returns
GNUNET_YES (continue to iterate)

Definition at line 183 of file gnunet-service-fs_cadet_client.c.

References GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_NO, GNUNET_YES, GSF_CadetRequest::mh, CadetHandle::pending_head, CadetHandle::pending_tail, value, CadetHandle::waiting_map, and GSF_CadetRequest::was_transmitted.

Referenced by reset_cadet().

184 {
185  struct CadetHandle *mh = cls;
186  struct GSF_CadetRequest *sr = value;
187 
188  GNUNET_assert (
189  GNUNET_YES ==
193  return GNUNET_YES;
194 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
Handle for a cadet to another peer.
#define GNUNET_NO
Definition: gnunet_common.h:78
static char * value
Value of the record to add/remove.
int was_transmitted
Did we transmit this request already? GNUNET_YES if we are in the 'waiting_map', GNUNET_NO if we are ...
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
Handle for a request that is going out via cadet API.
struct GSF_CadetRequest * pending_head
Head of DLL of pending requests on this cadet.
struct GSF_CadetRequest * pending_tail
Tail of DLL of pending requests on this cadet.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_CONTAINER_MultiHashMap * waiting_map
Map from query to struct GSF_CadetRequests waiting for a reply.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_reply()

static int check_reply ( void *  cls,
const struct CadetReplyMessage srm 
)
static

Functions with this signature are called whenever a complete reply is received.

Parameters
clsclosure with the struct CadetHandle
srmthe actual message
Returns
GNUNET_OK on success, GNUNET_SYSERR to stop further processing

Definition at line 206 of file gnunet-service-fs_cadet_client.c.

References GNUNET_OK, and reset_cadet_task().

207 {
208  /* We check later... */
209  return GNUNET_OK;
210 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Here is the call graph for this function:

◆ reset_cadet_task()

static void reset_cadet_task ( void *  cls)
static

Task called when it is time to reset an cadet.

Parameters
clsthe struct CadetHandle to tear down

Definition at line 513 of file gnunet-service-fs_cadet_client.c.

References GSF_CadetRequest::mh, reset_cadet(), and CadetHandle::reset_task.

Referenced by check_reply(), get_cadet(), and reset_cadet_async().

514 {
515  struct CadetHandle *mh = cls;
516 
517  mh->reset_task = NULL;
518  reset_cadet (mh);
519 }
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
Handle for a cadet to another peer.
struct GNUNET_SCHEDULER_Task * reset_task
Task to reset cadets that had errors (asynchronously, as we may not be able to do it immediately duri...
static void reset_cadet(struct CadetHandle *mh)
We had a serious error, tear down and re-create cadet from scratch.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ reset_cadet_async()

static void reset_cadet_async ( struct CadetHandle mh)
static

We had a serious error, tear down and re-create cadet from scratch, but do so asynchronously.

Parameters
mhcadet to reset

Definition at line 229 of file gnunet-service-fs_cadet_client.c.

References GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), reset_cadet_task(), and CadetHandle::reset_task.

Referenced by handle_reply().

230 {
231  if (NULL != mh->reset_task)
234 }
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
static void reset_cadet_task(void *cls)
Task called when it is time to reset an cadet.
struct GNUNET_SCHEDULER_Task * reset_task
Task to reset cadets that had errors (asynchronously, as we may not be able to do it immediately duri...
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_reply()

static int process_reply ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Iterator called on each entry in a waiting map to process a result.

Parameters
clsthe struct HandleReplyClosure
keythe key of the entry in the map (the query)
valuethe struct GSF_CadetRequest to handle result for
Returns
GNUNET_YES (continue to iterate)

Definition at line 279 of file gnunet-service-fs_cadet_client.c.

References HandleReplyClosure::data, HandleReplyClosure::data_size, HandleReplyClosure::expiration, HandleReplyClosure::found, GNUNET_YES, GSF_cadet_query_cancel(), GSF_CadetRequest::proc, GSF_CadetRequest::proc_cls, HandleReplyClosure::type, and value.

Referenced by handle_reply().

280 {
281  struct HandleReplyClosure *hrc = cls;
282  struct GSF_CadetRequest *sr = value;
283 
284  sr->proc (sr->proc_cls,
285  hrc->type,
286  hrc->expiration,
287  hrc->data_size,
288  hrc->data);
289  sr->proc = NULL;
291  hrc->found = GNUNET_YES;
292  return GNUNET_YES;
293 }
struct GNUNET_TIME_Absolute expiration
Expiration time for the block.
int found
Did we have a matching query?
const void * data
Reply payload.
static char * value
Value of the record to add/remove.
void * proc_cls
Closure for proc.
Closure for handle_reply().
Handle for a request that is going out via cadet API.
GSF_CadetReplyProcessor proc
Function to call with the result.
#define GNUNET_YES
Definition: gnunet_common.h:77
enum GNUNET_BLOCK_Type type
Type of the block.
size_t data_size
Number of bytes in data.
void GSF_cadet_query_cancel(struct GSF_CadetRequest *sr)
Cancel an active request; must not be called after 'proc' was calld.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ free_waiting_entry()

static int free_waiting_entry ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Iterator called on each entry in a waiting map to call the 'proc' continuation and release associated resources.

Parameters
clsthe struct CadetHandle
keythe key of the entry in the map (the query)
valuethe struct GSF_CadetRequest to clean up
Returns
GNUNET_YES (continue to iterate)

Definition at line 307 of file gnunet-service-fs_cadet_client.c.

References GNUNET_YES, GSF_cadet_query_cancel(), and value.

Referenced by disconnect_cb().

308 {
309  struct GSF_CadetRequest *sr = value;
310 
312  return GNUNET_YES;
313 }
static char * value
Value of the record to add/remove.
Handle for a request that is going out via cadet API.
#define GNUNET_YES
Definition: gnunet_common.h:77
void GSF_cadet_query_cancel(struct GSF_CadetRequest *sr)
Cancel an active request; must not be called after 'proc' was calld.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_reply()

static void handle_reply ( void *  cls,
const struct CadetReplyMessage srm 
)
static

Functions with this signature are called whenever a complete reply is received.

Parameters
clsclosure with the struct CadetHandle
srmthe actual message

Definition at line 324 of file gnunet-service-fs_cadet_client.c.

References CadetHandle::channel, HandleReplyClosure::data, HandleReplyClosure::data_size, CadetReplyMessage::expiration, HandleReplyClosure::expiration, HandleReplyClosure::found, gettext_noop, GNUNET_BLOCK_get_key(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, GSF_block_ctx, GSF_stats, CadetReplyMessage::header, GSF_CadetRequest::mh, process_reply(), reset_cadet_async(), GNUNET_MessageHeader::size, CadetHandle::target, GSF_CadetRequest::type, CadetReplyMessage::type, HandleReplyClosure::type, and CadetHandle::waiting_map.

325 {
326  struct CadetHandle *mh = cls;
327  struct HandleReplyClosure hrc;
328  uint16_t msize;
329  enum GNUNET_BLOCK_Type type;
330  struct GNUNET_HashCode query;
331 
332  msize = ntohs (srm->header.size) - sizeof(struct CadetReplyMessage);
333  type = (enum GNUNET_BLOCK_Type) ntohl (srm->type);
334  if (GNUNET_YES !=
335  GNUNET_BLOCK_get_key (GSF_block_ctx, type, &srm[1], msize, &query))
336  {
337  GNUNET_break_op (0);
338  GNUNET_log (
340  "Received bogus reply of type %u with %u bytes via cadet from peer %s\n",
341  type,
342  msize,
343  GNUNET_i2s (&mh->target));
344  reset_cadet_async (mh);
345  return;
346  }
348  "Received reply `%s' via cadet from peer %s\n",
349  GNUNET_h2s (&query),
350  GNUNET_i2s (&mh->target));
353  gettext_noop ("# replies received via cadet"),
354  1,
355  GNUNET_NO);
356  hrc.data = &srm[1];
357  hrc.data_size = msize;
359  hrc.type = type;
360  hrc.found = GNUNET_NO;
362  &query,
363  &process_reply,
364  &hrc);
365  if (GNUNET_NO == hrc.found)
366  {
368  gettext_noop (
369  "# replies received via cadet dropped"),
370  1,
371  GNUNET_NO);
372  }
373 }
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:673
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique type.
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
Handle for a cadet to another peer.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_FS_CADET_REPLY.
static int process_reply(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator called on each entry in a waiting map to process a result.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_NO
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
int GNUNET_BLOCK_get_key(struct GNUNET_BLOCK_Context *ctx, enum GNUNET_BLOCK_Type type, const void *block, size_t block_size, struct GNUNET_HashCode *key)
Function called to obtain the key for a block.
Definition: block.c:378
static void reset_cadet_async(struct CadetHandle *mh)
We had a serious error, tear down and re-create cadet from scratch, but do so asynchronously.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_BLOCK_Context * GSF_block_ctx
Our block context.
Closure for handle_reply().
struct GNUNET_PeerIdentity target
Which peer does this cadet go to?
A 512-bit hashcode.
struct GNUNET_TIME_AbsoluteNBO expiration
Expiration time for the block.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:954
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
struct GNUNET_CADET_Channel * channel
Channel to the other peer.
#define GNUNET_log(kind,...)
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
#define GNUNET_YES
Definition: gnunet_common.h:77
uint32_t type
Block type must be DBLOCK or IBLOCK.
Reply to a CadetQueryMessage.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_CONTAINER_MultiHashMap * waiting_map
Map from query to struct GSF_CadetRequests waiting for a reply.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:

◆ disconnect_cb()

static void disconnect_cb ( void *  cls,
const struct GNUNET_CADET_Channel channel 
)
static

Function called by cadet when a client disconnects.

Cleans up our struct CadetClient of that channel.

Parameters
clsour struct CadetClient
channelchannel of the disconnecting client

Definition at line 384 of file gnunet-service-fs_cadet_client.c.

References CadetHandle::channel, free_waiting_entry(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GSF_cadet_query_cancel(), GSF_CadetRequest::mh, CadetHandle::pending_head, CadetHandle::reset_task, CadetHandle::target, CadetHandle::timeout_task, and CadetHandle::waiting_map.

Referenced by get_cadet(), GNUNET_SERVICE_run_(), GNUNET_SERVICE_start(), and reset_cadet().

385 {
386  struct CadetHandle *mh = cls;
387  struct GSF_CadetRequest *sr;
388 
389  if (NULL == mh->channel)
390  return; /* being destroyed elsewhere */
391  GNUNET_assert (channel == mh->channel);
392  mh->channel = NULL;
393  while (NULL != (sr = mh->pending_head))
395  /* first remove `mh` from the `cadet_map`, so that if the
396  callback from `free_waiting_entry()` happens to re-issue
397  the request, we don't immediately have it back in the
398  `waiting_map`. */
400  &mh->target,
401  mh));
404  mh);
405  if (NULL != mh->timeout_task)
407  if (NULL != mh->reset_task)
411  GNUNET_free (mh);
412 }
struct GNUNET_CONTAINER_MultiPeerMap * cadet_map
Map from peer identities to 'struct CadetHandles' with cadet channels to those peers.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
Handle for a cadet to another peer.
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_PeerIdentity target
Which peer does this cadet go to?
struct GNUNET_SCHEDULER_Task * timeout_task
Task to kill inactive cadets (we keep them around for a few seconds to give the application a chance ...
struct GNUNET_SCHEDULER_Task * reset_task
Task to reset cadets that had errors (asynchronously, as we may not be able to do it immediately duri...
Handle for a request that is going out via cadet API.
struct GNUNET_CADET_Channel * channel
Channel to the other peer.
struct GSF_CadetRequest * pending_head
Head of DLL of pending requests on this cadet.
static int free_waiting_entry(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator called on each entry in a waiting map to call the 'proc' continuation and release associated...
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_CONTAINER_MultiHashMap * waiting_map
Map from query to struct GSF_CadetRequests waiting for a reply.
void GSF_cadet_query_cancel(struct GSF_CadetRequest *sr)
Cancel an active request; must not be called after 'proc' was calld.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
Here is the call graph for this function:
Here is the caller graph for this function:

◆ window_change_cb()

static void window_change_cb ( void *  cls,
const struct GNUNET_CADET_Channel channel,
int  window_size 
)
static

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

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

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

Parameters
clsChannel closure.
channelConnection to the other end (henceforth invalid).
window_sizeNew window size. If the is more messages than buffer size this value will be negative..

Definition at line 430 of file gnunet-service-fs_cadet_client.c.

References GSF_CadetRequest::mh, and transmit_pending().

Referenced by get_cadet(), and reset_cadet().

433 {
434  /* FIXME: for flow control, implement? */
435 #if 0
436  /* Something like this instead of the GNUNET_MQ_notify_sent() in
437  transmit_pending() might be good (once the window change CB works...) */
438  if (0 < window_size) /* test needed? */
440 #endif
441 }
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
static void transmit_pending(void *cls)
Transmit pending requests via the cadet.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ reset_cadet()

static void reset_cadet ( struct CadetHandle mh)
static

We had a serious error, tear down and re-create cadet from scratch.

Parameters
mhcadet to reset

Definition at line 450 of file gnunet-service-fs_cadet_client.c.

References CadetHandle::channel, disconnect_cb(), GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, GNUNET_CADET_channel_create(), GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, move_to_pending(), CadetHandle::target, transmit_pending(), CadetHandle::waiting_map, and window_change_cb().

Referenced by reset_cadet_task().

451 {
453  "Resetting cadet channel to %s\n",
454  GNUNET_i2s (&mh->target));
455  if (NULL != mh->channel)
456  {
458  mh->channel = NULL;
459  }
461  {
463  { GNUNET_MQ_hd_var_size (reply,
465  struct CadetReplyMessage,
466  mh),
468  struct GNUNET_HashCode port;
469 
472  &port);
474  mh,
475  &mh->target,
476  &port,
478  &disconnect_cb,
479  handlers);
480  }
481  transmit_pending (mh);
482 }
static void window_change_cb(void *cls, const struct GNUNET_CADET_Channel *channel, int window_size)
Function called whenever an MQ-channel&#39;s transmission window size changes.
#define GNUNET_MESSAGE_TYPE_FS_CADET_REPLY
P2P answer for content (one FS to another via a cadet).
static void disconnect_cb(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called by cadet when a client disconnects.
static int move_to_pending(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator called on each entry in a waiting map to move it back to the pending list.
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
struct GNUNET_PeerIdentity target
Which peer does this cadet go to?
A 512-bit hashcode.
Message handler for a specific message type.
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1068
static uint16_t port
Port number.
Definition: gnunet-bcd.c:81
struct GNUNET_CADET_Channel * channel
Channel to the other peer.
#define GNUNET_log(kind,...)
#define GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER
Transfer of blocks for non-anonymmous file-sharing.
static void transmit_pending(void *cls)
Transmit pending requests via the cadet.
struct GNUNET_CADET_Handle * cadet_handle
Cadet channel for creating outbound channels.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
Reply to a CadetQueryMessage.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:903
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_CONTAINER_MultiHashMap * waiting_map
Map from query to struct GSF_CadetRequests waiting for a reply.
#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:

◆ cadet_timeout()

static void cadet_timeout ( void *  cls)
static

Task called when it is time to destroy an inactive cadet channel.

Parameters
clsthe struct CadetHandle to tear down

Definition at line 491 of file gnunet-service-fs_cadet_client.c.

References CadetHandle::channel, GNUNET_CADET_channel_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GSF_CadetRequest::mh, CadetHandle::target, and CadetHandle::timeout_task.

Referenced by GSF_cadet_query_cancel().

492 {
493  struct CadetHandle *mh = cls;
494  struct GNUNET_CADET_Channel *tun;
495 
497  "Timeout on cadet channel to %s\n",
498  GNUNET_i2s (&mh->target));
499  mh->timeout_task = NULL;
500  tun = mh->channel;
501  mh->channel = NULL;
502  if (NULL != tun)
504 }
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
Handle for a cadet to another peer.
Opaque handle to a channel.
Definition: cadet_api.c:80
struct GNUNET_PeerIdentity target
Which peer does this cadet go to?
struct GNUNET_SCHEDULER_Task * timeout_task
Task to kill inactive cadets (we keep them around for a few seconds to give the application a chance ...
struct GNUNET_CADET_Channel * channel
Channel to the other peer.
#define GNUNET_log(kind,...)
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:903
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:

◆ get_cadet()

static struct CadetHandle* get_cadet ( const struct GNUNET_PeerIdentity target)
static

Get (or create) a cadet to talk to the given peer.

Parameters
targetpeer we want to communicate with

Definition at line 567 of file gnunet-service-fs_cadet_client.c.

References CadetHandle::channel, CLIENT_RETRY_TIMEOUT, disconnect_cb(), GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, GNUNET_assert, GNUNET_CADET_channel_create(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, GSF_CadetRequest::mh, reset_cadet_task(), CadetHandle::reset_task, CadetHandle::target, CadetHandle::timeout_task, CadetHandle::waiting_map, and window_change_cb().

Referenced by GSF_cadet_query().

568 {
569  struct CadetHandle *mh;
570 
572  if (NULL != mh)
573  {
574  if (NULL != mh->timeout_task)
575  {
577  mh->timeout_task = NULL;
578  }
579  return mh;
580  }
582  "Creating cadet channel to %s\n",
583  GNUNET_i2s (target));
584  mh = GNUNET_new (struct CadetHandle);
585  mh->reset_task =
588  mh->target = *target;
591  cadet_map,
592  &mh->target,
593  mh,
595  {
597  { GNUNET_MQ_hd_var_size (reply,
599  struct CadetReplyMessage,
600  mh),
602  struct GNUNET_HashCode port;
603 
606  &port);
608  mh,
609  &mh->target,
610  &port,
612  &disconnect_cb,
613  handlers);
614  }
615  return mh;
616 }
static void window_change_cb(void *cls, const struct GNUNET_CADET_Channel *channel, int window_size)
Function called whenever an MQ-channel&#39;s transmission window size changes.
#define GNUNET_MESSAGE_TYPE_FS_CADET_REPLY
P2P answer for content (one FS to another via a cadet).
struct GNUNET_CONTAINER_MultiPeerMap * cadet_map
Map from peer identities to &#39;struct CadetHandles&#39; with cadet channels to those peers.
static void disconnect_cb(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called by cadet when a client disconnects.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
Handle for a cadet to another peer.
#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.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
#define CLIENT_RETRY_TIMEOUT
After how long do we reset connections without replies?
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
static void reset_cadet_task(void *cls)
Task called when it is time to reset an cadet.
struct GNUNET_PeerIdentity target
Which peer does this cadet go to?
A 512-bit hashcode.
Message handler for a specific message type.
struct GNUNET_SCHEDULER_Task * timeout_task
Task to kill inactive cadets (we keep them around for a few seconds to give the application a chance ...
struct GNUNET_SCHEDULER_Task * reset_task
Task to reset cadets that had errors (asynchronously, as we may not be able to do it immediately duri...
There must only be one value per key; storing a value should fail if a value under the same key alrea...
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1068
static uint16_t port
Port number.
Definition: gnunet-bcd.c:81
struct GNUNET_CADET_Channel * channel
Channel to the other peer.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
#define GNUNET_log(kind,...)
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER
Transfer of blocks for non-anonymmous file-sharing.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_CADET_Handle * cadet_handle
Cadet channel for creating outbound channels.
Reply to a CadetQueryMessage.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_CONTAINER_MultiHashMap * waiting_map
Map from query to struct GSF_CadetRequests waiting for a reply.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_cadet_query()

struct GSF_CadetRequest* GSF_cadet_query ( const struct GNUNET_PeerIdentity target,
const struct GNUNET_HashCode query,
enum GNUNET_BLOCK_Type  type,
GSF_CadetReplyProcessor  proc,
void *  proc_cls 
)

Look for a block by directly contacting a particular peer.

Parameters
targetpeer that should have the block
queryhash to query for the block
typedesired type for the block
procfunction to call with result
proc_clsclosure for proc
Returns
handle to cancel the operation

Definition at line 630 of file gnunet-service-fs_cadet_client.c.

References get_cadet(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_new, GSF_CadetRequest::mh, CadetHandle::pending_head, CadetHandle::pending_tail, GSF_CadetRequest::proc, GSF_CadetRequest::proc_cls, GSF_CadetRequest::query, transmit_pending(), and GSF_CadetRequest::type.

Referenced by cadet_reply_proc(), and GSF_cadet_lookup_().

635 {
636  struct CadetHandle *mh;
637  struct GSF_CadetRequest *sr;
638 
640  "Preparing to send query for %s via cadet to %s\n",
641  GNUNET_h2s (query),
642  GNUNET_i2s (target));
643  mh = get_cadet (target);
644  sr = GNUNET_new (struct GSF_CadetRequest);
645  sr->mh = mh;
646  sr->proc = proc;
647  sr->proc_cls = proc_cls;
648  sr->type = type;
649  sr->query = *query;
651  transmit_pending (mh);
652  return sr;
653 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
Handle for a cadet to another peer.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_HashCode query
Query to transmit to the other peer.
void * proc_cls
Closure for proc.
Handle for a request that is going out via cadet API.
GSF_CadetReplyProcessor proc
Function to call with the result.
struct GSF_CadetRequest * pending_head
Head of DLL of pending requests on this cadet.
struct GSF_CadetRequest * pending_tail
Tail of DLL of pending requests on this cadet.
#define GNUNET_log(kind,...)
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
static void transmit_pending(void *cls)
Transmit pending requests via the cadet.
struct CadetHandle * mh
Which cadet is this request associated with?
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
enum GNUNET_BLOCK_Type type
Desired type for the reply.
static struct CadetHandle * get_cadet(const struct GNUNET_PeerIdentity *target)
Get (or create) a cadet to talk to the given peer.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_cadet_query_cancel()

void GSF_cadet_query_cancel ( struct GSF_CadetRequest sr)

Cancel an active request; must not be called after 'proc' was calld.

Parameters
srrequest to cancel

Definition at line 663 of file gnunet-service-fs_cadet_client.c.

References cadet_timeout(), GNUNET_assert, GNUNET_BLOCK_TYPE_ANY, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_UNIT_SECONDS, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, GSF_CadetRequest::mh, p, CadetHandle::pending_head, CadetHandle::pending_tail, GSF_CadetRequest::proc, GSF_CadetRequest::proc_cls, GSF_CadetRequest::query, CadetHandle::target, CadetHandle::timeout_task, CadetHandle::waiting_map, and GSF_CadetRequest::was_transmitted.

Referenced by clean_request(), disconnect_cb(), free_waiting_entry(), GSF_pending_request_cancel_(), and process_reply().

664 {
665  struct CadetHandle *mh = sr->mh;
667 
668  p = sr->proc;
669  sr->proc = NULL;
670  if (NULL != p)
671  {
672  /* signal failure / cancellation to callback */
674  }
676  "Cancelled query for %s via cadet to %s\n",
677  GNUNET_h2s (&sr->query),
678  GNUNET_i2s (&sr->mh->target));
679  if (GNUNET_YES == sr->was_transmitted)
680  GNUNET_assert (
681  GNUNET_OK ==
683  else
685  GNUNET_free (sr);
687  (NULL == mh->pending_head))
689  &cadet_timeout,
690  mh);
691 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
Any type of block, used as a wildcard when searching.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
Handle for a cadet to another peer.
#define GNUNET_TIME_UNIT_SECONDS
One second.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct GNUNET_HashCode query
Query to transmit to the other peer.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
int was_transmitted
Did we transmit this request already? GNUNET_YES if we are in the &#39;waiting_map&#39;, GNUNET_NO if we are ...
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
void * proc_cls
Closure for proc.
struct GNUNET_PeerIdentity target
Which peer does this cadet go to?
struct GNUNET_SCHEDULER_Task * timeout_task
Task to kill inactive cadets (we keep them around for a few seconds to give the application a chance ...
GSF_CadetReplyProcessor proc
Function to call with the result.
struct GSF_CadetRequest * pending_head
Head of DLL of pending requests on this cadet.
struct GSF_CadetRequest * pending_tail
Tail of DLL of pending requests on this cadet.
#define GNUNET_log(kind,...)
static void cadet_timeout(void *cls)
Task called when it is time to destroy an inactive cadet channel.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct CadetHandle * mh
Which cadet is this request associated with?
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
struct GNUNET_CONTAINER_MultiHashMap * waiting_map
Map from query to struct GSF_CadetRequests waiting for a reply.
void(* GSF_CadetReplyProcessor)(void *cls, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute expiration, size_t data_size, const void *data)
Function called with a reply from the cadet.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSF_cadet_release_clients()

int GSF_cadet_release_clients ( void *  cls,
const struct GNUNET_PeerIdentity key,
void *  value 
)

Function called on each active cadets to shut them down.

Parameters
clsNULL
keytarget peer, unused
valuethe struct CadetHandle to destroy
Returns
GNUNET_YES (continue to iterate)

Definition at line 703 of file gnunet-service-fs_cadet_client.c.

References CadetHandle::channel, GNUNET_CADET_channel_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_YES, GSF_CadetRequest::mh, CadetHandle::reset_task, CadetHandle::target, and value.

Referenced by GSF_cadet_stop_server().

706 {
707  struct CadetHandle *mh = value;
708 
710  "Timeout on cadet channel to %s\n",
711  GNUNET_i2s (&mh->target));
712  if (NULL != mh->channel)
713  {
714  struct GNUNET_CADET_Channel *channel = mh->channel;
715 
716  mh->channel = NULL;
718  }
719  if (NULL != mh->reset_task)
720  {
722  mh->reset_task = NULL;
723  }
724  return GNUNET_YES;
725 }
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
Handle for a cadet to another peer.
Opaque handle to a channel.
Definition: cadet_api.c:80
static char * value
Value of the record to add/remove.
struct GNUNET_PeerIdentity target
Which peer does this cadet go to?
struct GNUNET_SCHEDULER_Task * reset_task
Task to reset cadets that had errors (asynchronously, as we may not be able to do it immediately duri...
struct GNUNET_CADET_Channel * channel
Channel to the other peer.
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:77
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:903
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
Here is the call graph for this function:
Here is the caller graph for this function:

Variable Documentation

◆ cadet_handle

struct GNUNET_CADET_Handle* cadet_handle

Cadet channel for creating outbound channels.

Definition at line 152 of file gnunet-service-fs_cadet_client.c.

◆ cadet_map

struct GNUNET_CONTAINER_MultiPeerMap* cadet_map

Map from peer identities to 'struct CadetHandles' with cadet channels to those peers.

Definition at line 158 of file gnunet-service-fs_cadet_client.c.

Referenced by GSF_cadet_start_server(), and GSF_cadet_stop_server().