GNUnet  0.10.x
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2012 Christian Grothoff
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.
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
13  Affero General Public License for more details.
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <>.
18  SPDX-License-Identifier: AGPL3.0-or-later
19 */
29 #include "platform.h"
30 #include "gnunet_fs_service.h"
37 struct Pattern
38 {
42  struct Pattern *next;
47  struct Pattern *prev;
52  void *ctx;
57  void *sctx;
82  unsigned long long x;
87  unsigned long long y;
88 };
94 static int global_ret;
99 static const struct GNUNET_CONFIGURATION_Handle *cfg;
114 static unsigned long long my_peerid;
119 static unsigned long long anonymity_level;
124 static unsigned long long replication_level;
133 static char *publish_pattern;
138 static struct Pattern *publish_head;
143 static struct Pattern *publish_tail;
153 static char *download_pattern;
158 static struct Pattern *download_head;
163 static struct Pattern *download_tail;
175 static int
177  struct Pattern **tail,
178  const char *pattern)
179 {
180  struct Pattern *p;
181  unsigned long long x;
182  unsigned long long y;
183  unsigned long long t;
185  while (3 == sscanf (pattern,
186  "(%llu,%llu,%llu)",
187  &x, &y, &t))
188  {
189  p = GNUNET_new (struct Pattern);
190  p->x = x;
191  p->y = y;
192  p->delay.rel_value_us = (uint64_t) t;
193  GNUNET_CONTAINER_DLL_insert (*head, *tail, p);
194  pattern = strstr (pattern, ")");
195  GNUNET_assert (NULL != pattern);
196  pattern++;
197  }
198  return (0 == strlen (pattern)) ? GNUNET_OK : GNUNET_SYSERR;
199 }
208 static struct GNUNET_FS_Uri *
209 make_keywords (uint64_t kval)
210 {
211  char kw[128];
213  GNUNET_snprintf (kw, sizeof (kw),
214  "%llu", (unsigned long long) kval);
215  return GNUNET_FS_uri_ksk_create (kw, NULL);
216 }
228 static struct GNUNET_FS_FileInformation *
229 make_file (uint64_t length,
230  uint64_t kval,
231  void *ctx)
232 {
233  struct GNUNET_FS_FileInformation *fi;
234  struct GNUNET_FS_BlockOptions bo;
235  char *data;
236  struct GNUNET_FS_Uri *keywords;
237  unsigned long long i;
238  uint64_t xor;
240  data = NULL; /* to make compilers happy */
241  if ( (0 != length) &&
242  (NULL == (data = GNUNET_malloc_large ((size_t) length))) )
243  return NULL;
244  /* initialize data with 'unique' data only depending on 'kval' and 'size',
245  making sure that blocks do not repeat */
246  for (i=0;i<length; i+=8)
247  {
248  xor = length ^ kval ^ (uint64_t) (i / 32 / 1024);
249  GNUNET_memcpy (&data[i], &xor, GNUNET_MIN (length - i, sizeof (uint64_t)));
250  }
252  bo.anonymity_level = (uint32_t) anonymity_level;
253  bo.content_priority = 128;
254  bo.replication_level = (uint32_t) replication_level;
255  keywords = make_keywords (kval);
257  ctx,
258  length,
259  data, keywords,
260  NULL, GNUNET_NO, &bo);
261  GNUNET_FS_uri_destroy (keywords);
262  return fi;
263 }
271 static void
272 shutdown_task (void *cls)
273 {
274  struct Pattern *p;
276  while (NULL != (p = publish_head))
277  {
278  if (NULL != p->task)
280  if (NULL != p->ctx)
282  GNUNET_CONTAINER_DLL_remove (publish_head, publish_tail, p);
283  GNUNET_free (p);
284  }
285  while (NULL != (p = download_head))
286  {
287  if (NULL != p->task)
289  if (NULL != p->stask)
291  if (NULL != p->ctx)
293  if (NULL != p->sctx)
295  GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
296  GNUNET_free (p);
297  }
298  if (NULL != fs_handle)
299  {
300  GNUNET_FS_stop (fs_handle);
301  fs_handle = NULL;
302  }
303  if (NULL != stats_handle)
304  {
305  GNUNET_STATISTICS_destroy (stats_handle, GNUNET_YES);
306  stats_handle = NULL;
307  }
308 }
316 static void
317 publish_stop_task (void *cls)
318 {
319  struct Pattern *p = cls;
321  p->task = NULL;
323 }
331 static void
333 {
334  struct Pattern *p = cls;
336  p->task = NULL;
338 }
346 static void
347 search_stop_task (void *cls)
348 {
349  struct Pattern *p = cls;
351  p->stask = NULL;
353 }
371 static void *
372 progress_cb (void *cls,
373  const struct GNUNET_FS_ProgressInfo *info)
374 {
375  struct Pattern *p;
376  const struct GNUNET_FS_Uri *uri;
378  switch (info->status)
379  {
382  p = info->value.publish.cctx;
383  return p;
385  p = info->value.publish.cctx;
386  return p;
389  "Publishing failed\n");
390  GNUNET_STATISTICS_update (stats_handle,
391  "# failed publish operations", 1, GNUNET_NO);
392  p = info->value.publish.cctx;
394  return p;
396  p = info->value.publish.cctx;
397  GNUNET_STATISTICS_update (stats_handle,
398  "# publishing time (ms)",
400  GNUNET_NO);
402  return p;
404  p = info->value.publish.cctx;
405  p->ctx = NULL;
406  GNUNET_CONTAINER_DLL_remove (publish_head, publish_tail, p);
407  GNUNET_free (p);
408  return NULL;
413  p = info->;
414  return p;
417  "Download failed\n");
418  GNUNET_STATISTICS_update (stats_handle,
419  "# failed downloads", 1, GNUNET_NO);
420  p = info->;
422  return p;
424  p = info->;
425  GNUNET_STATISTICS_update (stats_handle,
426  "# download time (ms)",
428  GNUNET_NO);
430  return p;
432  p = info->;
433  p->ctx = NULL;
434  if (NULL == p->sctx)
435  {
436  GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
437  GNUNET_free (p);
438  }
439  return NULL;
442  p = info->;
443  return p;
445  p = info->;
446  uri = info->;
447  if (GNUNET_YES != GNUNET_FS_uri_test_chk (uri))
448  return NULL; /* not what we want */
449  if (p->y != GNUNET_FS_uri_chk_get_file_size (uri))
450  return NULL; /* not what we want */
451  GNUNET_STATISTICS_update (stats_handle,
452  "# search time (ms)",
454  GNUNET_NO);
456  p->ctx = GNUNET_FS_download_start (fs_handle, uri,
461  p,
462  NULL);
464  return NULL;
467  return NULL; /* don't care */
470  "Search failed\n");
471  GNUNET_STATISTICS_update (stats_handle,
472  "# failed searches", 1, GNUNET_NO);
473  p = info->;
475  return p;
477  p = info->;
478  p->sctx = NULL;
479  if (NULL == p->ctx)
480  {
481  GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
482  GNUNET_free (p);
483  }
484  return NULL;
485  default:
486  /* unexpected event during profiling */
487  GNUNET_break (0);
488  return NULL;
489  }
490 }
498 static void
499 start_publish (void *cls)
500 {
501  struct Pattern *p = cls;
502  struct GNUNET_FS_FileInformation *fi;
504  p->task = NULL;
505  fi = make_file (p->x, p->y, p);
507  p->ctx = GNUNET_FS_publish_start (fs_handle,
508  fi,
511 }
519 static void
520 start_download (void *cls)
521 {
522  struct Pattern *p = cls;
523  struct GNUNET_FS_Uri *keywords;
525  p->task = NULL;
526  keywords = make_keywords (p->x);
528  p->sctx = GNUNET_FS_search_start (fs_handle, keywords,
531  p);
532 }
543 static void
544 run (void *cls, char *const *args GNUNET_UNUSED,
545  const char *cfgfile GNUNET_UNUSED,
546  const struct GNUNET_CONFIGURATION_Handle *cfg_)
547 {
548  char myoptname[128];
549  struct Pattern *p;
551  cfg = cfg_;
552  /* Scheduled the task to clean up when shutdown is called */
554  NULL);
556  if (GNUNET_OK !=
559  &my_peerid))
560  {
562  "TESTBED", "PEERID");
565  return;
566  }
567  if (GNUNET_OK !=
570  &anonymity_level))
571  anonymity_level = 1;
572  if (GNUNET_OK !=
576  replication_level = 1;
577  GNUNET_snprintf (myoptname, sizeof (myoptname),
578  "DOWNLOAD-PATTERN-%u", my_peerid);
579  if (GNUNET_OK !=
581  "FSPROFILER", myoptname,
584  GNUNET_snprintf (myoptname, sizeof (myoptname),
585  "PUBLISH-PATTERN-%u", my_peerid);
586  if (GNUNET_OK !=
588  "FSPROFILER", myoptname,
589  &publish_pattern))
591  if ( (GNUNET_OK !=
592  parse_pattern (&download_head,
593  &download_tail,
594  download_pattern)) ||
595  (GNUNET_OK !=
596  parse_pattern (&publish_head,
597  &publish_tail,
598  publish_pattern)) )
599  {
601  return;
602  }
604  stats_handle = GNUNET_STATISTICS_create ("fsprofiler", cfg);
605  fs_handle =
606  GNUNET_FS_start (cfg,
607  "fsprofiler",
608  &progress_cb, NULL,
613  if (NULL == fs_handle)
614  {
615  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not acquire FS handle. Exiting.\n");
618  return;
619  }
620  for (p = publish_head; NULL != p; p = p->next)
622  &start_publish, p);
623  for (p = download_head; NULL != p; p = p->next)
625  &start_download, p);
626 }
636 int
637 main (int argc, char *const *argv)
638 {
639  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
641  };
643  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
644  return 2;
645  return (GNUNET_OK ==
646  GNUNET_PROGRAM_run (argc, argv, "gnunet-daemon-fsprofiler",
648  ("Daemon to use file-sharing to measure its performance."),
649  options, &run, NULL)) ? global_ret : 1;
650 }
652 /* end of gnunet-daemon-fsprofiler.c */
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
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...
Notification that we have started this download.
struct GNUNET_SCHEDULER_Task * stask
Secondary task to run the operation.
No options (use defaults for everything).
static void * progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
Notification of FS to a client about the progress of an operation.
static struct GNUNET_FS_Uri * make_keywords(uint64_t kval)
Create a KSK URI from a number.
void GNUNET_FS_publish_stop(struct GNUNET_FS_PublishContext *pc)
Stop an upload.
Definition: fs_publish.c:1558
static struct GNUNET_FS_FileInformation * make_file(uint64_t length, uint64_t kval, void *ctx)
Create a file of the given length with a deterministic amount of data to be published under keyword &#39;...
struct GNUNET_FS_ProgressInfo::@28::@31 search
Values for all "GNUNET_FS_STATUS_SEARCH_*" events.
int GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
uint64_t rel_value_us
The actual value.
This search has yielded a result.
Last message from a search; this signals that there will be no further events associated with this se...
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Notification that we are making progress sharing a file structure.
void * ctx
Execution context for the pattern (FS-handle to the operation).
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
int GNUNET_snprintf(char *buf, size_t size, const char *format,...)
Like snprintf, just aborts if the buffer is of insufficient size.
Event generated for each search result when the respective search is stopped.
gcc-ism to document unused arguments
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1293
Master context for most FS operations.
Definition: fs_api.h:1087
unsigned long long y
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1521
static char * download_pattern
String describing which download operations this peer should perform.
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.
struct GNUNET_TIME_Relative delay
With how much delay should this operation be started?
static struct Pattern * download_head
Head of the DLL of publish patterns.
struct GNUNET_FS_FileInformation * GNUNET_FS_file_information_create_from_data(struct GNUNET_FS_Handle *h, void *client_info, uint64_t length, void *data, 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.
struct GNUNET_FS_ProgressInfo::@28::@30 download
Values for all "GNUNET_FS_STATUS_DOWNLOAD_*" events.
Last option in the VARARG list.
First event generated when a client requests a search to begin or when a namespace result automatical...
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition of a command line option.
Information for a file or directory that is about to be published.
Definition: fs_api.h:231
static struct GNUNET_SCHEDULER_Task * t
Main task.
static int global_ret
Return value from &#39;main&#39;.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
We have discovered a new namespace.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we use.
Handle for the service.
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3163
#define GNUNET_malloc_large(size)
Wrapper around malloc.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
We use &#39;patterns&#39; of the form (x,y,t) to specify desired download/publish activities of a peer...
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
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Definition: 002.c:13
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.
Notification that we have stopped the process of uploading a file structure; no futher events will be...
Do not append temporary data to the target file (for the IBlocks).
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).
Notification that we have started to publish a file structure.
static unsigned long long anonymity_level
Desired anonymity level.
struct Pattern * next
Kept in a DLL.
static unsigned long long replication_level
Desired replication level.
static void publish_stop_task(void *cls)
Task run when a publish operation should be stopped.
Notification that this download completed.
static struct GNUNET_STATISTICS_Handle * stats_handle
Handle to the statistics service.
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
char ** keywords
Keywords start with a &#39;+&#39; if they are mandatory (in which case the &#39;+&#39; is NOT part of the keyword) an...
Definition: fs_api.h:188
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
#define GNUNET_memcpy(dst, src, n)
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
Notification that we are making progress sharing a directory.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
struct GNUNET_SCHEDULER_Task * task
Task to run the operation.
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
enum GNUNET_FS_Status status
Specific status code (determines the event type).
int main(int argc, char *const *argv)
Program that performs various "random" FS activities.
struct GNUNET_FS_SearchContext * GNUNET_FS_search_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, uint32_t anonymity, enum GNUNET_FS_SearchOptions options, void *cctx)
Start search for content.
Definition: fs_search.c:1598
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:83
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.
unsigned long long x
static unsigned long long my_peerid
Unique number for this peer in the testbed.
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
struct GNUNET_TIME_Absolute start_time
When did the operation start?
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
int GNUNET_FS_uri_test_chk(const struct GNUNET_FS_Uri *uri)
Is this a file (or directory) URI?
Definition: fs_uri.c:1345
int GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
Notification that this download is no longer actively being pursued (back in the queue).
Definition: gnunet_common.h:79
Notification about progress with this download.
Select the desired amount of parallelism (this option should be followed by an "unsigned int" giving ...
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.
static struct GNUNET_FS_Handle * fs_handle
Peer&#39;s FS handle.
Maximum number of requests that should be pending at a given point in time (invidivual downloads may ...
static struct Pattern * publish_head
Head of the DLL of publish patterns.
static int parse_pattern(struct Pattern **head, struct Pattern **tail, const char *pattern)
Parse a pattern string and store the corresponding &#39;struct Pattern&#39; in the given head/tail.
One day.
static void start_download(void *cls)
Start download operation.
struct GNUNET_FS_Uri * GNUNET_FS_uri_ksk_create(const char *keywords, char **emsg)
Create an FS URI from a single user-supplied string of keywords.
Definition: fs_uri.c:1048
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 download_stop_task(void *cls)
Task run when a download operation should be stopped.
Notification that an error was encountered sharing a file structure.
static void search_stop_task(void *cls)
Task run when a download operation should be stopped.
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
static struct PendingResolutions * head
Head of list of pending resolution requests.
Definition: gnunet-ats.c:231
void * sctx
Secondary execution context for the pattern (FS-handle to the operation).
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:168
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg_)
Main function that will be run by the scheduler.
#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.
static struct PendingResolutions * tail
Tail of list of pending resolution requests.
Definition: gnunet-ats.c:236
Signals a problem with this search.
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:361
We have additional data about the quality or availability of a search result.
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:80
static struct Pattern * publish_tail
Tail of the DLL of publish patterns.
No options (use defaults for everything).
Notification that this download was stopped (final event with respect to this action).
uint32_t data
The data value.
static char * publish_pattern
String describing which publishing operations this peer should perform.
struct Pattern * prev
Kept in a DLL.
void GNUNET_FS_search_stop(struct GNUNET_FS_SearchContext *sc)
Stop search for content.
Definition: fs_search.c:1757
Notification that this download encountered an error.
#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.
#define gettext_noop(String)
Definition: gettext.h:69
static void start_publish(void *cls)
Start publish operation.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
static void shutdown_task(void *cls)
Task run during shutdown.
static struct Pattern * download_tail
Tail of the DLL of publish patterns.