GNUnet  0.11.x
fs_test_lib.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2010, 2011, 2012 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 
29 #include "platform.h"
30 #include "fs_api.h"
31 #include "fs_test_lib.h"
32 
33 
34 #define CONTENT_LIFETIME GNUNET_TIME_UNIT_HOURS
35 
36 
41 {
46 
51 
56 
61 
66 
70  uint32_t publish_seed;
71 
76 
81 
86 
90  uint64_t size;
91 
95  uint32_t anonymity;
96 
100  unsigned int verbose;
101 
105  int do_index;
106 };
107 
108 
113 {
118 
123 
127  struct GNUNET_TESTING_Daemon *daemon;
128 
133 
138 
143 
148 
153 
157  uint64_t size;
158 
162  uint32_t anonymity;
163 
167  uint32_t download_seed;
168 
172  unsigned int verbose;
173 };
174 
175 
182 static void
183 report_uri (void *cls)
184 {
185  struct TestPublishOperation *po = cls;
186 
190  po->publish_uri,
191  (GNUNET_YES == po->do_index)
192  ? po->publish_tmp_file
193  : NULL);
195  if ((GNUNET_YES != po->do_index) &&
196  (NULL != po->publish_tmp_file))
199  GNUNET_free (po);
200 }
201 
202 
208 static void
209 publish_timeout (void *cls)
210 {
211  struct TestPublishOperation *po = cls;
212 
213  po->publish_timeout_task = NULL;
215  "Timeout while trying to publish data\n");
218  po->publish_cont (po->publish_cont_cls, NULL, NULL);
221  GNUNET_free (po);
222 }
223 
224 
231 static void *
232 publish_progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
233 {
234  struct TestPublishOperation *po = cls;
235 
236  switch (info->status)
237  {
240  po->publish_timeout_task = NULL;
241  po->publish_uri =
242  GNUNET_FS_uri_dup (info->value.publish.specifics.completed.chk_uri);
244  po);
245  break;
246 
248  if (po->verbose)
249  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Publishing at %llu/%llu bytes\n",
250  (unsigned long long) info->value.publish.completed,
251  (unsigned long long) info->value.publish.size);
252  break;
253 
255  break;
256 
258  if (po->verbose)
259  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Download at %llu/%llu bytes\n",
260  (unsigned long long) info->value.download.completed,
261  (unsigned long long) info->value.download.size);
262  break;
263 
264  default:
265  break;
266  }
267  return NULL;
268 }
269 
270 
281 static size_t
282 file_generator (void *cls,
283  uint64_t offset,
284  size_t max,
285  void *buf,
286  char **emsg)
287 {
288  uint32_t *publish_seed = cls;
289  uint64_t pos;
290  uint8_t *cbuf = buf;
291  int mod;
292 
293  if (emsg != NULL)
294  *emsg = NULL;
295  if (buf == NULL)
296  return 0;
297  for (pos = 0; pos < 8; pos++)
298  cbuf[pos] = (uint8_t) (offset >> pos * 8);
299  for (pos = 8; pos < max; pos++)
300  {
301  mod = (255 - (offset / 1024 / 32));
302  if (mod == 0)
303  mod = 1;
304  cbuf[pos] = (uint8_t) ((offset * (*publish_seed)) % mod);
305  }
306  return max;
307 }
308 
309 
319 static void *
321  const struct GNUNET_CONFIGURATION_Handle *cfg)
322 {
323  struct TestPublishOperation *po = cls;
324 
325  return GNUNET_FS_start (cfg,
326  "fs-test-publish",
327  &publish_progress_cb, po,
330 }
331 
332 
339 static void
341  void *op_result)
342 {
343  struct GNUNET_FS_Handle *fs = op_result;
344 
345  GNUNET_FS_stop (fs);
346 }
347 
348 
358 static void
361  void *ca_result,
362  const char *emsg)
363 {
364  struct TestPublishOperation *po = cls;
365  struct GNUNET_FS_FileInformation *fi;
366  struct GNUNET_DISK_FileHandle *fh;
367  char *em;
368  uint64_t off;
369  char buf[DBLOCK_SIZE];
370  size_t bsize;
371  struct GNUNET_FS_BlockOptions bo;
372 
373  if (NULL == ca_result)
374  {
376  "Failed to connect to FS for publishing: %s\n", emsg);
378  NULL, NULL);
380  GNUNET_free (po);
381  return;
382  }
383  po->fs = ca_result;
384 
386  bo.anonymity_level = po->anonymity;
387  bo.content_priority = 42;
388  bo.replication_level = 1;
389  if (GNUNET_YES == po->do_index)
390  {
391  po->publish_tmp_file = GNUNET_DISK_mktemp ("fs-test-publish-index");
392  GNUNET_assert (po->publish_tmp_file != NULL);
398  GNUNET_assert (NULL != fh);
399  off = 0;
400  while (off < po->size)
401  {
402  bsize = GNUNET_MIN (sizeof(buf), po->size - off);
403  emsg = NULL;
404  GNUNET_assert (bsize == file_generator (&po->publish_seed, off, bsize,
405  buf, &em));
406  GNUNET_assert (em == NULL);
407  GNUNET_assert (bsize == GNUNET_DISK_file_write (fh, buf, bsize));
408  off += bsize;
409  }
412  po->publish_tmp_file,
413  NULL, NULL, po->do_index,
414  &bo);
415  GNUNET_assert (NULL != fi);
416  }
417  else
418  {
420  po->size,
422  &po->publish_seed,
423  NULL, NULL,
424  po->do_index, &bo);
425  GNUNET_assert (NULL != fi);
426  }
427  po->publish_context =
428  GNUNET_FS_publish_start (po->fs, fi, NULL, NULL, NULL,
430 }
431 
432 
448 void
450  struct GNUNET_TIME_Relative timeout, uint32_t anonymity,
451  int do_index, uint64_t size, uint32_t seed,
452  unsigned int verbose,
453  GNUNET_FS_TEST_UriContinuation cont, void *cont_cls)
454 {
455  struct TestPublishOperation *po;
456 
457  po = GNUNET_new (struct TestPublishOperation);
458  po->publish_cont = cont;
459  po->publish_cont_cls = cont_cls;
460  po->publish_seed = seed;
461  po->anonymity = anonymity;
462  po->size = size;
463  po->verbose = verbose;
464  po->do_index = do_index;
466  peer,
467  "fs",
469  po,
472  po);
475 }
476 
477 
478 /* ************************** download ************************ */
479 
480 
486 static void
487 download_timeout (void *cls)
488 {
489  struct TestDownloadOperation *dop = cls;
490 
492  "Timeout while trying to download file\n");
493  dop->download_timeout_task = NULL;
495  GNUNET_YES);
497  dop->download_cont_cls);
499  GNUNET_FS_uri_destroy (dop->uri);
500  GNUNET_free (dop);
501 }
502 
503 
509 static void
510 report_success (void *cls)
511 {
512  struct TestDownloadOperation *dop = cls;
513 
515  GNUNET_YES);
517  dop->download_cont_cls);
519  GNUNET_FS_uri_destroy (dop->uri);
520  GNUNET_free (dop);
521 }
522 
523 
530 static void *
532  const struct GNUNET_FS_ProgressInfo *info)
533 {
534  struct TestDownloadOperation *dop = cls;
535 
536  switch (info->status)
537  {
539  if (dop->verbose)
541  "Download at %llu/%llu bytes\n",
542  (unsigned long long) info->value.download.completed,
543  (unsigned long long) info->value.download.size);
544  break;
545 
548  dop->download_timeout_task = NULL;
550  break;
551 
554  break;
555 
556  /* FIXME: monitor data correctness during download progress */
557  /* FIXME: do performance reports given sufficient verbosity */
558  /* FIXME: advance timeout task to "immediate" on error */
559  default:
560  break;
561  }
562  return NULL;
563 }
564 
565 
575 static void *
577  const struct GNUNET_CONFIGURATION_Handle *cfg)
578 {
579  struct TestPublishOperation *po = cls;
580 
581  return GNUNET_FS_start (cfg,
582  "fs-test-download",
586 }
587 
588 
598 static void
601  void *ca_result,
602  const char *emsg)
603 {
604  struct TestDownloadOperation *dop = cls;
605 
606  dop->fs = ca_result;
607  GNUNET_assert (NULL != dop->fs);
608  dop->download_context =
609  GNUNET_FS_download_start (dop->fs, dop->uri, NULL, NULL, NULL, 0, dop->size,
611  NULL, NULL);
612 }
613 
614 
628 void
631  uint32_t anonymity, uint32_t seed,
632  const struct GNUNET_FS_Uri *uri, unsigned int verbose,
633  GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
634 {
635  struct TestDownloadOperation *dop;
636 
637  dop = GNUNET_new (struct TestDownloadOperation);
638  dop->uri = GNUNET_FS_uri_dup (uri);
640  dop->verbose = verbose;
641  dop->anonymity = anonymity;
642  dop->download_cont = cont;
643  dop->download_cont_cls = cont_cls;
644  dop->download_seed = seed;
645 
647  peer,
648  "fs",
650  dop,
653  dop);
654  dop->download_timeout_task =
656 }
657 
658 
659 /* end of fs_test_lib.c */
struct GNUNET_TIME_Absolute expiration_time
At what time should the block expire? Data blocks (DBLOCKS and IBLOCKS) may still be used even if the...
struct GNUNET_FS_Handle * fs
Handle to the file sharing context using this daemon.
Definition: fs_test_lib.c:50
struct GNUNET_TESTING_Daemon * daemon
Handle to the daemon via testing.
Definition: fs_test_lib.c:127
static void report_uri(void *cls)
Task scheduled to report on the completion of our publish operation.
Definition: fs_test_lib.c:183
char * publish_tmp_file
Name of the temporary file used, or NULL for none.
Definition: fs_test_lib.c:85
static void * publish_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect adapter for publishing operation.
Definition: fs_test_lib.c:320
int do_index
Are we testing indexing? (YES: index, NO: insert, SYSERR: simulate)
Definition: fs_test_lib.c:105
Create file if it doesn&#39;t exist.
void * publish_cont_cls
Closure for publish_cont.
Definition: fs_test_lib.c:60
uint32_t publish_seed
Seed for file generation.
Definition: fs_test_lib.c:70
void GNUNET_FS_publish_stop(struct GNUNET_FS_PublishContext *pc)
Stop an upload.
Definition: fs_publish.c:1570
Context for controlling a download.
Definition: fs_api.h:1742
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1345
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
void(* GNUNET_FS_TEST_UriContinuation)(void *cls, const struct GNUNET_FS_Uri *uri, const char *fn)
Function signature.
Definition: fs_test_lib.h:46
void GNUNET_FS_TEST_download(struct GNUNET_TESTBED_Peer *peer, struct GNUNET_TIME_Relative timeout, uint32_t anonymity, uint32_t seed, const struct GNUNET_FS_Uri *uri, unsigned int verbose, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Perform test download.
Definition: fs_test_lib.c:629
struct GNUNET_FS_ProgressInfo::@25::@27 download
Values for all "GNUNET_FS_STATUS_DOWNLOAD_*" events.
Notification that we are making progress sharing a file structure.
struct GNUNET_FS_PublishContext * GNUNET_FS_publish_start(struct GNUNET_FS_Handle *h, struct GNUNET_FS_FileInformation *fi, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *nid, const char *nuid, enum GNUNET_FS_PublishOptions options)
Publish a file or directory.
Definition: fs_publish.c:1442
Master context for most FS operations.
Definition: fs_api.h:1068
uint64_t size
Size of the file.
Definition: fs_test_lib.c:157
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int op_result(struct GNUNET_OP_Handle *h, uint64_t op_id, int64_t result_code, const void *data, uint16_t data_size, void **ctx, uint8_t cancel)
Remove an operation, and call its result callback (unless it was cancelled).
Definition: op.c:245
Last option in the VARARG list.
struct GNUNET_FS_FileInformation * GNUNET_FS_file_information_create_from_file(struct GNUNET_FS_Handle *h, void *client_info, const char *filename, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
Create an entry for a file in a publish-structure.
uint32_t anonymity
Anonymity level used.
Definition: fs_test_lib.c:162
GNUNET_SCHEDULER_TaskCallback download_cont
Function to call when download is done.
Definition: fs_test_lib.c:132
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_FS_PublishContext * publish_context
Context for current publishing operation.
Definition: fs_test_lib.c:75
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Information for a file or directory that is about to be published.
Definition: fs_api.h:226
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3216
struct GNUNET_FS_Uri * uri
URI to download.
Definition: fs_test_lib.c:142
GNUNET_FS_TEST_UriContinuation publish_cont
Function to call when upload is done.
Definition: fs_test_lib.c:55
struct GNUNET_FS_DownloadContext * GNUNET_FS_download_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta, const char *filename, const char *tempname, uint64_t offset, uint64_t length, uint32_t anonymity, enum GNUNET_FS_DownloadOptions options, void *cctx, struct GNUNET_FS_DownloadContext *parent)
Download parts of a file.
Definition: fs_download.c:2145
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:998
void(* GNUNET_SCHEDULER_TaskCallback)(void *cls)
Signature of the main function of a task.
Opaque handle to an abstract operation to be executed by the testing framework.
struct GNUNET_FS_Handle * GNUNET_FS_start(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *client_name, GNUNET_FS_ProgressCallback upcb, void *upcb_cls, enum GNUNET_FS_Flags flags,...)
Setup a connection to the file-sharing service.
Definition: fs_api.c:3141
No special flags set.
static void publish_timeout(void *cls)
Task scheduled to run when publish operation times out.
Definition: fs_test_lib.c:209
struct GNUNET_FS_Uri * publish_uri
Result URI.
Definition: fs_test_lib.c:80
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
uint32_t anonymity_level
At which anonymity level should the block be shared? (0: no anonymity, 1: normal GAP, >1: with cover traffic).
struct GNUNET_TESTBED_Operation * fs_op
Handle for the operation to connect to the peer&#39;s &#39;fs&#39; service.
Definition: fs_test_lib.c:45
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_service_connect(void *op_cls, struct GNUNET_TESTBED_Peer *peer, const char *service_name, GNUNET_TESTBED_ServiceConnectCompletionCallback cb, void *cb_cls, GNUNET_TESTBED_ConnectAdapter ca, GNUNET_TESTBED_DisconnectAdapter da, void *cada_cls)
Connect to a service offered by the given peer.
Notification that this download completed.
union GNUNET_FS_ProgressInfo::@25 value
Values that depend on the event 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
char * GNUNET_DISK_mktemp(const char *t)
Create an (empty) temporary file on disk.
Definition: disk.c:468
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
Notification that we are making progress sharing a directory.
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:820
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
int GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1029
enum GNUNET_FS_Status status
Specific status code (determines the event type).
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:80
void GNUNET_FS_TEST_publish(struct GNUNET_TESTBED_Peer *peer, struct GNUNET_TIME_Relative timeout, uint32_t anonymity, int do_index, uint64_t size, uint32_t seed, unsigned int verbose, GNUNET_FS_TEST_UriContinuation cont, void *cont_cls)
Publish a file at the given peer.
Definition: fs_test_lib.c:449
void GNUNET_FS_download_stop(struct GNUNET_FS_DownloadContext *dc, int do_delete)
Stop a download (aborts if download is incomplete).
Definition: fs_download.c:2333
static char buf[2048]
No options (use defaults for everything).
uint32_t anonymity
Anonymity level used.
Definition: fs_test_lib.c:95
static int fh
Handle to the unique file.
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2044
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:678
Handle for controlling a publication process.
Definition: fs_api.h:1178
static unsigned int bsize
Handle for a publishing operation started for testing FS.
Definition: fs_test_lib.c:40
unsigned int verbose
Verbosity level of the current operation.
Definition: fs_test_lib.c:100
unsigned int verbose
Verbosity level of the current operation.
Definition: fs_test_lib.c:172
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
Notification that this download is no longer actively being pursued (back in the queue).
uint32_t download_seed
Seed for download verification.
Definition: fs_test_lib.c:167
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
Notification about progress with this download.
static void publish_fs_connect_complete_cb(void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
Callback to be called when testbed has connected to the fs service.
Definition: fs_test_lib.c:359
Open the file for writing.
Notification that this download is now actively being pursued (as opposed to waiting in the queue)...
Settings for publishing a block (which may of course also apply to an entire directory or file)...
Notification that we completed sharing a file structure.
struct GNUNET_TESTBED_Operation * fs_op
Handle for the operation to connect to the peer&#39;s &#39;fs&#39; service.
Definition: fs_test_lib.c:117
static void * download_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect adapter for download operation.
Definition: fs_test_lib.c:576
static void * publish_progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
Progress callback for file-sharing events while publishing.
Definition: fs_test_lib.c:232
uint32_t replication_level
How often should we try to migrate the block to other peers? Only used if "CONTENT_PUSHING" is set to...
static void fs_disconnect_adapter(void *cls, void *op_result)
Adapter function called to destroy connection to file-sharing service.
Definition: fs_test_lib.c:340
struct GNUNET_SCHEDULER_Task * publish_timeout_task
Task to abort publishing (timeout).
Definition: fs_test_lib.c:65
uint64_t size
Size of the file.
Definition: fs_test_lib.c:90
struct GNUNET_FS_ProgressInfo::@25::@26 publish
Values for all "GNUNET_FS_STATUS_PUBLISH_*" events.
uint64_t GNUNET_FS_uri_chk_get_file_size(const struct GNUNET_FS_Uri *uri)
What is the size of the file that this URI refers to?
Definition: fs_uri.c:1371
configuration data
Definition: configuration.c:85
shared definitions for the FS library
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:165
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
uint32_t content_priority
How important is it for us to store the block? If we run out of space, the highest-priority, non-expired blocks will be kept.
struct GNUNET_FS_Handle * fs
Handle to the file sharing context using this daemon.
Definition: fs_test_lib.c:122
struct GNUNET_FS_FileInformation * GNUNET_FS_file_information_create_from_reader(struct GNUNET_FS_Handle *h, void *client_info, uint64_t length, GNUNET_FS_DataReader reader, void *reader_cls, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
Create an entry for a file in a publish-structure.
void * download_cont_cls
Closure for download_cont.
Definition: fs_test_lib.c:137
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_SCHEDULER_Task * download_timeout_task
Task to abort downloading (timeout).
Definition: fs_test_lib.c:147
Handle for a download operation started for testing FS.
Definition: fs_test_lib.c:112
#define CONTENT_LIFETIME
Definition: fs_test_lib.c:34
static void download_timeout(void *cls)
Task scheduled to run when download operation times out.
Definition: fs_test_lib.c:487
struct GNUNET_FS_DownloadContext * download_context
Context for current download operation.
Definition: fs_test_lib.c:152
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
static size_t file_generator(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
Generate test data for publishing test.
Definition: fs_test_lib.c:282
static void download_fs_connect_complete_cb(void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
Callback to be called when testbed has connected to the fs service.
Definition: fs_test_lib.c:599
A peer controlled by the testing framework.
No options (use defaults for everything).
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1268
static void * download_progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
Progress callback for file-sharing events while downloading.
Definition: fs_test_lib.c:531
Handle used to access files (and pipes).
library routines for testing FS publishing and downloading; this code is limited to flat files and no...
static void report_success(void *cls)
Task scheduled to report on the completion of our download operation.
Definition: fs_test_lib.c:510
#define GNUNET_free(ptr)
Wrapper around free.
Argument given to the progress callback with information about what is going on.
Time for relative time used by GNUnet, in microseconds.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966