GNUnet  0.11.x
gnunet-daemon-fsprofiler.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2012 Christian Grothoff
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 "gnunet_fs_service.h"
32 
37 struct Pattern
38 {
42  struct Pattern *next;
43 
47  struct Pattern *prev;
48 
52  void *ctx;
53 
57  void *sctx;
58 
63 
68 
73 
78 
82  unsigned long long x;
83 
87  unsigned long long y;
88 };
89 
90 
94 static int global_ret;
95 
99 static const struct GNUNET_CONFIGURATION_Handle *cfg;
100 
105 
110 
114 static unsigned long long my_peerid;
115 
119 static unsigned long long anonymity_level;
120 
124 static unsigned long long replication_level;
125 
133 static char *publish_pattern;
134 
138 static struct Pattern *publish_head;
139 
143 static struct Pattern *publish_tail;
144 
153 static char *download_pattern;
154 
158 static struct Pattern *download_head;
159 
163 static struct Pattern *download_tail;
164 
165 
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;
184 
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;
194  pattern = strstr (pattern, ")");
195  GNUNET_assert (NULL != pattern);
196  pattern++;
197  }
198  return (0 == strlen (pattern)) ? GNUNET_OK : GNUNET_SYSERR;
199 }
200 
201 
208 static struct GNUNET_FS_Uri *
209 make_keywords (uint64_t kval)
210 {
211  char kw[128];
212 
213  GNUNET_snprintf (kw, sizeof(kw),
214  "%llu", (unsigned long long) kval);
215  return GNUNET_FS_uri_ksk_create (kw, NULL);
216 }
217 
218 
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;
239 
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;
255  keywords = make_keywords (kval);
257  ctx,
258  length,
259  data, keywords,
260  NULL, GNUNET_NO, &bo);
262  return fi;
263 }
264 
265 
271 static void
272 shutdown_task (void *cls)
273 {
274  struct Pattern *p;
275 
276  while (NULL != (p = publish_head))
277  {
278  if (NULL != p->task)
279  GNUNET_SCHEDULER_cancel (p->task);
280  if (NULL != p->ctx)
281  GNUNET_FS_publish_stop (p->ctx);
283  GNUNET_free (p);
284  }
285  while (NULL != (p = download_head))
286  {
287  if (NULL != p->task)
288  GNUNET_SCHEDULER_cancel (p->task);
289  if (NULL != p->stask)
290  GNUNET_SCHEDULER_cancel (p->stask);
291  if (NULL != p->ctx)
293  if (NULL != p->sctx)
294  GNUNET_FS_search_stop (p->sctx);
296  GNUNET_free (p);
297  }
298  if (NULL != fs_handle)
299  {
301  fs_handle = NULL;
302  }
303  if (NULL != stats_handle)
304  {
306  stats_handle = NULL;
307  }
308 }
309 
310 
316 static void
317 publish_stop_task (void *cls)
318 {
319  struct Pattern *p = cls;
320 
321  p->task = NULL;
322  GNUNET_FS_publish_stop (p->ctx);
323 }
324 
325 
331 static void
333 {
334  struct Pattern *p = cls;
335 
336  p->task = NULL;
338 }
339 
340 
346 static void
347 search_stop_task (void *cls)
348 {
349  struct Pattern *p = cls;
350 
351  p->stask = NULL;
352  GNUNET_FS_search_stop (p->sctx);
353 }
354 
355 
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;
377 
378  switch (info->status)
379  {
382  p = info->value.publish.cctx;
383  return p;
384 
386  p = info->value.publish.cctx;
387  return p;
388 
391  "Publishing failed\n");
393  "# failed publish operations", 1, GNUNET_NO);
394  p = info->value.publish.cctx;
396  return p;
397 
399  p = info->value.publish.cctx;
401  "# publishing time (ms)",
403  p->start_time).rel_value_us / 1000LL,
404  GNUNET_NO);
406  return p;
407 
409  p = info->value.publish.cctx;
410  p->ctx = NULL;
412  GNUNET_free (p);
413  return NULL;
414 
419  p = info->value.download.cctx;
420  return p;
421 
424  "Download failed\n");
426  "# failed downloads", 1, GNUNET_NO);
427  p = info->value.download.cctx;
429  return p;
430 
432  p = info->value.download.cctx;
434  "# download time (ms)",
436  p->start_time).rel_value_us / 1000LL,
437  GNUNET_NO);
439  return p;
440 
442  p = info->value.download.cctx;
443  p->ctx = NULL;
444  if (NULL == p->sctx)
445  {
447  GNUNET_free (p);
448  }
449  return NULL;
450 
453  p = info->value.search.cctx;
454  return p;
455 
457  p = info->value.search.cctx;
458  uri = info->value.search.specifics.result.uri;
460  return NULL; /* not what we want */
462  return NULL; /* not what we want */
464  "# search time (ms)",
466  p->start_time).rel_value_us / 1000LL,
467  GNUNET_NO);
468  p->start_time = GNUNET_TIME_absolute_get ();
470  NULL, NULL, NULL,
474  p,
475  NULL);
477  return NULL;
478 
481  return NULL; /* don't care */
482 
485  "Search failed\n");
487  "# failed searches", 1, GNUNET_NO);
488  p = info->value.search.cctx;
490  return p;
491 
493  p = info->value.search.cctx;
494  p->sctx = NULL;
495  if (NULL == p->ctx)
496  {
498  GNUNET_free (p);
499  }
500  return NULL;
501 
502  default:
503  /* unexpected event during profiling */
504  GNUNET_break (0);
505  return NULL;
506  }
507 }
508 
509 
515 static void
516 start_publish (void *cls)
517 {
518  struct Pattern *p = cls;
519  struct GNUNET_FS_FileInformation *fi;
520 
521  p->task = NULL;
522  fi = make_file (p->x, p->y, p);
523  p->start_time = GNUNET_TIME_absolute_get ();
525  fi,
526  NULL, NULL, NULL,
528 }
529 
530 
536 static void
537 start_download (void *cls)
538 {
539  struct Pattern *p = cls;
540  struct GNUNET_FS_Uri *keywords;
541 
542  p->task = NULL;
543  keywords = make_keywords (p->x);
544  p->start_time = GNUNET_TIME_absolute_get ();
548  p);
549 }
550 
551 
560 static void
561 run (void *cls, char *const *args GNUNET_UNUSED,
562  const char *cfgfile GNUNET_UNUSED,
563  const struct GNUNET_CONFIGURATION_Handle *cfg_)
564 {
565  char myoptname[128];
566  struct Pattern *p;
567 
568  cfg = cfg_;
569  /* Scheduled the task to clean up when shutdown is called */
571  NULL);
572 
573  if (GNUNET_OK !=
575  "TESTBED", "PEERID",
576  &my_peerid))
577  {
579  "TESTBED", "PEERID");
582  return;
583  }
584  if (GNUNET_OK !=
586  "FSPROFILER", "ANONYMITY_LEVEL",
587  &anonymity_level))
588  anonymity_level = 1;
589  if (GNUNET_OK !=
591  "FSPROFILER", "REPLICATION_LEVEL",
593  replication_level = 1;
594  GNUNET_snprintf (myoptname, sizeof(myoptname),
595  "DOWNLOAD-PATTERN-%llu", my_peerid);
596  if (GNUNET_OK !=
598  "FSPROFILER", myoptname,
601  GNUNET_snprintf (myoptname, sizeof(myoptname),
602  "PUBLISH-PATTERN-%llu", my_peerid);
603  if (GNUNET_OK !=
605  "FSPROFILER", myoptname,
606  &publish_pattern))
608  if ((GNUNET_OK !=
610  &download_tail,
611  download_pattern)) ||
612  (GNUNET_OK !=
614  &publish_tail,
615  publish_pattern)))
616  {
618  return;
619  }
620 
621  stats_handle = GNUNET_STATISTICS_create ("fsprofiler", cfg);
622  fs_handle =
624  "fsprofiler",
625  &progress_cb, NULL,
630  if (NULL == fs_handle)
631  {
633  "Could not acquire FS handle. Exiting.\n");
636  return;
637  }
638  for (p = publish_head; NULL != p; p = p->next)
639  p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
640  &start_publish, p);
641  for (p = download_head; NULL != p; p = p->next)
642  p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
643  &start_download, p);
644 }
645 
646 
654 int
655 main (int argc, char *const *argv)
656 {
657  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
659  };
660 
661  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
662  return 2;
663  return (GNUNET_OK ==
664  GNUNET_PROGRAM_run (argc, argv, "gnunet-daemon-fsprofiler",
666  (
667  "Daemon to use file-sharing to measure its performance."),
668  options, &run, NULL)) ? global_ret : 1;
669 }
670 
671 
672 /* end of gnunet-daemon-fsprofiler.c */
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:69
static struct PendingResolutions * tail
Tail of list of pending resolution requests.
Definition: gnunet-ats.c:235
static struct PendingResolutions * head
Head of list of pending resolution requests.
Definition: gnunet-ats.c:230
static void publish_stop_task(void *cls)
Task run when a publish operation should be stopped.
static struct Pattern * download_tail
Tail of the DLL of publish patterns.
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 '...
static char * publish_pattern
String describing which publishing operations this peer should perform.
static struct GNUNET_FS_Uri * make_keywords(uint64_t kval)
Create a KSK URI from a number.
static int global_ret
Return value from 'main'.
static char * download_pattern
String describing which download operations this peer should perform.
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.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we use.
static void shutdown_task(void *cls)
Task run during shutdown.
static struct Pattern * publish_head
Head of the DLL of publish patterns.
static struct GNUNET_STATISTICS_Handle * stats_handle
Handle to the statistics service.
static void start_download(void *cls)
Start download operation.
static unsigned long long my_peerid
Unique number for this peer in the testbed.
static unsigned long long replication_level
Desired replication level.
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 unsigned long long anonymity_level
Desired anonymity level.
static int parse_pattern(struct Pattern **head, struct Pattern **tail, const char *pattern)
Parse a pattern string and store the corresponding 'struct Pattern' in the given head/tail.
static struct Pattern * publish_tail
Tail of the DLL of publish patterns.
static void search_stop_task(void *cls)
Task run when a download operation should be stopped.
static struct Pattern * download_head
Head of the DLL of publish patterns.
static struct GNUNET_FS_Handle * fs_handle
Peer's FS handle.
int main(int argc, char *const *argv)
Program that performs various "random" FS activities.
static void start_publish(void *cls)
Start publish operation.
static void download_stop_task(void *cls)
Task run when a download operation should be stopped.
uint32_t data
The data value.
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
static struct GNUNET_FS_BlockOptions bo
Options we set for published blocks.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
static struct GNUNET_SCHEDULER_Task * t
Main task.
#define GNUNET_log(kind,...)
#define GNUNET_UNUSED
gcc-ism to document unused arguments
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
#define GNUNET_MIN(a, b)
enum GNUNET_GenericReturnValue 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.
enum GNUNET_GenericReturnValue 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.
#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.
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:1370
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_ksk_create(const char *keywords, char **emsg)
Create an FS URI from a single user-supplied string of keywords.
Definition: fs_uri.c:1059
void GNUNET_FS_search_stop(struct GNUNET_FS_SearchContext *sc)
Stop search for content.
Definition: fs_search.c:1778
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
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:678
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
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_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:3263
int GNUNET_FS_uri_test_chk(const struct GNUNET_FS_Uri *uri)
Is this a file (or directory) URI?
Definition: fs_uri.c:1356
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3338
void GNUNET_FS_publish_stop(struct GNUNET_FS_PublishContext *pc)
Stop an upload.
Definition: fs_publish.c:1570
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:1619
@ GNUNET_FS_FLAGS_NONE
No special flags set.
@ GNUNET_FS_SEARCH_OPTION_NONE
No options (use defaults for everything).
@ GNUNET_FS_DOWNLOAD_NO_TEMPORARIES
Do not append temporary data to the target file (for the IBlocks).
@ GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM
Select the desired amount of parallelism (this option should be followed by an "unsigned int" giving ...
@ GNUNET_FS_OPTIONS_END
Last option in the VARARG list.
@ GNUNET_FS_OPTIONS_REQUEST_PARALLELISM
Maximum number of requests that should be pending at a given point in time (invidivual downloads may ...
@ GNUNET_FS_STATUS_SEARCH_UPDATE
We have additional data about the quality or availability of a search result.
@ GNUNET_FS_STATUS_DOWNLOAD_INACTIVE
Notification that this download is no longer actively being pursued (back in the queue).
@ GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE
We have discovered a new namespace.
@ GNUNET_FS_STATUS_DOWNLOAD_ERROR
Notification that this download encountered an error.
@ GNUNET_FS_STATUS_SEARCH_ERROR
Signals a problem with this search.
@ GNUNET_FS_STATUS_DOWNLOAD_COMPLETED
Notification that this download completed.
@ GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED
Event generated for each search result when the respective search is stopped.
@ GNUNET_FS_STATUS_PUBLISH_STOPPED
Notification that we have stopped the process of uploading a file structure; no further events will b...
@ GNUNET_FS_STATUS_PUBLISH_ERROR
Notification that an error was encountered sharing a file structure.
@ GNUNET_FS_STATUS_SEARCH_RESULT
This search has yielded a result.
@ GNUNET_FS_STATUS_PUBLISH_PROGRESS
Notification that we are making progress sharing a file structure.
@ GNUNET_FS_STATUS_DOWNLOAD_START
Notification that we have started this download.
@ GNUNET_FS_STATUS_DOWNLOAD_PROGRESS
Notification about progress with this download.
@ GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY
Notification that we are making progress sharing a directory.
@ GNUNET_FS_STATUS_PUBLISH_START
Notification that we have started to publish a file structure.
@ GNUNET_FS_STATUS_PUBLISH_COMPLETED
Notification that we completed sharing a file structure.
@ GNUNET_FS_STATUS_SEARCH_START
First event generated when a client requests a search to begin or when a namespace result automatical...
@ GNUNET_FS_STATUS_DOWNLOAD_ACTIVE
Notification that this download is now actively being pursued (as opposed to waiting in the queue).
@ GNUNET_FS_STATUS_DOWNLOAD_STOPPED
Notification that this download was stopped (final event with respect to this action).
@ GNUNET_FS_STATUS_SEARCH_STOPPED
Last message from a search; this signals that there will be no further events associated with this se...
@ GNUNET_FS_PUBLISH_OPTION_NONE
No options (use defaults for everything).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_malloc_large(size)
Wrapper around malloc.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
enum GNUNET_GenericReturnValue 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,...
Definition: program.c:364
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
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:1296
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,...
Definition: scheduler.c:1331
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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:1269
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1209
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:263
#define GNUNET_TIME_UNIT_DAYS
One day.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:86
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:181
Settings for publishing a block (which may of course also apply to an entire directory or file).
uint32_t anonymity_level
At which anonymity level should the block be shared? (0: no anonymity, 1: normal GAP,...
uint32_t content_priority
How important is it for us to store the block? If we run out of space, the highest-priority,...
uint32_t replication_level
How often should we try to migrate the block to other peers? Only used if "CONTENT_PUSHING" is set to...
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...
Information for a file or directory that is about to be published.
Definition: fs_api.h:227
Master context for most FS operations.
Definition: fs_api.h:1069
Argument given to the progress callback with information about what is going on.
struct GNUNET_FS_ProgressInfo::@25::GNUNET_FS_DownloadStatusEvent download
union GNUNET_FS_ProgressInfo::@25 value
Values that depend on the event type.
struct GNUNET_FS_ProgressInfo::@25::GNUNET_FS_SearchStatusEvent search
enum GNUNET_FS_Status status
Specific status code (determines the event type).
struct GNUNET_FS_ProgressInfo::@25::GNUNET_FS_PublishStatusEvent publish
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:166
char ** keywords
Keywords start with a '+' if they are mandatory (in which case the '+' is NOT part of the keyword) an...
Definition: fs_api.h:185
Definition of a command line option.
Entry in list of pending tasks.
Definition: scheduler.c:135
Handle for the service.
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
We use 'patterns' of the form (x,y,t) to specify desired download/publish activities of a peer.
void * ctx
Execution context for the pattern (FS-handle to the operation).
void * sctx
Secondary execution context for the pattern (FS-handle to the operation).
struct GNUNET_TIME_Relative delay
With how much delay should this operation be started?
unsigned long long y
Y-value.
struct GNUNET_SCHEDULER_Task * stask
Secondary task to run the operation.
struct GNUNET_TIME_Absolute start_time
When did the operation start?
unsigned long long x
X-value.
struct Pattern * prev
Kept in a DLL.
struct GNUNET_SCHEDULER_Task * task
Task to run the operation.
struct Pattern * next
Kept in a DLL.