GNUnet  0.10.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 {
42 
47 
52 
57 
62 
67 
71  uint32_t publish_seed;
72 
77 
82 
87 
91  uint64_t size;
92 
96  uint32_t anonymity;
97 
101  unsigned int verbose;
102 
106  int do_index;
107 };
108 
109 
114 {
115 
120 
125 
129  struct GNUNET_TESTING_Daemon *daemon;
130 
135 
140 
145 
150 
155 
159  uint64_t size;
160 
164  uint32_t anonymity;
165 
169  uint32_t download_seed;
170 
174  unsigned int verbose;
175 
176 };
177 
178 
185 static void
186 report_uri (void *cls)
187 {
188  struct TestPublishOperation *po = cls;
189 
193  po->publish_uri,
194  (GNUNET_YES == po->do_index)
195  ? po->publish_tmp_file
196  : NULL);
198  if ( (GNUNET_YES != po->do_index) &&
199  (NULL != po->publish_tmp_file) )
202  GNUNET_free (po);
203 }
204 
205 
211 static void
212 publish_timeout (void *cls)
213 {
214  struct TestPublishOperation *po = cls;
215 
216  po->publish_timeout_task = NULL;
218  "Timeout while trying to publish data\n");
221  po->publish_cont (po->publish_cont_cls, NULL, NULL);
224  GNUNET_free (po);
225 }
226 
227 
234 static void *
235 publish_progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
236 {
237  struct TestPublishOperation *po = cls;
238 
239  switch (info->status)
240  {
243  po->publish_timeout_task = NULL;
244  po->publish_uri =
245  GNUNET_FS_uri_dup (info->value.publish.specifics.completed.chk_uri);
247  po);
248  break;
250  if (po->verbose)
251  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Publishing at %llu/%llu bytes\n",
252  (unsigned long long) info->value.publish.completed,
253  (unsigned long long) info->value.publish.size);
254  break;
256  break;
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  default:
264  break;
265  }
266  return NULL;
267 }
268 
269 
280 static size_t
281 file_generator (void *cls,
282  uint64_t offset,
283  size_t max,
284  void *buf,
285  char **emsg)
286 {
287  uint32_t *publish_seed = cls;
288  uint64_t pos;
289  uint8_t *cbuf = buf;
290  int mod;
291 
292  if (emsg != NULL)
293  *emsg = NULL;
294  if (buf == NULL)
295  return 0;
296  for (pos = 0; pos < 8; pos++)
297  cbuf[pos] = (uint8_t) (offset >> pos * 8);
298  for (pos = 8; pos < max; pos++)
299  {
300  mod = (255 - (offset / 1024 / 32));
301  if (mod == 0)
302  mod = 1;
303  cbuf[pos] = (uint8_t) ((offset * (*publish_seed)) % mod);
304  }
305  return max;
306 }
307 
308 
318 static void *
320  const struct GNUNET_CONFIGURATION_Handle *cfg)
321 {
322  struct TestPublishOperation *po = cls;
323 
324  return GNUNET_FS_start (cfg,
325  "fs-test-publish",
326  &publish_progress_cb, po,
329 }
330 
331 
338 static void
340  void *op_result)
341 {
342  struct GNUNET_FS_Handle *fs = op_result;
343 
344  GNUNET_FS_stop (fs);
345 }
346 
347 
357 static void
360  void *ca_result,
361  const char *emsg)
362 {
363  struct TestPublishOperation *po = cls;
364  struct GNUNET_FS_FileInformation *fi;
365  struct GNUNET_DISK_FileHandle *fh;
366  char *em;
367  uint64_t off;
368  char buf[DBLOCK_SIZE];
369  size_t bsize;
370  struct GNUNET_FS_BlockOptions bo;
371 
372  if (NULL == ca_result)
373  {
374  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to connect to FS for publishing: %s\n", emsg);
376  NULL, NULL);
378  GNUNET_free (po);
379  return;
380  }
381  po->fs = ca_result;
382 
384  bo.anonymity_level = po->anonymity;
385  bo.content_priority = 42;
386  bo.replication_level = 1;
387  if (GNUNET_YES == po->do_index)
388  {
389  po->publish_tmp_file = GNUNET_DISK_mktemp ("fs-test-publish-index");
390  GNUNET_assert (po->publish_tmp_file != NULL);
396  GNUNET_assert (NULL != fh);
397  off = 0;
398  while (off < po->size)
399  {
400  bsize = GNUNET_MIN (sizeof (buf), po->size - off);
401  emsg = NULL;
402  GNUNET_assert (bsize == file_generator (&po->publish_seed, off, bsize, buf, &em));
403  GNUNET_assert (em == NULL);
404  GNUNET_assert (bsize == GNUNET_DISK_file_write (fh, buf, bsize));
405  off += bsize;
406  }
409  po->publish_tmp_file,
410  NULL, NULL, po->do_index,
411  &bo);
412  GNUNET_assert (NULL != fi);
413  }
414  else
415  {
417  po->size,
419  NULL, NULL,
420  po->do_index, &bo);
421  GNUNET_assert (NULL != fi);
422  }
423  po->publish_context =
424  GNUNET_FS_publish_start (po->fs, fi, NULL, NULL, NULL,
426 }
427 
428 
444 void
446  struct GNUNET_TIME_Relative timeout, uint32_t anonymity,
447  int do_index, uint64_t size, uint32_t seed,
448  unsigned int verbose,
449  GNUNET_FS_TEST_UriContinuation cont, void *cont_cls)
450 {
451  struct TestPublishOperation *po;
452 
453  po = GNUNET_new (struct TestPublishOperation);
454  po->publish_cont = cont;
455  po->publish_cont_cls = cont_cls;
456  po->publish_seed = seed;
457  po->anonymity = anonymity;
458  po->size = size;
459  po->verbose = verbose;
460  po->do_index = do_index;
462  peer,
463  "fs",
465  po,
468  po);
471 }
472 
473 
474 /* ************************** download ************************ */
475 
476 
482 static void
483 download_timeout (void *cls)
484 {
485  struct TestDownloadOperation *dop = cls;
486 
488  "Timeout while trying to download file\n");
489  dop->download_timeout_task = NULL;
491  GNUNET_YES);
493  dop->download_cont_cls);
495  GNUNET_FS_uri_destroy (dop->uri);
496  GNUNET_free (dop);
497 }
498 
499 
505 static void
506 report_success (void *cls)
507 {
508  struct TestDownloadOperation *dop = cls;
509 
511  GNUNET_YES);
513  dop->download_cont_cls);
515  GNUNET_FS_uri_destroy (dop->uri);
516  GNUNET_free (dop);
517 }
518 
519 
526 static void *
528  const struct GNUNET_FS_ProgressInfo *info)
529 {
530  struct TestDownloadOperation *dop = cls;
531 
532  switch (info->status)
533  {
535  if (dop->verbose)
537  "Download at %llu/%llu bytes\n",
538  (unsigned long long) info->value.download.completed,
539  (unsigned long long) info->value.download.size);
540  break;
543  dop->download_timeout_task = NULL;
545  break;
548  break;
549  /* FIXME: monitor data correctness during download progress */
550  /* FIXME: do performance reports given sufficient verbosity */
551  /* FIXME: advance timeout task to "immediate" on error */
552  default:
553  break;
554  }
555  return NULL;
556 }
557 
558 
568 static void *
570  const struct GNUNET_CONFIGURATION_Handle *cfg)
571 {
572  struct TestPublishOperation *po = cls;
573 
574  return GNUNET_FS_start (cfg,
575  "fs-test-download",
579 }
580 
581 
591 static void
594  void *ca_result,
595  const char *emsg)
596 {
597  struct TestDownloadOperation *dop = cls;
598 
599  dop->fs = ca_result;
600  GNUNET_assert (NULL != dop->fs);
601  dop->download_context =
602  GNUNET_FS_download_start (dop->fs, dop->uri, NULL, NULL, NULL, 0, dop->size,
604  NULL, NULL);
605 }
606 
607 
621 void
624  uint32_t anonymity, uint32_t seed,
625  const struct GNUNET_FS_Uri *uri, unsigned int verbose,
626  GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
627 {
628  struct TestDownloadOperation *dop;
629 
630  dop = GNUNET_new (struct TestDownloadOperation);
631  dop->uri = GNUNET_FS_uri_dup (uri);
633  dop->verbose = verbose;
634  dop->anonymity = anonymity;
635  dop->download_cont = cont;
636  dop->download_cont_cls = cont_cls;
637  dop->download_seed = seed;
638 
640  peer,
641  "fs",
643  dop,
646  dop);
647  dop->download_timeout_task =
649 }
650 
651 
652 /* 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:51
struct GNUNET_TESTING_Daemon * daemon
Handle to the daemon via testing.
Definition: fs_test_lib.c:129
static void report_uri(void *cls)
Task scheduled to report on the completion of our publish operation.
Definition: fs_test_lib.c:186
char * publish_tmp_file
Name of the temporary file used, or NULL for none.
Definition: fs_test_lib.c:86
static void * publish_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect adapter for publishing operation.
Definition: fs_test_lib.c:319
int do_index
Are we testing indexing? (YES: index, NO: insert, SYSERR: simulate)
Definition: fs_test_lib.c:106
Create file if it doesn&#39;t exist.
void * publish_cont_cls
Closure for publish_cont.
Definition: fs_test_lib.c:61
uint32_t publish_seed
Seed for file generation.
Definition: fs_test_lib.c:71
void GNUNET_FS_publish_stop(struct GNUNET_FS_PublishContext *pc)
Stop an upload.
Definition: fs_publish.c:1558
Context for controlling a download.
Definition: fs_api.h:1768
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1817
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:622
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:1431
Master context for most FS operations.
Definition: fs_api.h:1087
uint64_t size
Size of the file.
Definition: fs_test_lib.c:159
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:245
#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:244
struct GNUNET_FS_ProgressInfo::@28::@30 download
Values for all "GNUNET_FS_STATUS_DOWNLOAD_*" events.
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:164
GNUNET_SCHEDULER_TaskCallback download_cont
Function to call when download is done.
Definition: fs_test_lib.c:134
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
struct GNUNET_FS_PublishContext * publish_context
Context for current publishing operation.
Definition: fs_test_lib.c:76
#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:231
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3163
struct GNUNET_FS_Uri * uri
URI to download.
Definition: fs_test_lib.c:144
GNUNET_FS_TEST_UriContinuation publish_cont
Function to call when upload is done.
Definition: fs_test_lib.c:56
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:2126
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:988
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:3097
No special flags set.
static void publish_timeout(void *cls)
Task scheduled to run when publish operation times out.
Definition: fs_test_lib.c:212
struct GNUNET_FS_Uri * publish_uri
Result URI.
Definition: fs_test_lib.c:81
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:46
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.
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:1246
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
char * GNUNET_DISK_mktemp(const char *t)
Create an (empty) temporary file on disk.
Definition: disk.c:593
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition: gnunet-arm.c:114
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:1049
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:1273
int GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1359
enum GNUNET_FS_Status status
Specific status code (determines the event type).
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:83
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:445
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:2313
struct GNUNET_FS_ProgressInfo::@28::@29 publish
Values for all "GNUNET_FS_STATUS_PUBLISH_*" events.
static char buf[2048]
No options (use defaults for everything).
uint32_t anonymity
Anonymity level used.
Definition: fs_test_lib.c:96
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:2046
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
Handle for controlling a publication process.
Definition: fs_api.h:1198
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:101
unsigned int verbose
Verbosity level of the current operation.
Definition: fs_test_lib.c:174
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
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:169
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:358
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:119
static void * download_connect_adapter(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect adapter for download operation.
Definition: fs_test_lib.c:569
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:235
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:339
struct GNUNET_SCHEDULER_Task * publish_timeout_task
Task to abort publishing (timeout).
Definition: fs_test_lib.c:66
uint64_t size
Size of the file.
Definition: fs_test_lib.c:91
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:1359
configuration data
Definition: configuration.c:85
shared definitions for the FS library
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:168
#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:124
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:139
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_SCHEDULER_Task * download_timeout_task
Task to abort downloading (timeout).
Definition: fs_test_lib.c:149
Handle for a download operation started for testing FS.
Definition: fs_test_lib.c:113
#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:483
struct GNUNET_FS_DownloadContext * download_context
Context for current download operation.
Definition: fs_test_lib.c:154
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:139
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:281
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:592
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:1673
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:527
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:506
#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:965