GNUnet 0.22.2
gnunet-service-fs_cadet_client.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2012, 2013 GNUnet e.V.
4
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
14
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
19 */
20
30#include "platform.h"
31#include "gnunet_util_lib.h"
33#include "gnunet_protocols.h"
34#include "gnunet_applications.h"
35#include "gnunet-service-fs.h"
37
38
42#define CLIENT_RETRY_TIMEOUT \
43 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
44
45
49struct CadetHandle;
50
51
56{
61
66
70 struct CadetHandle *mh;
71
76
80 void *proc_cls;
81
86
91
97};
98
99
104{
109
114
120
125
130
137
144};
145
146
151
157
158
159/* ********************* client-side code ************************* */
160
161
167static void
168transmit_pending (void *cls);
169
170
180static int
181move_to_pending (void *cls, const struct GNUNET_HashCode *key, void *value)
182{
183 struct CadetHandle *mh = cls;
184 struct GSF_CadetRequest *sr = value;
185
187 GNUNET_YES ==
189 GNUNET_CONTAINER_DLL_insert (mh->pending_head, mh->pending_tail, sr);
191 return GNUNET_YES;
192}
193
194
203static int
204check_reply (void *cls, const struct CadetReplyMessage *srm)
205{
206 /* We check later... */
207 return GNUNET_OK;
208}
209
210
216static void
217reset_cadet_task (void *cls);
218
219
226static void
228{
229 if (NULL != mh->reset_task)
230 GNUNET_SCHEDULER_cancel (mh->reset_task);
232}
233
234
239{
243 const void *data;
244
249
253 size_t data_size;
254
259
263 int found;
264};
265
266
276static int
277process_reply (void *cls, const struct GNUNET_HashCode *key, void *value)
278{
279 struct HandleReplyClosure *hrc = cls;
280 struct GSF_CadetRequest *sr = value;
281
282 sr->proc (sr->proc_cls,
283 hrc->type,
284 hrc->expiration,
285 hrc->data_size,
286 hrc->data);
287 sr->proc = NULL;
289 hrc->found = GNUNET_YES;
290 return GNUNET_YES;
291}
292
293
304static int
305free_waiting_entry (void *cls, const struct GNUNET_HashCode *key, void *value)
306{
307 struct GSF_CadetRequest *sr = value;
308
310 return GNUNET_YES;
311}
312
313
321static void
322handle_reply (void *cls, const struct CadetReplyMessage *srm)
323{
324 struct CadetHandle *mh = cls;
325 struct HandleReplyClosure hrc;
326 uint16_t msize;
328 struct GNUNET_HashCode query;
329
330 msize = ntohs (srm->header.size) - sizeof(struct CadetReplyMessage);
331 type = ntohl (srm->type);
332 if (GNUNET_YES !=
333 GNUNET_BLOCK_get_key (GSF_block_ctx, type, &srm[1], msize, &query))
334 {
335 GNUNET_break_op (0);
336 GNUNET_log (
338 "Received bogus reply of type %u with %u bytes via cadet from peer %s\n",
339 type,
340 msize,
341 GNUNET_i2s (&mh->target));
343 return;
344 }
346 "Received reply `%s' via cadet from peer %s\n",
347 GNUNET_h2s (&query),
348 GNUNET_i2s (&mh->target));
349 GNUNET_CADET_receive_done (mh->channel);
351 gettext_noop ("# replies received via cadet"),
352 1,
353 GNUNET_NO);
354 hrc.data = &srm[1];
355 hrc.data_size = msize;
357 hrc.type = type;
358 hrc.found = GNUNET_NO;
360 &query,
362 &hrc);
363 if (GNUNET_NO == hrc.found)
364 {
367 "# replies received via cadet dropped"),
368 1,
369 GNUNET_NO);
370 }
371}
372
373
381static void
382disconnect_cb (void *cls, const struct GNUNET_CADET_Channel *channel)
383{
384 struct CadetHandle *mh = cls;
385 struct GSF_CadetRequest *sr;
386
387 if (NULL == mh->channel)
388 return; /* being destroyed elsewhere */
389 GNUNET_assert (channel == mh->channel);
390 mh->channel = NULL;
391 while (NULL != (sr = mh->pending_head))
393 /* first remove `mh` from the `cadet_map`, so that if the
394 callback from `free_waiting_entry()` happens to re-issue
395 the request, we don't immediately have it back in the
396 `waiting_map`. */
398 &mh->target,
399 mh));
402 mh);
403 if (NULL != mh->timeout_task)
404 GNUNET_SCHEDULER_cancel (mh->timeout_task);
405 if (NULL != mh->reset_task)
406 GNUNET_SCHEDULER_cancel (mh->reset_task);
409 GNUNET_free (mh);
410}
411
412
427static void
429 const struct GNUNET_CADET_Channel *channel,
430 int window_size)
431{
432 /* FIXME: for flow control, implement? */
433#if 0
434 /* Something like this instead of the GNUNET_MQ_notify_sent() in
435 transmit_pending() might be good (once the window change CB works...) */
436 if (0 < window_size) /* test needed? */
438#endif
439}
440
441
447static void
449{
451 "Resetting cadet channel to %s\n",
452 GNUNET_i2s (&mh->target));
453 if (NULL != mh->channel)
454 {
456 mh->channel = NULL;
457 }
459 {
461 { GNUNET_MQ_hd_var_size (reply,
463 struct CadetReplyMessage,
464 mh),
466 struct GNUNET_HashCode port;
467
470 &port);
472 mh,
473 &mh->target,
474 &port,
477 handlers);
478 }
480}
481
482
488static void
489cadet_timeout (void *cls)
490{
491 struct CadetHandle *mh = cls;
492 struct GNUNET_CADET_Channel *tun;
493
495 "Timeout on cadet channel to %s\n",
496 GNUNET_i2s (&mh->target));
497 mh->timeout_task = NULL;
498 tun = mh->channel;
499 mh->channel = NULL;
500 if (NULL != tun)
502}
503
504
510static void
512{
513 struct CadetHandle *mh = cls;
514
515 mh->reset_task = NULL;
516 reset_cadet (mh);
517}
518
519
525static void
527{
528 struct CadetHandle *mh = cls;
529 struct GNUNET_MQ_Handle *mq = GNUNET_CADET_get_mq (mh->channel);
530 struct GSF_CadetRequest *sr;
531 struct GNUNET_MQ_Envelope *env;
532 struct CadetQueryMessage *sqm;
533
534 if ((0 != GNUNET_MQ_get_length (mq)) || (NULL == (sr = mh->pending_head)))
535 return;
536 GNUNET_CONTAINER_DLL_remove (mh->pending_head, mh->pending_tail, sr);
538 mh->waiting_map,
539 &sr->query,
540 sr,
544 "Sending query for %s via cadet to %s\n",
545 GNUNET_h2s (&sr->query),
546 GNUNET_i2s (&mh->target));
552 sqm->type = htonl (sr->type);
553 sqm->query = sr->query;
556}
557
558
564static struct CadetHandle *
566{
567 struct CadetHandle *mh;
568
570 if (NULL != mh)
571 {
572 if (NULL != mh->timeout_task)
573 {
574 GNUNET_SCHEDULER_cancel (mh->timeout_task);
575 mh->timeout_task = NULL;
576 }
577 return mh;
578 }
580 "Creating cadet channel to %s\n",
582 mh = GNUNET_new (struct CadetHandle);
583 mh->reset_task =
586 mh->target = *target;
589 cadet_map,
590 &mh->target,
591 mh,
593 {
595 { GNUNET_MQ_hd_var_size (reply,
597 struct CadetReplyMessage,
598 mh),
600 struct GNUNET_HashCode port;
601
604 &port);
606 mh,
607 &mh->target,
608 &port,
611 handlers);
612 }
613 return mh;
614}
615
616
627struct GSF_CadetRequest *
629 const struct GNUNET_HashCode *query,
632 void *proc_cls)
633{
634 struct CadetHandle *mh;
635 struct GSF_CadetRequest *sr;
636
638 "Preparing to send query for %s via cadet to %s\n",
640 GNUNET_i2s (target));
641 mh = get_cadet (target);
642 sr = GNUNET_new (struct GSF_CadetRequest);
643 sr->mh = mh;
644 sr->proc = proc;
645 sr->proc_cls = proc_cls;
646 sr->type = type;
647 sr->query = *query;
648 GNUNET_CONTAINER_DLL_insert (mh->pending_head, mh->pending_tail, sr);
650 return sr;
651}
652
653
660void
662{
663 struct CadetHandle *mh = sr->mh;
665
666 p = sr->proc;
667 sr->proc = NULL;
668 if (NULL != p)
669 {
670 /* signal failure / cancellation to callback */
672 }
674 "Cancelled query for %s via cadet to %s\n",
675 GNUNET_h2s (&sr->query),
676 GNUNET_i2s (&sr->mh->target));
677 if (GNUNET_YES == sr->was_transmitted)
679 GNUNET_OK ==
680 GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map, &sr->query, sr));
681 else
682 GNUNET_CONTAINER_DLL_remove (mh->pending_head, mh->pending_tail, sr);
683 GNUNET_free (sr);
684 if ((0 == GNUNET_CONTAINER_multihashmap_size (mh->waiting_map)) &&
685 (NULL == mh->pending_head))
688 mh);
689}
690
691
700int
702 const struct GNUNET_PeerIdentity *key,
703 void *value)
704{
705 struct CadetHandle *mh = value;
706
708 "Timeout on cadet channel to %s\n",
709 GNUNET_i2s (&mh->target));
710 if (NULL != mh->channel)
711 {
712 struct GNUNET_CADET_Channel *channel = mh->channel;
713
714 mh->channel = NULL;
716 }
717 if (NULL != mh->reset_task)
718 {
719 GNUNET_SCHEDULER_cancel (mh->reset_task);
720 mh->reset_task = NULL;
721 }
722 return GNUNET_YES;
723}
724
725
726/* end of gnunet-service-fs_cadet_client.c */
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define gettext_noop(String)
Definition: gettext.h:74
static uint16_t port
Port number.
Definition: gnunet-bcd.c:146
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
static uint32_t type
Type string converted to DNS type value.
struct GNUNET_BLOCK_Context * GSF_block_ctx
Our block context.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
shared data structures of gnunet-service-fs.c
non-anonymous file-transfer
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.
static void disconnect_cb(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called by cadet when a client disconnects.
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.
static void handle_reply(void *cls, const struct CadetReplyMessage *srm)
Functions with this signature are called whenever a complete reply is received.
static void transmit_pending(void *cls)
Transmit pending requests via the cadet.
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.
struct GNUNET_CONTAINER_MultiPeerMap * cadet_map
Map from peer identities to 'struct CadetHandles' with cadet channels to those peers.
void GSF_cadet_query_cancel(struct GSF_CadetRequest *sr)
Cancel an active request; must not be called after 'proc' was called.
static struct CadetHandle * get_cadet(const struct GNUNET_PeerIdentity *target)
Get (or create) a cadet to talk to the given peer.
static int check_reply(void *cls, const struct CadetReplyMessage *srm)
Functions with this signature are called whenever a complete reply is received.
static void reset_cadet_task(void *cls)
Task called when it is time to reset an cadet.
int GSF_cadet_release_clients(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Function called on each active cadets to shut them down.
static void reset_cadet(struct CadetHandle *mh)
We had a serious error, tear down and re-create cadet from scratch.
struct GNUNET_CADET_Handle * cadet_handle
Cadet channel for creating outbound channels.
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.
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 CLIENT_RETRY_TIMEOUT
After how long do we reset connections without replies?
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...
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 void cadet_timeout(void *cls)
Task called when it is time to destroy an inactive cadet channel.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
Constants for network applications operating on top of the CADET service.
CADET service; establish channels to distant peers.
Constants for network protocols.
#define GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER
Transfer of blocks for non-anonymmous file-sharing.
enum GNUNET_GenericReturnValue 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:278
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Indicate readiness to receive the next message on a channel.
Definition: cadet_api.c:875
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:833
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected channel.
Definition: cadet_api.c:1081
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:1030
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
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.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
enum GNUNET_GenericReturnValue 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.
enum GNUNET_GenericReturnValue 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.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
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.
enum GNUNET_GenericReturnValue 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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_log(kind,...)
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
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:847
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition: mq.c:293
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:305
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:76
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
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:655
@ GNUNET_MQ_PREF_OUT_OF_ORDER
Flag to indicate that out-of-order delivery is OK.
@ GNUNET_MQ_PREF_CORK_ALLOWED
Flag to indicate that CORKing is acceptable.
@ GNUNET_MQ_PREF_GOODPUT
Flag to indicate that high bandwidth is desired.
#define GNUNET_MESSAGE_TYPE_FS_CADET_QUERY
P2P request for content (one FS to another via a cadet).
#define GNUNET_MESSAGE_TYPE_FS_CADET_REPLY
P2P answer for content (one FS to another via a cadet).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:980
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:1304
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:1277
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:741
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
GNUNET_BLOCK_Type
WARNING: This header is generated! In order to add DHT block types, you must register them in GANA,...
@ GNUNET_BLOCK_TYPE_ANY
Identifier for any block.
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...
struct GNUNET_CONTAINER_MultiHashMap * waiting_map
Map from query to struct GSF_CadetRequests waiting for a reply.
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 GSF_CadetRequest * pending_head
Head of DLL of pending requests on this cadet.
struct GNUNET_CADET_Channel * channel
Channel to the other peer.
struct GNUNET_PeerIdentity target
Which peer does this cadet go to?
struct GSF_CadetRequest * pending_tail
Tail of DLL of pending requests on this cadet.
Query from one peer, asking the other for CHK-data.
struct GNUNET_HashCode query
Query hash from CHK (hash of encrypted block).
uint32_t type
Block type must be DBLOCK or IBLOCK.
Reply to a CadetQueryMessage.
struct GNUNET_TIME_AbsoluteNBO expiration
Expiration time for the block.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_FS_CADET_REPLY.
uint32_t type
Block type must be DBLOCK or IBLOCK.
Opaque handle to a channel.
Definition: cadet.h:116
Opaque handle to the service.
Definition: cadet_api.c:39
Internal representation of the hash map.
Internal representation of the hash map.
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:136
Time for absolute times used by GNUnet, in microseconds.
Handle for a request that is going out via cadet API.
void * proc_cls
Closure for proc.
enum GNUNET_BLOCK_Type type
Desired type for the reply.
struct CadetHandle * mh
Which cadet is this request associated with?
int was_transmitted
Did we transmit this request already? GNUNET_YES if we are in the 'waiting_map', GNUNET_NO if we are ...
GSF_CadetReplyProcessor proc
Function to call with the result.
struct GSF_CadetRequest * next
DLL.
struct GSF_CadetRequest * prev
DLL.
struct GNUNET_HashCode query
Query to transmit to the other peer.
Closure for handle_reply().
enum GNUNET_BLOCK_Type type
Type of the block.
const void * data
Reply payload.
int found
Did we have a matching query?
size_t data_size
Number of bytes in data.
struct GNUNET_TIME_Absolute expiration
Expiration time for the block.