GNUnet 0.21.0
gnunet-namestore-zonefile.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2012, 2013, 2014, 2019, 2022 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 */
26#include "platform.h"
27#include <gnunet_util_lib.h>
29
30#define MAX_RECORDS_PER_NAME 50
31
35#define MAX_ZONEFILE_LINE_LEN 4096
36
40#define MAX_ZONEFILE_RECORD_DATA_LEN 2048
41
47
52
57
61static unsigned int rd_count = 0;
62
66static int ret = 0;
67
71static char *ego_name = NULL;
72
76static char *res;
77
81static unsigned int published_sets = 0;
82
86static unsigned int published_records = 0;
87
88
93
98
103
108
113
118
122static const struct GNUNET_CONFIGURATION_Handle *cfg;
123
128
132static int state;
133
135{
136
137 /* Uninitialized */
139
140 /* The initial state */
142
143 /* The $ORIGIN has changed */
145
146 /* The record name/label has changed */
148
150
151
152
158static void
159do_shutdown (void *cls)
160{
161 (void) cls;
162 if (NULL != ego_name)
164 if (NULL != el)
165 {
167 el = NULL;
168 }
169 if (NULL != ns_qe)
171 if (NULL != id_op)
173 if (NULL != ns)
175 if (NULL != id)
177 for (int i = 0; i < rd_count; i++)
178 {
179 void *rd_ptr = (void*) rd[i].data;
180 GNUNET_free (rd_ptr);
181 }
182 if (NULL != parse_task)
184}
185
186static void
187parse (void *cls);
188
189static char*
190trim (char *line)
191{
192 char *ltrimmed = line;
193 int ltrimmed_len;
194 int quoted = 0;
195
196 // Trim all whitespace to the left
197 while (*ltrimmed == ' ')
198 ltrimmed++;
199 ltrimmed_len = strlen (ltrimmed);
200 // Find the first occurence of an unqoted ';', which is our comment
201 for (int i = 0; i < ltrimmed_len; i++)
202 {
203 if (ltrimmed[i] == '"')
204 quoted = ! quoted;
205 if ((ltrimmed[i] != ';') || quoted)
206 continue;
207 ltrimmed[i] = '\0';
208 }
209 ltrimmed_len = strlen (ltrimmed);
210 // Remove trailing whitespace
211 for (int i = ltrimmed_len; i > 0; i--)
212 {
213 if (ltrimmed[i - 1] != ' ')
214 break;
215 ltrimmed[i - 1] = '\0';
216 }
217 ltrimmed_len = strlen (ltrimmed);
218 if (ltrimmed[ltrimmed_len - 1] == '\n')
219 ltrimmed[ltrimmed_len - 1] = ' ';
220 return ltrimmed;
221}
222
223static char*
224next_token (char *token)
225{
226 char *next = token;
227 while (*next == ' ')
228 next++;
229 return next;
230}
231
232static int
233parse_ttl (char *token, struct GNUNET_TIME_Relative *ttl)
234{
235 char *next;
236 unsigned int ttl_tmp;
237
238 next = strchr (token, ';');
239 if (NULL != next)
240 next[0] = '\0';
241 next = strchr (token, ' ');
242 if (NULL != next)
243 next[0] = '\0';
244 if (1 != sscanf (token, "%u", &ttl_tmp))
245 {
246 fprintf (stderr, "Unable to parse TTL `%s'\n", token);
247 return GNUNET_SYSERR;
248 }
249 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TTL is: %u\n", ttl_tmp);
250 ttl->rel_value_us = ttl_tmp * 1000 * 1000;
251 return GNUNET_OK;
252}
253
254static int
255parse_origin (char *token, char *origin)
256{
257 char *next;
258 next = strchr (token, ';');
259 if (NULL != next)
260 next[0] = '\0';
261 next = strchr (token, ' ');
262 if (NULL != next)
263 next[0] = '\0';
264 strcpy (origin, token);
265 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Origin is: %s\n", origin);
266 return GNUNET_OK;
267}
268
269static void
271 enum GNUNET_ErrorCode ec)
272{
273 id_op = NULL;
274 if (GNUNET_EC_NONE != ec)
275 {
276 fprintf (stderr, "Error: %s\n", GNUNET_ErrorCode_get_hint (ec));
277 ret = 1;
279 return;
280 }
282 zone_pkey = *pk;
284}
285
286static void
287origin_lookup_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego)
288{
289
290 el = NULL;
291
292 if (NULL == ego)
293 {
295 "$ORIGIN %s does not exist, creating...\n", ego_name);
297 GNUNET_PUBLIC_KEY_TYPE_ECDSA, // FIXME make configurable
299 NULL);
300 return;
301 }
305}
306
307static void
309{
310 ns_qe = NULL;
311 if (GNUNET_EC_NONE != ec)
312 {
313 fprintf (stderr,
314 _ ("Failed to store records...\n"));
316 ret = -1;
317 }
319 {
320 if (NULL != ego_name)
323 if (ego_name[strlen (ego_name) - 1] == '.')
324 ego_name[strlen (ego_name) - 1] = '\0';
326 "Changing origin to %s\n", ego_name);
328 &origin_lookup_cb, NULL);
329 return;
330 }
332}
333
334
335
352static void
353parse (void *cls)
354{
355 char buf[MAX_ZONEFILE_LINE_LEN];
357 char *next;
358 char *token;
359 char *payload_pos;
360 static char lastname[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
362 void *data;
363 size_t data_size;
364 int ttl_line = 0;
365 int type;
366 int bracket_unclosed = 0;
367 int quoted = 0;
368
369 parse_task = NULL;
370 /* use filename provided as 1st argument (stdin by default) */
371 int ln = 0;
372 while ((res = fgets (buf, sizeof(buf), stdin))) /* read each line of input */
373 {
374 ln++;
375 ttl_line = 0;
376 token = trim (buf);
378 "Trimmed line (bracket %s): `%s'\n",
379 (bracket_unclosed > 0) ? "unclosed" : "closed",
380 token);
381 if ((0 == strlen (token)) ||
382 ((1 == strlen (token)) && (' ' == *token)))
383 continue; // I guess we can safely ignore blank lines
384 if (bracket_unclosed == 0)
385 {
386 /* Payload is already parsed */
387 payload_pos = payload;
388 /* Find space */
389 next = strchr (token, ' ');
390 if (NULL == next)
391 {
392 fprintf (stderr, "Error at line %u: %s\n", ln, token);
393 ret = 1;
395 return;
396 }
397 next[0] = '\0';
398 next++;
399 if (0 == (strcmp (token, "$ORIGIN")))
400 {
402 token = next_token (next);
403 }
404 else if (0 == (strcmp (token, "$TTL")))
405 {
406 ttl_line = 1;
407 token = next_token (next);
408 }
409 else
410 {
411 if (0 == strcmp (token, "IN")) // Inherit name from before
412 {
414 "Old name: %s\n", lastname);
415 strcpy (newname, lastname);
416 token[strlen (token)] = ' ';
417 }
418 else if (token[strlen (token) - 1] != '.') // no fqdn
419 {
420 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New name: %s\n", token);
421 if (GNUNET_DNSPARSER_MAX_LABEL_LENGTH < strlen (token))
422 {
423 fprintf (stderr,
424 _ ("Name `%s' is too long\n"),
425 token);
426 ret = 1;
428 return;
429 }
430 strcpy (newname, token);
431 token = next_token (next);
432 }
433 else if (0 == strcmp (token, origin))
434 {
435 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New name: @\n");
436 strcpy (newname, "@");
437 token = next_token (next);
438 }
439 else
440 {
441 if (strlen (token) < strlen (origin))
442 {
443 fprintf (stderr, "Wrong origin: %s (expected %s)\n", token, origin);
444 break; // FIXME error?
445 }
446 if (0 != strcmp (token + (strlen (token) - strlen (origin)), origin))
447 {
448 fprintf (stderr, "Wrong origin: %s (expected %s)\n", token, origin);
449 break;
450 }
451 token[strlen (token) - strlen (origin) - 1] = '\0';
452 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New name: %s\n", token);
453 if (GNUNET_DNSPARSER_MAX_LABEL_LENGTH < strlen (token))
454 {
455 fprintf (stderr,
456 _ ("Name `%s' is too long\n"),
457 token);
458 ret = 1;
460 return;
461 }
462 strcpy (newname, token);
463 token = next_token (next);
464 }
465 if (0 != strcmp (newname, lastname) &&
466 (0 < rd_count))
467 {
469 "Name changed %s->%s, storing record set of %u elements\n",
470 lastname, newname,
471 rd_count);
473 }
474 else {
475 strcpy (lastname, newname);
476 }
477 }
478
479 if (ttl_line)
480 {
481 if (GNUNET_SYSERR == parse_ttl (token, &ttl))
482 {
483 fprintf (stderr, _ ("Failed to parse $TTL\n"));
484 ret = 1;
486 return;
487 }
488 continue;
489 }
491 {
492 if (GNUNET_SYSERR == parse_origin (token, origin))
493 {
494 fprintf (stderr, _ ("Failed to parse $ORIGIN from %s\n"), token);
495 ret = 1;
497 return;
498 }
499 break;
500 }
501 if (ZS_READY == state)
502 {
503 fprintf (stderr,
504 _ (
505 "You must provide $ORIGIN in your zonefile or via arguments (--zone)!\n"));
506 ret = 1;
508 return;
509 }
510 // This is a record, let's go
512 {
513 fprintf (stderr,
514 _ ("Only %u records per unique name supported.\n"),
516 ret = 1;
518 return;
519 }
522 next = strchr (token, ' ');
523 if (NULL == next)
524 {
525 fprintf (stderr, "Error, last token: %s\n", token);
526 ret = 1;
528 break;
529 }
530 next[0] = '\0';
531 next++;
532 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "class is: %s\n", token);
533 while (*next == ' ')
534 next++;
535 token = next;
536 next = strchr (token, ' ');
537 if (NULL == next)
538 {
539 fprintf (stderr, "Error\n");
540 break;
541 }
542 next[0] = '\0';
543 next++;
544 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "type is: %s\n", token);
547 while (*next == ' ')
548 next++;
549 token = next;
550 }
551 for (int i = 0; i < strlen (token); i++)
552 {
553 if (token[i] == '"')
554 quoted = ! quoted;
555 if ((token[i] == '(') && ! quoted)
556 bracket_unclosed++;
557 if ((token[i] == ')') && ! quoted)
558 bracket_unclosed--;
559 }
560 memcpy (payload_pos, token, strlen (token));
561 payload_pos += strlen (token);
562 if (bracket_unclosed > 0)
563 {
564 *payload_pos = ' ';
565 payload_pos++;
566 continue;
567 }
568 *payload_pos = '\0';
569 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "data is: %s\n\n", payload);
570 if (GNUNET_OK !=
572 &data,
573 &data_size))
574 {
575 fprintf (stderr,
576 _ ("Data `%s' invalid\n"),
577 payload);
578 ret = 1;
580 return;
581 }
582 rd[rd_count].data = data;
584 if (ZS_NAME_CHANGED == state)
585 break;
586 rd_count++;
587 }
588 if (rd_count > 0)
589 {
591 &zone_pkey,
592 lastname,
593 rd_count,
594 rd,
596 NULL);
599 for (int i = 0; i < rd_count; i++)
600 {
601 data = (void*) rd[i].data;
603 }
604 if (ZS_NAME_CHANGED == state)
605 {
606 rd[0] = rd[rd_count]; // recover last rd parsed.
607 rd_count = 1;
608 strcpy (lastname, newname);
610 }
611 else
612 rd_count = 0;
613 return;
614 }
616 {
617 if (NULL != ego_name)
620 if (ego_name[strlen (ego_name) - 1] == '.')
621 ego_name[strlen (ego_name) - 1] = '\0';
623 "Changing origin to %s\n", ego_name);
625 &origin_lookup_cb, NULL);
626 return;
627 }
628 printf ("Published %u records sets with total %u records\n",
631}
632
633
634static void
635identity_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego)
636{
637
638 el = NULL;
639 if (NULL == ego)
640 {
641 if (NULL != ego_name)
642 {
643 fprintf (stderr,
644 _ ("Ego `%s' not known to identity service\n"),
645 ego_name);
646
647 }
649 ret = -1;
650 return;
651 }
653 sprintf (origin, "%s.", ego_name);
656}
657
658
659static void
660run (void *cls,
661 char *const *args,
662 const char *cfgfile,
663 const struct GNUNET_CONFIGURATION_Handle *_cfg)
664{
665 cfg = _cfg;
668 if (NULL == ns)
669 {
670 fprintf (stderr,
671 _ ("Failed to connect to NAMESTORE\n"));
672 return;
673 }
674 id = GNUNET_IDENTITY_connect (cfg, NULL, NULL);
675 if (NULL == id)
676 {
677 fprintf (stderr,
678 _ ("Failed to connect to IDENTITY\n"));
679 return;
680 }
681 if (NULL != ego_name)
683 else
685 state = ZS_READY;
686}
687
688
696int
697main (int argc, char *const *argv)
698{
701 "zone",
702 "EGO",
704 "name of the ego controlling the zone"),
705 &ego_name),
707 };
708 int lret;
709
710 if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
711 return 2;
712
713 GNUNET_log_setup ("gnunet-namestore-dbtool", "WARNING", NULL);
714 if (GNUNET_OK !=
715 (lret = GNUNET_PROGRAM_run (argc,
716 argv,
717 "gnunet-namestore-zonefile",
718 _ (
719 "GNUnet namestore database manipulation tool"),
720 options,
721 &run,
722 NULL)))
723 {
724 GNUNET_free_nz ((void *) argv);
725 return lret;
726 }
727 GNUNET_free_nz ((void *) argv);
728 return ret;
729}
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 char * line
Desired phone line (string to be converted to a hash).
static char * data
The data to insert into the dht.
struct GNUNET_CRYPTO_PrivateKey pk
Private key from command line option, or NULL.
static struct GNUNET_NAMESTORE_QueueEntry * ns_qe
Queue entry for the 'add' operation.
static int parse_ttl(char *token, struct GNUNET_TIME_Relative *ttl)
static struct GNUNET_IDENTITY_Operation * id_op
Origin create operations.
static int parse_origin(char *token, char *origin)
static struct GNUNET_CRYPTO_PrivateKey zone_pkey
Private key for the our zone.
static void identity_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego)
static void parse(void *cls)
Main function that will be run.
static unsigned int published_records
Statistics, how many records published in aggregate.
static void origin_create_cb(void *cls, const struct GNUNET_CRYPTO_PrivateKey *pk, enum GNUNET_ErrorCode ec)
static const struct GNUNET_CONFIGURATION_Handle * cfg
Current configurataion.
static struct GNUNET_SCHEDULER_Task * parse_task
Scheduled parse task.
static struct GNUNET_TIME_Relative ttl
Current record $TTL to use.
#define MAX_RECORDS_PER_NAME
static int ret
Return code.
static void do_shutdown(void *cls)
Task run on shutdown.
static struct GNUNET_IDENTITY_EgoLookup * el
Handle to identity lookup.
static char * ego_name
Name of the ego.
#define MAX_ZONEFILE_LINE_LEN
Maximum length of a zonefile line.
static char origin[GNUNET_DNSPARSER_MAX_NAME_LENGTH]
Current origin.
#define MAX_ZONEFILE_RECORD_DATA_LEN
FIXME: Soft limit this?
static int state
The current state of the parser.
static void add_continuation(void *cls, enum GNUNET_ErrorCode ec)
static unsigned int rd_count
Number of records for currently parsed set.
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *_cfg)
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
static char * res
Currently read line or NULL on EOF.
static struct GNUNET_IDENTITY_Handle * id
Handle to IDENTITY.
static char * trim(char *line)
int main(int argc, char *const *argv)
The main function for gnunet-namestore-dbtool.
static void origin_lookup_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego)
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
static char * next_token(char *token)
static unsigned int published_sets
Statistics, how many published record sets.
static uint32_t type
Type string converted to DNS type value.
static size_t data_size
Number of bytes in data.
static unsigned long long payload
How much data are we currently storing in the database?
Plugin API for the namestore database backend.
#define GNUNET_DNSPARSER_MAX_LABEL_LENGTH
Maximum length of a label in DNS.
#define GNUNET_DNSPARSER_MAX_NAME_LENGTH
Maximum length of a name in DNS.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
uint32_t GNUNET_GNSRECORD_typename_to_number(const char *dns_typename)
Convert a type name (e.g.
Definition: gnsrecord.c:200
int GNUNET_GNSRECORD_string_to_value(uint32_t type, const char *s, void **data, size_t *data_size)
Convert human-readable version of the value s of a record of type type to the respective binary repre...
Definition: gnsrecord.c:177
@ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
This expiration time of the record is a relative time (not an absolute time).
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_create(struct GNUNET_IDENTITY_Handle *id, const char *name, const struct GNUNET_CRYPTO_PrivateKey *privkey, enum GNUNET_CRYPTO_KeyType ktype, GNUNET_IDENTITY_CreateContinuation cont, void *cont_cls)
Create a new ego with the given name.
Definition: identity_api.c:561
const struct GNUNET_CRYPTO_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:517
struct GNUNET_IDENTITY_EgoLookup * GNUNET_IDENTITY_ego_lookup(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, GNUNET_IDENTITY_EgoCallback cb, void *cb_cls)
Lookup an ego by name.
struct GNUNET_IDENTITY_Handle * GNUNET_IDENTITY_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Connect to the identity service.
Definition: identity_api.c:487
void GNUNET_IDENTITY_cancel(struct GNUNET_IDENTITY_Operation *op)
Cancel an identity operation.
Definition: identity_api.c:715
void GNUNET_IDENTITY_ego_lookup_cancel(struct GNUNET_IDENTITY_EgoLookup *el)
Abort ego lookup attempt.
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:732
#define GNUNET_log(kind,...)
@ GNUNET_PUBLIC_KEY_TYPE_ECDSA
The identity type.
@ GNUNET_OK
@ GNUNET_SYSERR
enum GNUNET_GenericReturnValue GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_free_nz(ptr)
Wrapper around free.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_record_set_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_PrivateKey *pkey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the namestore.
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
void GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
Cancel a namestore operation.
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
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
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
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
const char * GNUNET_ErrorCode_get_hint(enum GNUNET_ErrorCode ec)
Returns a hint for a given error code.
GNUNET_ErrorCode
Taler error codes.
@ GNUNET_EC_NONE
No error (success).
A private key for an identity as per LSD0001.
Definition of a command line option.
uint32_t record_type
Type of the GNS/DNS record.
const void * data
Binary value stored in the DNS record.
size_t data_size
Number of bytes in data.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
uint64_t expiration_time
Expiration time for the DNS record.
Handle for ego lookup.
Handle for an ego.
Definition: identity.h:37
Handle for the service.
Definition: identity_api.c:97
Handle for an operation with the identity service.
Definition: identity_api.c:41
Connection to the NAMESTORE service.
An QueueEntry used to store information for a pending NAMESTORE record operation.
Definition: namestore_api.c:49
Entry in list of pending tasks.
Definition: scheduler.c:136
struct GNUNET_SCHEDULER_Task * next
This is a linked list.
Definition: scheduler.c:140
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.