GNUnet  0.17.6
gnsrecord_misc.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2009-2013 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 
28 #include "platform.h"
29 #include "gnunet_util_lib.h"
30 #include "gnunet_constants.h"
31 #include "gnunet_signatures.h"
32 #include "gnunet_arm_service.h"
33 #include "gnunet_gnsrecord_lib.h"
34 #include "gnunet_dnsparser_lib.h"
35 #include "gnunet_tun_lib.h"
36 
37 
38 #define LOG(kind, ...) GNUNET_log_from (kind, "gnsrecord", __VA_ARGS__)
39 
40 char *
42 {
43  /*FIXME: We may want to follow RFC5890/RFC5891 */
44  return GNUNET_STRINGS_utf8_normalize (src);
45 }
46 
47 
49 GNUNET_GNSRECORD_label_check (const char*label, char **emsg)
50 {
51  if (NULL == label)
52  {
53  *emsg = GNUNET_strdup (_ ("Label is NULL which is not allowed\n"));
54  return GNUNET_NO;
55  }
56  if (0 != strchr (label, '.'))
57  {
58  *emsg = GNUNET_strdup (_ ("Label contains `.' which is not allowed\n"));
59  return GNUNET_NO;
60  }
61  return GNUNET_OK;
62 }
63 
64 
73 const char *
75 {
76  static char buf[sizeof(struct GNUNET_IDENTITY_PublicKey) * 8];
77  char *end;
78 
79  end = GNUNET_STRINGS_data_to_string ((const unsigned char *) z,
80  sizeof(struct
82  buf, sizeof(buf));
83  if (NULL == end)
84  {
85  GNUNET_break (0);
86  return NULL;
87  }
88  *end = '\0';
89  return buf;
90 }
91 
92 
102 int
104  const struct GNUNET_GNSRECORD_Data *b)
105 {
107  "Comparing records\n");
108  if (a->record_type != b->record_type)
109  {
111  "Record type %u != %u\n", a->record_type, b->record_type);
112  return GNUNET_NO;
113  }
114  if ((a->expiration_time != b->expiration_time) &&
115  ((a->expiration_time != 0) && (b->expiration_time != 0)))
116  {
118  "Expiration time %llu != %llu\n",
119  (unsigned long long) a->expiration_time,
120  (unsigned long long) b->expiration_time);
121  return GNUNET_NO;
122  }
125  {
127  "Flags %u (%u) != %u (%u)\n", a->flags,
130  return GNUNET_NO;
131  }
132  if (a->data_size != b->data_size)
133  {
135  "Data size %lu != %lu\n",
136  a->data_size,
137  b->data_size);
138  return GNUNET_NO;
139  }
140  if (0 != memcmp (a->data, b->data, a->data_size))
141  {
143  "Data contents do not match\n");
144  return GNUNET_NO;
145  }
147  "Records are equal\n");
148  return GNUNET_YES;
149 }
150 
151 
154  const struct
156  struct GNUNET_TIME_Absolute min)
157 {
159  struct GNUNET_TIME_Absolute at;
160  struct GNUNET_TIME_Relative rt;
161  struct GNUNET_TIME_Absolute at_shadow;
162  struct GNUNET_TIME_Relative rt_shadow;
163 
164  if (0 == rd_count)
167  for (unsigned int c = 0; c < rd_count; c++)
168  {
169  if (0 != (rd[c].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
170  {
171  rt.rel_value_us = rd[c].expiration_time;
173  }
174  else
175  {
176  at.abs_value_us = rd[c].expiration_time;
177  }
178 
179  for (unsigned int c2 = 0; c2 < rd_count; c2++)
180  {
181  /* Check for shadow record */
182  if ((c == c2) ||
183  (rd[c].record_type != rd[c2].record_type) ||
184  (0 == (rd[c2].flags & GNUNET_GNSRECORD_RF_SHADOW_RECORD)))
185  continue;
186  /* We have a shadow record */
187  if (0 != (rd[c2].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
188  {
189  rt_shadow.rel_value_us = rd[c2].expiration_time;
190  at_shadow = GNUNET_TIME_relative_to_absolute (rt_shadow);
191  }
192  else
193  {
194  at_shadow.abs_value_us = rd[c2].expiration_time;
195  }
196  at = GNUNET_TIME_absolute_max (at,
197  at_shadow);
198  }
200  expire);
201  }
204  "Determined expiration time for block with %u records to be %s\n",
205  rd_count,
207  return expire;
208 }
209 
210 
217 int
219 {
220  struct GNUNET_TIME_Absolute at;
221 
223  return GNUNET_NO;
224  at.abs_value_us = rd->expiration_time;
225  return (0 == GNUNET_TIME_absolute_get_remaining (at).rel_value_us) ?
227 }
228 
229 
240 const char *
242 {
243  static char ret[128];
244  char *pkeys;
245 
248  sizeof(ret),
249  "%s",
250  pkeys);
251  GNUNET_free (pkeys);
252  return ret;
253 }
254 
255 
265 int
268 {
269  if (GNUNET_OK !=
271  pkey))
272  return GNUNET_SYSERR;
273  return GNUNET_OK;
274 }
275 
276 
279  size_t data_size,
280  uint32_t type,
282 {
284  return GNUNET_SYSERR;
285  switch (type)
286  {
288  if (data_size > sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))
289  return GNUNET_SYSERR;
290  memcpy (&key->ecdsa_key, data, data_size);
291  break;
293  if (data_size > sizeof (struct GNUNET_CRYPTO_EddsaPublicKey))
294  return GNUNET_SYSERR;
295  memcpy (&key->eddsa_key, data, data_size);
296  break;
297  default:
298  return GNUNET_NO;
299  }
300  key->type = htonl (type);
301 
302  return GNUNET_YES;
303 }
304 
305 
309  char **data,
310  size_t *data_size,
311  uint32_t *type)
312 {
313  char *tmp;
314  *type = ntohl (key->type);
315  *data_size = GNUNET_IDENTITY_key_get_length (key) - sizeof (key->type);
316  if (0 == *data_size)
317  return GNUNET_SYSERR;
318  tmp = GNUNET_malloc (*data_size);
319  memcpy (tmp, ((char*) key) + sizeof (key->type), *data_size);
320  *data = tmp;
321  return GNUNET_OK;
322 }
323 
324 
327 {
328  switch (type)
329  {
332  return GNUNET_YES;
333  default:
334  return GNUNET_NO;
335  }
336 }
337 
338 
339 size_t
341 {
342  return ntohl (block->size);
343 }
344 
345 
348  GNUNET_GNSRECORD_Block *block)
349 {
350 
351  switch (ntohl (block->type))
352  {
354  return GNUNET_TIME_absolute_ntoh (block->ecdsa_block.expiration_time);
356  return GNUNET_TIME_absolute_ntoh (block->eddsa_block.expiration_time);
357  default:
358  GNUNET_break (0); /* Hopefully we never get here, but we might */
359  }
361 
362 }
363 
364 
367  struct GNUNET_HashCode *query)
368 {
369  switch (ntohl (block->type))
370  {
373  sizeof (block->ecdsa_block.derived_key),
374  query);
375  return GNUNET_OK;
378  sizeof (block->eddsa_block.derived_key),
379  query);
380  return GNUNET_OK;
381  default:
382  return GNUNET_SYSERR;
383  }
384  return GNUNET_SYSERR;
385 
386 }
387 
388 
392 {
394  "Got record of type %u\n",
395  rd->record_type);
396  switch (rd->record_type)
397  {
399  key->type = htonl (rd->record_type);
400  memcpy (&key->ecdsa_key, rd->data, sizeof (key->ecdsa_key));
401  return GNUNET_OK;
403  key->type = htonl (rd->record_type);
404  memcpy (&key->eddsa_key, rd->data, sizeof (key->eddsa_key));
405  return GNUNET_OK;
406  default:
407  return GNUNET_SYSERR;
408  }
409  return GNUNET_SYSERR;
410 
411 
412 }
413 
414 
416 GNUNET_GNSRECORD_normalize_record_set (const char *label,
417  const struct
419  unsigned int rd_count,
420  struct GNUNET_GNSRECORD_Data *
421  rd_public,
422  unsigned int *rd_count_public,
423  struct GNUNET_TIME_Absolute *expiry,
425  char **emsg)
426 {
427  struct GNUNET_TIME_Absolute now;
428  struct GNUNET_TIME_Absolute minimum_expiration;
429  int have_zone_delegation = GNUNET_NO;
430  int have_gns2dns = GNUNET_NO;
431  int have_other = GNUNET_NO;
432  int have_redirect = GNUNET_NO;
433  int have_empty_label = (0 == strcmp (GNUNET_GNS_EMPTY_LABEL_AT, label));
434  unsigned int rd_count_tmp;
435 
436  minimum_expiration = GNUNET_TIME_UNIT_ZERO_ABS;
437  now = GNUNET_TIME_absolute_get ();
438  rd_count_tmp = 0;
439  for (unsigned int i = 0; i < rd_count; i++)
440  {
441  /* Ignore the tombstone. For maintenance only. Remember expiration time. */
442  if (GNUNET_GNSRECORD_TYPE_TOMBSTONE == rd[i].record_type)
443  {
444  minimum_expiration.abs_value_us = rd[i].expiration_time;
445  continue;
446  }
447  /* No NICK records unless empty label */
448  if (have_empty_label &&
449  (GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type))
450  continue;
451 
461  if (GNUNET_YES == GNUNET_GNSRECORD_is_zonekey_type (rd[i].record_type))
462  {
463  /* No delegation records under empty label*/
464  if (have_empty_label)
465  {
466  *emsg = GNUNET_strdup (_ (
467  "Zone delegation record not allowed in apex."));
468  return GNUNET_SYSERR;
469  }
470  if ((GNUNET_YES == have_other) ||
471  (GNUNET_YES == have_redirect) ||
472  (GNUNET_YES == have_gns2dns))
473  {
474  *emsg = GNUNET_strdup (_ (
475  "Zone delegation record set contains mutually exclusive records."));
476  return GNUNET_SYSERR;
477  }
478  have_zone_delegation = GNUNET_YES;
479  }
480  else if (GNUNET_GNSRECORD_TYPE_REDIRECT == rd[i].record_type)
481  {
482  if (GNUNET_YES == have_redirect)
483  {
484  *emsg = GNUNET_strdup (_ (
485  "Multiple REDIRECT records."));
486  return GNUNET_SYSERR;
487 
488  }
489  if ((GNUNET_YES == have_other) ||
490  (GNUNET_YES == have_zone_delegation) ||
491  (GNUNET_YES == have_gns2dns))
492  {
493  *emsg = GNUNET_strdup (_ (
494  "Redirection record set contains mutually exclusive records."));
495  return GNUNET_SYSERR;
496  }
497  /* No redirection records under empty label*/
498  if (have_empty_label)
499  {
500  *emsg = GNUNET_strdup (_ (
501  "Redirection records not allowed in apex."));
502  return GNUNET_SYSERR;
503  }
504  have_redirect = GNUNET_YES;
505  }
506  else if (GNUNET_GNSRECORD_TYPE_GNS2DNS == rd[i].record_type)
507  {
508  /* No gns2dns records under empty label*/
509  if (have_empty_label)
510  {
511  *emsg = GNUNET_strdup (_ (
512  "Redirection records not allowed in apex.."));
513  return GNUNET_SYSERR;
514  }
515  if ((GNUNET_YES == have_other) ||
516  (GNUNET_YES == have_redirect) ||
517  (GNUNET_YES == have_zone_delegation))
518  {
519  *emsg = GNUNET_strdup (_ (
520  "Redirection record set contains mutually exclusive records."));
521  return GNUNET_SYSERR;
522  }
523  have_gns2dns = GNUNET_YES;
524  }
525  else
526  {
527  /* Some other record.
528  * Not allowed for zone delegations or redirections */
529  if ((GNUNET_YES == have_zone_delegation) ||
530  (GNUNET_YES == have_redirect) ||
531  (GNUNET_YES == have_gns2dns))
532  {
533  *emsg = GNUNET_strdup (_ (
534  "Mutually exclusive records."));
535  return GNUNET_SYSERR;
536  }
537  have_other = GNUNET_YES;
538  }
539 
540  /* Ignore private records for public record set */
541 
543  (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE)))
544  continue;
545  /* Skip expired records */
546  if ((0 == (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION)) &&
547  (rd[i].expiration_time < now.abs_value_us))
548  continue; /* record already expired, skip it */
549  rd_public[rd_count_tmp] = rd[i];
550  /* Make sure critical record types are marked as such */
551  if (GNUNET_YES == GNUNET_GNSRECORD_is_critical (rd[i].record_type))
552  rd_public[rd_count_tmp].flags |= GNUNET_GNSRECORD_RF_CRITICAL;
553  rd_count_tmp++;
554  }
555 
556  *expiry = GNUNET_GNSRECORD_record_get_expiration_time (rd_count_tmp,
557  rd_public,
558  minimum_expiration);
559  *rd_count_public = rd_count_tmp;
560  return GNUNET_OK;
561 }
562 
563 
564 /* end of gnsrecord_misc.c */
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_record_to_identity_key(const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_IDENTITY_PublicKey *key)
#define LOG(kind,...)
#define GNUNET_GNSRECORD_TYPE_NICK
GNS nick names.
#define GNUNET_GNSRECORD_TYPE_TOMBSTONE
Record type to indicate a previously delete record (PRIVATE only)
#define GNUNET_GNSRECORD_TYPE_GNS2DNS
Delegation to DNS.
#define GNUNET_GNSRECORD_TYPE_REDIRECT
Resolver redirects.
#define GNUNET_GNSRECORD_TYPE_PKEY
WARNING: This header is generated! In order to add GNS record types, you must register them in GANA,...
#define GNUNET_GNSRECORD_TYPE_EDKEY
Record type for EDKEY zone delegations.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
struct GNUNET_HashCode key
The key used in the DHT.
static char * expire
DID Document expiration Date Attribut String.
Definition: gnunet-did.c:101
uint32_t data
The data value.
static char * pkey
Public key of the zone to look in, in ASCII.
static struct GNUNET_CONTAINER_BloomFilter * filter
Bloomfilter to quickly tell if we don't have the content.
static char buf[2048]
API for helper library to parse DNS packets.
API that can be used to manipulate GNS record data.
#define GNUNET_GNSRECORD_RF_RCMP_FLAGS
When comparing flags for record equality for removal, which flags should must match (in addition to t...
Standard TCP/IP network structs and IP checksum calculations for TUN interaction.
char * GNUNET_GNSRECORD_string_normalize(const char *src)
Normalize a UTF-8 string to a GNS name.
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_label_check(const char *label, char **emsg)
Check label for invalid characters.
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_identity_from_data(const char *data, size_t data_size, uint32_t type, struct GNUNET_IDENTITY_PublicKey *key)
Build a #GNUNET_GNSRECORD_PublicKey from zone delegation resource record data.
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_data_from_identity(const struct GNUNET_IDENTITY_PublicKey *key, char **data, size_t *data_size, uint32_t *type)
Create record data and size from an identity key.
struct GNUNET_TIME_Absolute GNUNET_GNSRECORD_record_get_expiration_time(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute min)
Returns the expiration time of the given block of records.
size_t GNUNET_GNSRECORD_block_get_size(const struct GNUNET_GNSRECORD_Block *block)
Returns the length of this block in bytes.
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_query_from_block(const struct GNUNET_GNSRECORD_Block *block, struct GNUNET_HashCode *query)
Builds the query hash from a block.
int GNUNET_GNSRECORD_is_expired(const struct GNUNET_GNSRECORD_Data *rd)
Test if a given record is expired.
#define GNUNET_GNS_EMPTY_LABEL_AT
String we use to indicate an empty label (top-level entry in the zone).
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_is_critical(uint32_t type)
Check if this type is a critical record.
Definition: gnsrecord.c:264
int GNUNET_GNSRECORD_zkey_to_pkey(const char *zkey, struct GNUNET_IDENTITY_PublicKey *pkey)
Convert an absolute domain name to the respective public key.
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_is_zonekey_type(uint32_t type)
Check if this type is one of the supported GNS zone types.
const char * GNUNET_GNSRECORD_z2s(const struct GNUNET_IDENTITY_PublicKey *z)
Convert a zone key to a string (for printing debug messages).
GNUNET_GNSRECORD_Filter
Filter for GNUNET_GNSRECORD_normalize_record_set().
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_normalize_record_set(const char *label, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *rd_public, unsigned int *rd_count_public, struct GNUNET_TIME_Absolute *expiry, enum GNUNET_GNSRECORD_Filter filter, char **emsg)
Normalize namestore records: Check for consistency and expirations.
int GNUNET_GNSRECORD_records_cmp(const struct GNUNET_GNSRECORD_Data *a, const struct GNUNET_GNSRECORD_Data *b)
Compares if two records are equal (ignoring flags such as authority, private and pending,...
struct GNUNET_TIME_Absolute GNUNET_GNSRECORD_block_get_expiration(const struct GNUNET_GNSRECORD_Block *block)
Returns the expiration of a block.
const char * GNUNET_GNSRECORD_pkey_to_zkey(const struct GNUNET_IDENTITY_PublicKey *pkey)
Convert public key to the respective absolute domain name in the ".zkey" pTLD.
@ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
This expiration time of the record is a relative time (not an absolute time).
@ GNUNET_GNSRECORD_RF_CRITICAL
This record is critical.
@ GNUNET_GNSRECORD_RF_SHADOW_RECORD
This record should not be used unless all (other) records with an absolute expiration time have expir...
@ GNUNET_GNSRECORD_RF_PRIVATE
This is a private record of this peer and it should thus not be handed out to other peers.
@ GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE
Filter private records.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_public_key_from_string(const char *str, struct GNUNET_IDENTITY_PublicKey *key)
Parses a (Base32) string representation of the public key.
char * GNUNET_IDENTITY_public_key_to_string(const struct GNUNET_IDENTITY_PublicKey *key)
Creates a (Base32) string representation of the public key.
ssize_t GNUNET_IDENTITY_key_get_length(const struct GNUNET_IDENTITY_PublicKey *key)
Get the compacted length of a GNUNET_IDENTITY_PublicKey.
Definition: identity_api.c:991
#define GNUNET_log(kind,...)
GNUNET_GenericReturnValue
Named constants for return values.
Definition: gnunet_common.h:96
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_YES
@ GNUNET_NO
Definition: gnunet_common.h:98
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
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_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
char * GNUNET_STRINGS_data_to_string(const void *data, size_t size, char *out, size_t out_size)
Convert binary data to ASCII encoding using CrockfordBase32.
Definition: strings.c:709
char * GNUNET_STRINGS_utf8_normalize(const char *input)
Normalize the utf-8 input string to NFC.
Definition: strings.c:430
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_zero_(void)
Return absolute time of 0ms.
Definition: time.c:141
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:404
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_max(struct GNUNET_TIME_Absolute t1, struct GNUNET_TIME_Absolute t2)
Return the maximum of two absolute time values.
Definition: time.c:366
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:110
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:617
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:736
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:315
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_min(struct GNUNET_TIME_Absolute t1, struct GNUNET_TIME_Absolute t2)
Return the minimum of two absolute time values.
Definition: time.c:358
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
#define min(x, y)
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and E...
uint32_t type
The zone type (GNUNET_GNSRECORD_TYPE_PKEY)
struct GNUNET_GNSRECORD_EcdsaBlock ecdsa_block
struct GNUNET_GNSRECORD_EddsaBlock eddsa_block
uint32_t size
Size of the block.
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.
struct GNUNET_CRYPTO_EcdsaPublicKey derived_key
Derived key used for signing; hash of this is the query.
struct GNUNET_CRYPTO_EddsaPublicKey derived_key
Derived key used for signing; hash of this is the query.
A 512-bit hashcode.
An identity key as per LSD0001.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model