Merge branch 'master' of ssh://git.gnunet.org/gnunet

4 files changed, 226 insertions, 148 deletions

diff --git a/src/json/json_generator.c b/src/json/json_generator.c
index 0c513ca9d..5421b9527 100644
--- a/src/json/json_generator.c
+++ b/src/json/json_generator.c
@@ -27,14 +27,6 @@
 #include "gnunet_json_lib.h"
 
 
-/**
- * Convert binary data to a JSON string
- * with the base32crockford encoding.
- *
- * @param data binary data
- * @param size size of @a data in bytes
- * @return json string that encodes @a data
- */
 json_t *
 GNUNET_JSON_from_data (const void *data,
                        size_t size)
@@ -57,30 +49,30 @@ GNUNET_JSON_from_data (const void *data,
 }
 
 
-/**
- * Convert absolute timestamp to a json string.
- *
- * @param stamp the time stamp
- * @return a json string with the timestamp in @a stamp
- */
 json_t *
-GNUNET_JSON_from_time_abs (struct GNUNET_TIME_Absolute stamp)
+GNUNET_JSON_from_timestamp (struct GNUNET_TIME_Timestamp stamp)
 {
   json_t *j;
 
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_TIME_round_abs (&stamp));
-
   j = json_object ();
   if (NULL == j)
   {
     GNUNET_break (0);
     return NULL;
   }
-  if (stamp.abs_value_us == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
+  if (GNUNET_TIME_absolute_is_never (stamp.abs_time))
   {
     if (0 !=
         json_object_set_new (j,
+                             "t_s",
+                             json_string ("never")))
+    {
+      GNUNET_break (0);
+      json_decref (j);
+      return NULL;
+    }
+    if (0 !=
+        json_object_set_new (j,
                              "t_ms",
                              json_string ("never")))
     {
@@ -90,11 +82,29 @@ GNUNET_JSON_from_time_abs (struct GNUNET_TIME_Absolute stamp)
     }
     return j;
   }
+  GNUNET_assert (
+    0 ==
+    (stamp.abs_time.abs_value_us
+     % GNUNET_TIME_UNIT_SECONDS.rel_value_us));
   if (0 !=
-      json_object_set_new (j,
-                           "t_ms",
-                           json_integer ((json_int_t) (stamp.abs_value_us
-                                                       / 1000LL))))
+      json_object_set_new (
+        j,
+        "t_s",
+        json_integer (
+          (json_int_t) (stamp.abs_time.abs_value_us
+                        / GNUNET_TIME_UNIT_SECONDS.rel_value_us))))
+  {
+    GNUNET_break (0);
+    json_decref (j);
+    return NULL;
+  }
+  if (0 !=
+      json_object_set_new (
+        j,
+        "t_ms",
+        json_integer (
+          (json_int_t) (stamp.abs_time.abs_value_us
+                        / GNUNET_TIME_UNIT_MILLISECONDS.rel_value_us))))
   {
     GNUNET_break (0);
     json_decref (j);
@@ -104,43 +114,37 @@ GNUNET_JSON_from_time_abs (struct GNUNET_TIME_Absolute stamp)
 }
 
 
-/**
- * Convert absolute timestamp to a json string.
- *
- * @param stamp the time stamp
- * @return a json string with the timestamp in @a stamp
- */
 json_t *
-GNUNET_JSON_from_time_abs_nbo (struct GNUNET_TIME_AbsoluteNBO stamp)
+GNUNET_JSON_from_timestamp_nbo (struct GNUNET_TIME_TimestampNBO stamp)
 {
-  return GNUNET_JSON_from_time_abs (GNUNET_TIME_absolute_ntoh (stamp));
+  return GNUNET_JSON_from_timestamp (GNUNET_TIME_timestamp_ntoh (stamp));
 }
 
 
-/**
- * Convert relative timestamp to a json string.
- *
- * @param stamp the time stamp
- * @return a json string with the timestamp in @a stamp
- */
 json_t *
 GNUNET_JSON_from_time_rel (struct GNUNET_TIME_Relative stamp)
 {
   json_t *j;
 
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_TIME_round_rel (&stamp));
-
   j = json_object ();
   if (NULL == j)
   {
     GNUNET_break (0);
     return NULL;
   }
-  if (stamp.rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
+  if (GNUNET_TIME_relative_is_forever (stamp))
   {
     if (0 !=
         json_object_set_new (j,
+                             "d_us",
+                             json_string ("forever")))
+    {
+      GNUNET_break (0);
+      json_decref (j);
+      return NULL;
+    }
+    if (0 !=
+        json_object_set_new (j,
                              "d_ms",
                              json_string ("forever")))
     {
@@ -150,11 +154,27 @@ GNUNET_JSON_from_time_rel (struct GNUNET_TIME_Relative stamp)
     }
     return j;
   }
+  if (stamp.rel_value_us >= (1LLU << 53))
+  {
+    /* value is larger than allowed */
+    GNUNET_break (0);
+    return NULL;
+  }
   if (0 !=
-      json_object_set_new (j,
-                           "d_ms",
-                           json_integer ((json_int_t) (stamp.rel_value_us
-                                                       / 1000LL))))
+      json_object_set_new (
+        j,
+        "d_us",
+        json_integer ((json_int_t) stamp.rel_value_us)))
+  {
+    GNUNET_break (0);
+    json_decref (j);
+    return NULL;
+  }
+  if (0 !=
+      json_object_set_new (
+        j,
+        "d_ms",
+        json_integer (((json_int_t) stamp.rel_value_us)/1000LL)))
   {
     GNUNET_break (0);
     json_decref (j);
@@ -164,12 +184,6 @@ GNUNET_JSON_from_time_rel (struct GNUNET_TIME_Relative stamp)
 }
 
 
-/**
- * Convert RSA public key to JSON.
- *
- * @param pk public key to convert
- * @return corresponding JSON encoding
- */
 json_t *
 GNUNET_JSON_from_rsa_public_key (const struct GNUNET_CRYPTO_RsaPublicKey *pk)
 {
@@ -186,12 +200,6 @@ GNUNET_JSON_from_rsa_public_key (const struct GNUNET_CRYPTO_RsaPublicKey *pk)
 }
 
 
-/**
- * Convert RSA signature to JSON.
- *
- * @param sig signature to convert
- * @return corresponding JSON encoding
- */
 json_t *
 GNUNET_JSON_from_rsa_signature (const struct GNUNET_CRYPTO_RsaSignature *sig)
 {
diff --git a/src/json/json_helper.c b/src/json/json_helper.c
index 3a11f205c..c0513c529 100644
--- a/src/json/json_helper.c
+++ b/src/json/json_helper.c
@@ -49,7 +49,7 @@ GNUNET_JSON_spec_end ()
  * @param[out] spec where to write the data
  * @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
  */
-static int
+static enum GNUNET_GenericReturnValue
 parse_fixed_data (void *cls,
                   json_t *root,
                   struct GNUNET_JSON_Specification *spec)
@@ -579,19 +579,20 @@ GNUNET_JSON_spec_int64 (const char *name,
 /* ************ GNUnet-specific parser specifications ******************* */
 
 /**
- * Parse given JSON object to absolute time.
+ * Parse given JSON object to a timestamp.
  *
  * @param cls closure, NULL
  * @param root the json object representing data
  * @param[out] spec where to write the data
  * @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
  */
-static int
-parse_abs_time (void *cls,
-                json_t *root,
-                struct GNUNET_JSON_Specification *spec)
+static enum GNUNET_GenericReturnValue
+parse_timestamp (void *cls,
+                 json_t *root,
+                 struct GNUNET_JSON_Specification *spec)
 {
-  struct GNUNET_TIME_Absolute *abs = spec->ptr;
+  struct GNUNET_TIME_Timestamp *ts = spec->ptr;
+  json_t *json_t_s;
   json_t *json_t_ms;
   unsigned long long int tval;
 
@@ -600,13 +601,49 @@ parse_abs_time (void *cls,
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
-  json_t_ms = json_object_get (root, "t_ms");
+  json_t_s = json_object_get (root,
+                              "t_s");
+  if (json_is_integer (json_t_s))
+  {
+    tval = json_integer_value (json_t_s);
+    /* Time is in seconds in JSON, but in microseconds in GNUNET_TIME_Absolute */
+    ts->abs_time.abs_value_us
+      = tval * GNUNET_TIME_UNIT_SECONDS.rel_value_us;
+    if (ts->abs_time.abs_value_us
+        / GNUNET_TIME_UNIT_SECONDS.rel_value_us
+        != tval)
+    {
+      /* Integer overflow */
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
+    }
+    return GNUNET_OK;
+  }
+  if (json_is_string (json_t_s))
+  {
+    const char *val;
+
+    val = json_string_value (json_t_s);
+    if ((0 == strcasecmp (val,
+                          "never")))
+    {
+      ts->abs_time = GNUNET_TIME_UNIT_FOREVER_ABS;
+      return GNUNET_OK;
+    }
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  json_t_ms = json_object_get (root,
+                               "t_ms");
   if (json_is_integer (json_t_ms))
   {
     tval = json_integer_value (json_t_ms);
-    /* Time is in milliseconds in JSON, but in microseconds in GNUNET_TIME_Absolute */
-    abs->abs_value_us = tval * GNUNET_TIME_UNIT_MILLISECONDS.rel_value_us;
-    if ((abs->abs_value_us)
+    GNUNET_break_op (0 == tval % 1000);
+    tval -= tval % 1000;
+    /* Time is in seconds in JSON, but in microseconds in GNUNET_TIME_Absolute */
+    ts->abs_time.abs_value_us
+      = tval * GNUNET_TIME_UNIT_MILLISECONDS.rel_value_us;
+    if (ts->abs_time.abs_value_us
         / GNUNET_TIME_UNIT_MILLISECONDS.rel_value_us
         != tval)
     {
@@ -621,9 +658,10 @@ parse_abs_time (void *cls,
     const char *val;
 
     val = json_string_value (json_t_ms);
-    if ((0 == strcasecmp (val, "never")))
+    if ((0 == strcasecmp (val,
+                          "never")))
     {
-      *abs = GNUNET_TIME_UNIT_FOREVER_ABS;
+      ts->abs_time = GNUNET_TIME_UNIT_FOREVER_ABS;
       return GNUNET_OK;
     }
     GNUNET_break_op (0);
@@ -635,17 +673,14 @@ parse_abs_time (void *cls,
 
 
 struct GNUNET_JSON_Specification
-GNUNET_JSON_spec_absolute_time (const char *name,
-                                struct GNUNET_TIME_Absolute *at)
+GNUNET_JSON_spec_timestamp (const char *name,
+                            struct GNUNET_TIME_Timestamp *t)
 {
   struct GNUNET_JSON_Specification ret = {
-    .parser = &parse_abs_time,
-    .cleaner = NULL,
-    .cls = NULL,
+    .parser = &parse_timestamp,
     .field = name,
-    .ptr = at,
-    .ptr_size = sizeof(struct GNUNET_TIME_Absolute),
-    .size_ptr = NULL
+    .ptr = t,
+    .ptr_size = sizeof(struct GNUNET_TIME_Timestamp)
   };
 
   return ret;
@@ -660,40 +695,37 @@ GNUNET_JSON_spec_absolute_time (const char *name,
  * @param[out] spec where to write the data
  * @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
  */
-static int
-parse_abs_time_nbo (void *cls,
-                    json_t *root,
-                    struct GNUNET_JSON_Specification *spec)
+static enum GNUNET_GenericReturnValue
+parse_timestamp_nbo (void *cls,
+                     json_t *root,
+                     struct GNUNET_JSON_Specification *spec)
 {
-  struct GNUNET_TIME_AbsoluteNBO *abs = spec->ptr;
-  struct GNUNET_TIME_Absolute a;
+  struct GNUNET_TIME_TimestampNBO *ts = spec->ptr;
+  struct GNUNET_TIME_Timestamp a;
   struct GNUNET_JSON_Specification ispec;
 
   ispec = *spec;
-  ispec.parser = &parse_abs_time;
+  ispec.parser = &parse_timestamp;
   ispec.ptr = &a;
   if (GNUNET_OK !=
-      parse_abs_time (NULL,
-                      root,
-                      &ispec))
+      parse_timestamp (NULL,
+                       root,
+                       &ispec))
     return GNUNET_SYSERR;
-  *abs = GNUNET_TIME_absolute_hton (a);
+  *ts = GNUNET_TIME_timestamp_hton (a);
   return GNUNET_OK;
 }
 
 
 struct GNUNET_JSON_Specification
-GNUNET_JSON_spec_absolute_time_nbo (const char *name,
-                                    struct GNUNET_TIME_AbsoluteNBO *at)
+GNUNET_JSON_spec_timestamp_nbo (const char *name,
+                                struct GNUNET_TIME_TimestampNBO *at)
 {
   struct GNUNET_JSON_Specification ret = {
-    .parser = &parse_abs_time_nbo,
-    .cleaner = NULL,
-    .cls = NULL,
+    .parser = &parse_timestamp_nbo,
     .field = name,
     .ptr = at,
-    .ptr_size = sizeof(struct GNUNET_TIME_AbsoluteNBO),
-    .size_ptr = NULL
+    .ptr_size = sizeof(struct GNUNET_TIME_TimestampNBO)
   };
 
   return ret;
@@ -708,12 +740,13 @@ GNUNET_JSON_spec_absolute_time_nbo (const char *name,
  * @param[out] spec where to write the data
  * @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
  */
-static int
+static enum GNUNET_GenericReturnValue
 parse_rel_time (void *cls,
                 json_t *root,
                 struct GNUNET_JSON_Specification *spec)
 {
   struct GNUNET_TIME_Relative *rel = spec->ptr;
+  json_t *json_d_us;
   json_t *json_d_ms;
   unsigned long long int tval;
 
@@ -722,25 +755,52 @@ parse_rel_time (void *cls,
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
-  json_d_ms = json_object_get (root, "d_ms");
-  if (json_is_integer (json_d_ms))
+  json_d_us = json_object_get (root,
+                               "d_us");
+  if (json_is_integer (json_d_us))
   {
-    tval = json_integer_value (json_d_ms);
-    /* Time is in milliseconds in JSON, but in microseconds in GNUNET_TIME_Absolute */
-    rel->rel_value_us = tval * 1000LL;
-    if ((rel->rel_value_us) / 1000LL != tval)
+    tval = json_integer_value (json_d_us);
+    if (tval >= (1LLU << 53))
     {
-      /* Integer overflow */
+      /* value is larger than allowed */
       GNUNET_break_op (0);
       return GNUNET_SYSERR;
     }
+    rel->rel_value_us = tval;
+    return GNUNET_OK;
+  }
+  if (json_is_string (json_d_us))
+  {
+    const char *val;
+
+    val = json_string_value (json_d_us);
+    if ((0 == strcasecmp (val,
+                          "forever")))
+    {
+      *rel = GNUNET_TIME_UNIT_FOREVER_REL;
+      return GNUNET_OK;
+    }
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+
+  json_d_ms = json_object_get (root,
+                               "d_ms");
+  if (json_is_integer (json_d_ms))
+  {
+    tval = json_integer_value (json_d_ms);
+    *rel = GNUNET_TIME_relative_multiply (
+      GNUNET_TIME_UNIT_MILLISECONDS,
+      tval);
     return GNUNET_OK;
   }
   if (json_is_string (json_d_ms))
   {
     const char *val;
+
     val = json_string_value (json_d_ms);
-    if ((0 == strcasecmp (val, "forever")))
+    if ((0 == strcasecmp (val,
+                          "forever")))
     {
       *rel = GNUNET_TIME_UNIT_FOREVER_REL;
       return GNUNET_OK;
@@ -759,12 +819,9 @@ GNUNET_JSON_spec_relative_time (const char *name,
 {
   struct GNUNET_JSON_Specification ret = {
     .parser = &parse_rel_time,
-    .cleaner = NULL,
-    .cls = NULL,
     .field = name,
     .ptr = rt,
-    .ptr_size = sizeof(struct GNUNET_TIME_Relative),
-    .size_ptr = NULL
+    .ptr_size = sizeof(struct GNUNET_TIME_Relative)
   };
 
   return ret;
@@ -779,7 +836,7 @@ GNUNET_JSON_spec_relative_time (const char *name,
  * @param[out] spec where to write the data
  * @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
  */
-static int
+static enum GNUNET_GenericReturnValue
 parse_rsa_public_key (void *cls,
                       json_t *root,
                       struct GNUNET_JSON_Specification *spec)
@@ -864,7 +921,7 @@ GNUNET_JSON_spec_rsa_public_key (const char *name,
  * @param[out] spec where to write the data
  * @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
  */
-static int
+static enum GNUNET_GenericReturnValue
 parse_rsa_signature (void *cls,
                      json_t *root,
                      struct GNUNET_JSON_Specification *spec)
@@ -952,7 +1009,7 @@ GNUNET_JSON_spec_rsa_signature (const char *name,
  * @param[out] spec where to write the data
  * @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
  */
-static int
+static enum GNUNET_GenericReturnValue
 parse_boolean (void *cls,
                json_t *root,
                struct GNUNET_JSON_Specification *spec)
diff --git a/src/json/json_pack.c b/src/json/json_pack.c
index 92f8b4535..296f56104 100644
--- a/src/json/json_pack.c
+++ b/src/json/json_pack.c
@@ -245,16 +245,16 @@ GNUNET_JSON_pack_data_varsize (const char *name,
 
 
 struct GNUNET_JSON_PackSpec
-GNUNET_JSON_pack_time_abs (const char *name,
-                           struct GNUNET_TIME_Absolute at)
+GNUNET_JSON_pack_timestamp (const char *name,
+                            struct GNUNET_TIME_Timestamp t)
 {
   struct GNUNET_JSON_PackSpec ps = {
     .field_name = name
   };
 
-  if (0 != at.abs_value_us)
+  if (! GNUNET_TIME_absolute_is_zero (t.abs_time))
   {
-    ps.object = GNUNET_JSON_from_time_abs (at);
+    ps.object = GNUNET_JSON_from_timestamp (t);
     GNUNET_assert (NULL != ps.object);
   }
   else
@@ -266,11 +266,11 @@ GNUNET_JSON_pack_time_abs (const char *name,
 
 
 struct GNUNET_JSON_PackSpec
-GNUNET_JSON_pack_time_abs_nbo (const char *name,
-                               struct GNUNET_TIME_AbsoluteNBO at)
+GNUNET_JSON_pack_timestamp_nbo (const char *name,
+                                struct GNUNET_TIME_TimestampNBO at)
 {
-  return GNUNET_JSON_pack_time_abs (name,
-                                    GNUNET_TIME_absolute_ntoh (at));
+  return GNUNET_JSON_pack_timestamp (name,
+                                     GNUNET_TIME_timestamp_ntoh (at));
 }
 
 
diff --git a/src/json/test_json.c b/src/json/test_json.c
index 4485a37a4..d6c372cf3 100644
--- a/src/json/test_json.c
+++ b/src/json/test_json.c
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet
-   (C) 2015, 2016 GNUnet e.V.
+   (C) 2015, 2016, 2021 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -34,33 +34,44 @@
  * @return 0 on success
  */
 static int
-test_abs_time ()
+test_timestamp (void)
 {
   json_t *j;
   struct GNUNET_TIME_Absolute a1;
-  struct GNUNET_TIME_Absolute a2;
-  struct GNUNET_JSON_Specification s1[] = { GNUNET_JSON_spec_absolute_time (
-                                              NULL,
-                                              &a2),
-                                            GNUNET_JSON_spec_end () };
-  struct GNUNET_JSON_Specification s2[] = { GNUNET_JSON_spec_absolute_time (
-                                              NULL,
-                                              &a2),
-                                            GNUNET_JSON_spec_end () };
+  struct GNUNET_TIME_Timestamp t1;
+  struct GNUNET_TIME_Timestamp t2;
+  struct GNUNET_JSON_Specification s1[] = {
+    GNUNET_JSON_spec_timestamp (NULL,
+                                &t2),
+    GNUNET_JSON_spec_end ()
+  };
+  struct GNUNET_JSON_Specification s2[] = {
+    GNUNET_JSON_spec_timestamp (NULL,
+                                &t2),
+    GNUNET_JSON_spec_end ()
+  };
 
   a1 = GNUNET_TIME_absolute_get ();
-  GNUNET_TIME_round_abs (&a1);
-  j = GNUNET_JSON_from_time_abs (a1);
+  t1 = GNUNET_TIME_absolute_to_timestamp (a1);
+  j = GNUNET_JSON_from_timestamp (t1);
   GNUNET_assert (NULL != j);
-  GNUNET_assert (GNUNET_OK == GNUNET_JSON_parse (j, s1, NULL, NULL));
-  GNUNET_assert (a1.abs_value_us == a2.abs_value_us);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_JSON_parse (j,
+                                    s1,
+                                    NULL,
+                                    NULL));
+  GNUNET_assert (GNUNET_TIME_timestamp_cmp (t1, ==, t2));
   json_decref (j);
 
   a1 = GNUNET_TIME_UNIT_FOREVER_ABS;
-  j = GNUNET_JSON_from_time_abs (a1);
+  j = GNUNET_JSON_from_timestamp (t1);
   GNUNET_assert (NULL != j);
-  GNUNET_assert (GNUNET_OK == GNUNET_JSON_parse (j, s2, NULL, NULL));
-  GNUNET_assert (a1.abs_value_us == a2.abs_value_us);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_JSON_parse (j,
+                                    s2,
+                                    NULL,
+                                    NULL));
+  GNUNET_assert (GNUNET_TIME_timestamp_cmp (t1, ==, t2));
   json_decref (j);
   return 0;
 }
@@ -72,19 +83,21 @@ test_abs_time ()
  * @return 0 on success
  */
 static int
-test_rel_time ()
+test_rel_time (void)
 {
   json_t *j;
   struct GNUNET_TIME_Relative r1;
   struct GNUNET_TIME_Relative r2;
-  struct GNUNET_JSON_Specification s1[] = { GNUNET_JSON_spec_relative_time (
-                                              NULL,
-                                              &r2),
-                                            GNUNET_JSON_spec_end () };
-  struct GNUNET_JSON_Specification s2[] = { GNUNET_JSON_spec_relative_time (
-                                              NULL,
-                                              &r2),
-                                            GNUNET_JSON_spec_end () };
+  struct GNUNET_JSON_Specification s1[] = {
+    GNUNET_JSON_spec_relative_time (NULL,
+                                    &r2),
+    GNUNET_JSON_spec_end ()
+  };
+  struct GNUNET_JSON_Specification s2[] = {
+    GNUNET_JSON_spec_relative_time (NULL,
+                                    &r2),
+    GNUNET_JSON_spec_end ()
+  };
 
   r1 = GNUNET_TIME_UNIT_SECONDS;
   j = GNUNET_JSON_from_time_rel (r1);
@@ -211,7 +224,7 @@ int
 main (int argc, const char *const argv[])
 {
   GNUNET_log_setup ("test-json", "WARNING", NULL);
-  if (0 != test_abs_time ())
+  if (0 != test_timestamp ())
     return 1;
   if (0 != test_rel_time ())
     return 1;