GNUnet 0.21.0
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
31#include "gnunet_fs_service.h"
33
38struct Pattern
39{
43 struct Pattern *next;
44
48 struct Pattern *prev;
49
53 void *ctx;
54
58 void *sctx;
59
64
69
74
79
83 unsigned long long x;
84
88 unsigned long long y;
89};
90
91
95static int global_ret;
96
100static const struct GNUNET_CONFIGURATION_Handle *cfg;
101
106
111
115static unsigned long long my_peerid;
116
120static unsigned long long anonymity_level;
121
125static unsigned long long replication_level;
126
134static char *publish_pattern;
135
139static struct Pattern *publish_head;
140
144static struct Pattern *publish_tail;
145
154static char *download_pattern;
155
159static struct Pattern *download_head;
160
164static struct Pattern *download_tail;
165
166
176static int
177parse_pattern (struct Pattern **head,
178 struct Pattern **tail,
179 const char *pattern)
180{
181 struct Pattern *p;
182 unsigned long long x;
183 unsigned long long y;
184 unsigned long long t;
185
186 while (3 == sscanf (pattern,
187 "(%llu,%llu,%llu)",
188 &x, &y, &t))
189 {
190 p = GNUNET_new (struct Pattern);
191 p->x = x;
192 p->y = y;
193 p->delay.rel_value_us = (uint64_t) t;
194 GNUNET_CONTAINER_DLL_insert (*head, *tail, p);
195 pattern = strstr (pattern, ")");
196 GNUNET_assert (NULL != pattern);
197 pattern++;
198 }
199 return (0 == strlen (pattern)) ? GNUNET_OK : GNUNET_SYSERR;
200}
201
202
209static struct GNUNET_FS_Uri *
210make_keywords (uint64_t kval)
211{
212 char kw[128];
213
214 GNUNET_snprintf (kw, sizeof(kw),
215 "%llu", (unsigned long long) kval);
216 return GNUNET_FS_uri_ksk_create (kw, NULL);
217}
218
219
229static struct GNUNET_FS_FileInformation *
230make_file (uint64_t length,
231 uint64_t kval,
232 void *ctx)
233{
234 struct GNUNET_FS_FileInformation *fi;
236 char *data;
237 struct GNUNET_FS_Uri *keywords;
238 unsigned long long i;
239 uint64_t xor;
240
241 data = NULL; /* to make compilers happy */
242 if ((0 != length) &&
243 (NULL == (data = GNUNET_malloc_large ((size_t) length))))
244 return NULL;
245 /* initialize data with 'unique' data only depending on 'kval' and 'size',
246 making sure that blocks do not repeat */
247 for (i = 0; i < length; i += 8)
248 {
249 xor = length ^ kval ^ (uint64_t) (i / 32 / 1024);
250 GNUNET_memcpy (&data[i], &xor, GNUNET_MIN (length - i, sizeof(uint64_t)));
251 }
254 bo.content_priority = 128;
256 keywords = make_keywords (kval);
258 ctx,
259 length,
260 data, keywords,
261 NULL, GNUNET_NO, &bo);
263 return fi;
264}
265
266
272static void
273shutdown_task (void *cls)
274{
275 struct Pattern *p;
276
277 while (NULL != (p = publish_head))
278 {
279 if (NULL != p->task)
281 if (NULL != p->ctx)
284 GNUNET_free (p);
285 }
286 while (NULL != (p = download_head))
287 {
288 if (NULL != p->task)
290 if (NULL != p->stask)
291 GNUNET_SCHEDULER_cancel (p->stask);
292 if (NULL != p->ctx)
294 if (NULL != p->sctx)
295 GNUNET_FS_search_stop (p->sctx);
297 GNUNET_free (p);
298 }
299 if (NULL != fs_handle)
300 {
302 fs_handle = NULL;
303 }
304 if (NULL != stats_handle)
305 {
307 stats_handle = NULL;
308 }
309}
310
311
317static void
319{
320 struct Pattern *p = cls;
321
322 p->task = NULL;
324}
325
326
332static void
334{
335 struct Pattern *p = cls;
336
337 p->task = NULL;
339}
340
341
347static void
349{
350 struct Pattern *p = cls;
351
352 p->stask = NULL;
353 GNUNET_FS_search_stop (p->sctx);
354}
355
356
372static void *
373progress_cb (void *cls,
374 const struct GNUNET_FS_ProgressInfo *info)
375{
376 struct Pattern *p;
377 const struct GNUNET_FS_Uri *uri;
378
379 switch (info->status)
380 {
383 p = info->value.publish.cctx;
384 return p;
385
387 p = info->value.publish.cctx;
388 return p;
389
392 "Publishing failed\n");
394 "# failed publish operations", 1, GNUNET_NO);
395 p = info->value.publish.cctx;
397 return p;
398
400 p = info->value.publish.cctx;
402 "# publishing time (ms)",
404 p->start_time).rel_value_us / 1000LL,
405 GNUNET_NO);
407 return p;
408
410 p = info->value.publish.cctx;
411 p->ctx = NULL;
413 GNUNET_free (p);
414 return NULL;
415
420 p = info->value.download.cctx;
421 return p;
422
425 "Download failed\n");
427 "# failed downloads", 1, GNUNET_NO);
428 p = info->value.download.cctx;
430 return p;
431
433 p = info->value.download.cctx;
435 "# download time (ms)",
437 p->start_time).rel_value_us / 1000LL,
438 GNUNET_NO);
440 return p;
441
443 p = info->value.download.cctx;
444 p->ctx = NULL;
445 if (NULL == p->sctx)
446 {
448 GNUNET_free (p);
449 }
450 return NULL;
451
454 p = info->value.search.cctx;
455 return p;
456
458 p = info->value.search.cctx;
459 uri = info->value.search.specifics.result.uri;
461 return NULL; /* not what we want */
463 return NULL; /* not what we want */
465 "# search time (ms)",
467 p->start_time).rel_value_us / 1000LL,
468 GNUNET_NO);
469 p->start_time = GNUNET_TIME_absolute_get ();
471 NULL, NULL, NULL,
475 p,
476 NULL);
478 return NULL;
479
482 return NULL; /* don't care */
483
486 "Search failed\n");
488 "# failed searches", 1, GNUNET_NO);
489 p = info->value.search.cctx;
491 return p;
492
494 p = info->value.search.cctx;
495 p->sctx = NULL;
496 if (NULL == p->ctx)
497 {
499 GNUNET_free (p);
500 }
501 return NULL;
502
503 default:
504 /* unexpected event during profiling */
505 GNUNET_break (0);
506 return NULL;
507 }
508}
509
510
516static void
517start_publish (void *cls)
518{
519 struct Pattern *p = cls;
520 struct GNUNET_FS_FileInformation *fi;
521
522 p->task = NULL;
523 fi = make_file (p->x, p->y, p);
524 p->start_time = GNUNET_TIME_absolute_get ();
526 fi,
527 NULL, NULL, NULL,
529}
530
531
537static void
538start_download (void *cls)
539{
540 struct Pattern *p = cls;
541 struct GNUNET_FS_Uri *keywords;
542
543 p->task = NULL;
544 keywords = make_keywords (p->x);
545 p->start_time = GNUNET_TIME_absolute_get ();
549 p);
550}
551
552
561static void
562run (void *cls, char *const *args GNUNET_UNUSED,
563 const char *cfgfile GNUNET_UNUSED,
564 const struct GNUNET_CONFIGURATION_Handle *cfg_)
565{
566 char myoptname[128];
567 struct Pattern *p;
568
569 cfg = cfg_;
570 /* Scheduled the task to clean up when shutdown is called */
572 NULL);
573
574 if (GNUNET_OK !=
576 "TESTBED", "PEERID",
577 &my_peerid))
578 {
580 "TESTBED", "PEERID");
583 return;
584 }
585 if (GNUNET_OK !=
587 "FSPROFILER", "ANONYMITY_LEVEL",
589 anonymity_level = 1;
590 if (GNUNET_OK !=
592 "FSPROFILER", "REPLICATION_LEVEL",
595 GNUNET_snprintf (myoptname, sizeof(myoptname),
596 "DOWNLOAD-PATTERN-%llu", my_peerid);
597 if (GNUNET_OK !=
599 "FSPROFILER", myoptname,
602 GNUNET_snprintf (myoptname, sizeof(myoptname),
603 "PUBLISH-PATTERN-%llu", my_peerid);
604 if (GNUNET_OK !=
606 "FSPROFILER", myoptname,
609 if ((GNUNET_OK !=
613 (GNUNET_OK !=
617 {
619 return;
620 }
621
622 stats_handle = GNUNET_STATISTICS_create ("fsprofiler", cfg);
623 fs_handle =
625 "fsprofiler",
626 &progress_cb, NULL,
631 if (NULL == fs_handle)
632 {
634 "Could not acquire FS handle. Exiting.\n");
637 return;
638 }
639 for (p = publish_head; NULL != p; p = p->next)
640 p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
641 &start_publish, p);
642 for (p = download_head; NULL != p; p = p->next)
643 p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
644 &start_download, p);
645}
646
647
655int
656main (int argc, char *const *argv)
657{
658 static const struct GNUNET_GETOPT_CommandLineOption options[] = {
660 };
661
662 if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
663 return 2;
664 return (GNUNET_OK ==
665 GNUNET_PROGRAM_run (argc, argv, "gnunet-daemon-fsprofiler",
667 (
668 "Daemon to use file-sharing to measure its performance."),
669 options, &run, NULL)) ? global_ret : 1;
670}
671
672
673/* 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:70
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 char * publish_pattern
String describing which publishing operations this peer should perform.
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 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 void shutdown_task(void *cls)
Task run during shutdown.
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 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 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 GNUNET_FS_Uri * make_keywords(uint64_t kval)
Create a KSK URI from a number.
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.
static char * data
The data to insert into the dht.
static struct GNUNET_FS_Handle * ctx
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.
#define info
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
static struct GNUNET_SCHEDULER_Task * t
Main task.
API for file sharing via GNUnet.
API to create, modify and access statistics.
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.
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:1443
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:1360
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:1049
struct GNUNET_FS_DownloadContext * GNUNET_FS_download_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_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:2099
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:3244
void GNUNET_FS_search_stop(struct GNUNET_FS_SearchContext *sc)
Stop search for content.
Definition: fs_search.c:1766
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:677
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:2253
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_FS_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
Create an entry for a file in a publish-structure.
int GNUNET_FS_uri_test_chk(const struct GNUNET_FS_Uri *uri)
Is this a file (or directory) URI?
Definition: fs_uri.c:1346
void GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
Close our connection with the file-sharing service.
Definition: fs_api.c:3310
void GNUNET_FS_publish_stop(struct GNUNET_FS_PublishContext *pc)
Stop a publication.
Definition: fs_publish.c:1571
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:1607
@ 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_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.
#define GNUNET_MIN(a, b)
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#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:400
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:562
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:1334
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
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:1299
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:1272
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:1230
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:436
#define GNUNET_TIME_UNIT_DAYS
One day.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
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:316
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:228
Master context for most FS operations.
Definition: fs_api.h:1070
Argument given to the progress callback with information about what is going on.
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:167
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:186
Definition of a command line option.
Entry in list of pending tasks.
Definition: scheduler.c:136
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.