-eliminating some legacy json_pack calls from Anastasis

4 files changed, 152 insertions, 155 deletions

diff --git a/contrib/gana b/contrib/gana
-Subproject 755e752e3a235df0be8d45374835b109f7843c1
+Subproject 0f1eb8555b89056fe62e093211e53a1f9ba85d5
diff --git a/src/reducer/anastasis_api_backup_redux.c b/src/reducer/anastasis_api_backup_redux.c
index cea1360..02e2401 100644
--- a/src/reducer/anastasis_api_backup_redux.c
+++ b/src/reducer/anastasis_api_backup_redux.c
@@ -1440,20 +1440,22 @@ select_policies (struct PolicyBuilder *pb)
       GNUNET_assert (NULL != method_arr);
       for (unsigned int i = 0; i < pb->req_methods; i++)
       {
-        json_t *policy_method = json_pack ("{s:I, s:s}",
-                                           "authentication_method",
-                                           (json_int_t) p->challenges[i],
-                                           "provider",
-                                           pm->providers[i].provider_name);
+        json_t *policy_method = GNUNET_JSON_PACK (
+          GNUNET_JSON_pack_uint64 ("authentication_method",
+                                   p->challenges[i]),
+          GNUNET_JSON_pack_string ("provider",
+                                   pm->providers[i].provider_name));
+
         GNUNET_assert (0 ==
                        json_array_append_new (method_arr,
                                               policy_method));
       }
       {
-        json_t *policy = json_pack ("{s:o}",
-                                    "methods",
-                                    method_arr);
-        GNUNET_assert (NULL != policy);
+        json_t *policy = GNUNET_JSON_PACK (
+          GNUNET_JSON_pack_array_steal (
+            "methods",
+            method_arr));
+
         GNUNET_assert (0 ==
                        json_array_append_new (pb->policies,
                                               policy));
@@ -1616,8 +1618,9 @@ done_authentication (json_t *state,
                        url,
                        &salt))
         continue; /* skip providers that are down */
-      provider = json_pack ("{s:s}",
-                            "provider_url", url);
+      provider = GNUNET_JSON_PACK (
+        GNUNET_JSON_pack_string ("provider_url",
+                                 url));
       GNUNET_assert (NULL != provider);
       GNUNET_assert (0 ==
                      json_array_append_new (policy_providers,
@@ -1651,9 +1654,9 @@ done_authentication (json_t *state,
                                "unworkable provider requested");
         return NULL;
       }
-      provider = json_pack ("{s:s}",
-                            "provider_url", url);
-      GNUNET_assert (NULL != provider);
+      provider = GNUNET_JSON_PACK (
+        GNUNET_JSON_pack_string ("provider_url",
+                                 url_str));
       GNUNET_assert (0 ==
                      json_array_append_new (policy_providers,
                                             provider));
@@ -1968,10 +1971,9 @@ add_policy (json_t *state,
     json_t *policy;
     json_t *idx;
 
-    policy = json_pack ("{s:o}",
-                        "methods",
-                        methods);
-    GNUNET_assert (NULL != policy);
+    policy = GNUNET_JSON_PACK (
+      GNUNET_JSON_pack_array_steal ("methods",
+                                    methods));
     idx = json_object_get (arguments,
                            "policy_index");
     if ( (NULL == idx) ||
@@ -2447,9 +2449,9 @@ update_expiration_cost (json_t *state,
       {
         json_t *ao;
 
-        ao = json_pack ("{s:o}",
-                        "fee",
-                        TALER_JSON_from_amount (&costs->cost));
+        ao = GNUNET_JSON_PACK (
+          TALER_JSON_pack_amount ("fee",
+                                  &costs->cost));
         GNUNET_assert (0 ==
                        json_array_append_new (arr,
                                               ao));
@@ -2821,11 +2823,11 @@ secret_share_result_cb (void *cls,
           = &sr->details.success.pss[i];
         json_t *d;
 
-        d = json_pack ("{s:I, s:o}",
-                       "policy_version",
-                       pssi->policy_version,
-                       "policy_expiration",
-                       GNUNET_JSON_from_time_abs (pssi->policy_expiration));
+        d = GNUNET_JSON_PACK (
+          GNUNET_JSON_pack_uint64 ("policy_version",
+                                   pssi->policy_version),
+          GNUNET_JSON_pack_time_abs ("policy_expiration",
+                                     pssi->policy_expiration));
         GNUNET_assert (NULL != d);
         GNUNET_assert (0 ==
                        json_object_set_new (sa,
@@ -2864,11 +2866,11 @@ secret_share_result_cb (void *cls,
         json_t *provider;
 
         spr = &sr->details.payment_required.payment_requests[i];
-        pr = json_pack ("{s:s, s:s}",
-                        "payto",
-                        spr->payment_request_url,
-                        "provider",
-                        spr->provider_url);
+        pr = GNUNET_JSON_PACK (
+          GNUNET_JSON_pack_string ("payto",
+                                   spr->payment_request_url),
+          GNUNET_JSON_pack_string ("provider",
+                                   spr->provider_url));
         GNUNET_assert (0 ==
                        json_array_append_new (ra,
                                               pr));
@@ -2916,15 +2918,15 @@ secret_share_result_cb (void *cls,
     {
       json_t *details;
 
-      details = json_pack ("{s:s, s:I, s:I, s:s}",
-                           "backup_state",
-                           "ERROR",
-                           "http_status",
-                           (json_int_t) sr->details.provider_failure.http_status,
-                           "upload_status",
-                           (json_int_t) sr->details.provider_failure.ec,
-                           "provider_url",
-                           sr->details.provider_failure.provider_url);
+      details = GNUNET_JSON_PACK (
+        GNUNET_JSON_pack_string ("backup_state",
+                                 "ERROR"),
+        GNUNET_JSON_pack_uint64 ("http_status",
+                                 sr->details.provider_failure.http_status),
+        GNUNET_JSON_pack_uint64 ("upload_status",
+                                 sr->details.provider_failure.ec),
+        GNUNET_JSON_pack_string ("provider_url",
+                                 sr->details.provider_failure.provider_url));
       uc->cb (uc->cb_cls,
               TALER_EC_ANASTASIS_REDUCER_BACKUP_PROVIDER_FAILED,
               details);
diff --git a/src/reducer/anastasis_api_recovery_redux.c b/src/reducer/anastasis_api_recovery_redux.c
index 77f5847..c0fae18 100644
--- a/src/reducer/anastasis_api_recovery_redux.c
+++ b/src/reducer/anastasis_api_recovery_redux.c
@@ -452,10 +452,9 @@ answer_feedback_cb (
     {
       json_t *solved;
 
-      solved = json_pack ("{s:s}",
-                          "state",
-                          "solved");
-      GNUNET_assert (NULL != solved);
+      solved = GNUNET_JSON_PACK (
+        GNUNET_JSON_pack_string ("state",
+                                 "solved"));
       GNUNET_assert (0 ==
                      json_object_set_new (feedback,
                                           uuid,
@@ -470,7 +469,6 @@ answer_feedback_cb (
   case ANASTASIS_CHALLENGE_STATUS_INSTRUCTIONS:
     {
       json_t *instructions;
-      json_t *val;
       const char *mime;
 
       mime = csr->details.open_challenge.content_type;
@@ -484,14 +482,14 @@ answer_feedback_cb (
           char *s = GNUNET_strndup (csr->details.open_challenge.body,
                                     csr->details.open_challenge.body_size);
 
-          instructions = json_pack (
-            "{s:s, s:s, s:I}",
-            "state",
-            "hint",
-            "hint",
-            s,
-            "http_status",
-            (json_int_t) csr->details.open_challenge.http_status);
+          instructions = GNUNET_JSON_PACK (
+            GNUNET_JSON_pack_string ("state",
+                                     "hint"),
+            GNUNET_JSON_pack_string ("hint",
+                                     s),
+            GNUNET_JSON_pack_uint64 ("http_status",
+                                     (json_int_t) csr->details.open_challenge.
+                                     http_status));
           GNUNET_free (s);
         }
         else if (0 == strcasecmp (mime,
@@ -510,14 +508,13 @@ answer_feedback_cb (
           }
           else
           {
-            instructions = json_pack (
-              "{s:s, s:o, s:I}",
-              "state",
-              "details",
-              "details",
-              body,
-              "http_status",
-              (json_int_t) csr->details.open_challenge.http_status);
+            instructions = GNUNET_JSON_PACK (
+              GNUNET_JSON_pack_string ("state",
+                                       "details"),
+              GNUNET_JSON_pack_object_steal ("details",
+                                             body),
+              GNUNET_JSON_pack_uint64 ("http_status",
+                                       csr->details.open_challenge.http_status));
           }
         }
         else
@@ -528,21 +525,18 @@ answer_feedback_cb (
       }
       if (NULL == mime)
       {
-        val = GNUNET_JSON_from_data (csr->details.open_challenge.body,
-                                     csr->details.open_challenge.body_size);
-        GNUNET_assert (NULL != val);
-        instructions = json_pack (
-          "{s:s, s:o, s:I, s:s?}",
-          "state",
-          "body",
-          "body",
-          val,
-          "http_status",
-          (json_int_t) csr->details.open_challenge.http_status,
-          "mime_type",
-          mime);
+        instructions = GNUNET_JSON_PACK (
+          GNUNET_JSON_pack_string ("state",
+                                   "body"),
+          GNUNET_JSON_pack_data_varsize ("body",
+                                         csr->details.open_challenge.body,
+                                         csr->details.open_challenge.body_size),
+          GNUNET_JSON_pack_uint64 ("http_status",
+                                   csr->details.open_challenge.http_status),
+          GNUNET_JSON_pack_allow_null (
+            GNUNET_JSON_pack_string ("mime_type",
+                                     mime)));
       }
-      GNUNET_assert (NULL != instructions);
       GNUNET_assert (0 ==
                      json_object_set_new (feedback,
                                           uuid,
@@ -559,11 +553,11 @@ answer_feedback_cb (
     {
       json_t *redir;
 
-      redir = json_pack ("{s:s, s:s}",
-                         "state",
-                         "redirect",
-                         "redirect_url",
-                         csr->details.redirect_url);
+      redir = GNUNET_JSON_PACK (
+        GNUNET_JSON_pack_string ("state",
+                                 "redirect"),
+        GNUNET_JSON_pack_string ("redirect_url",
+                                 csr->details.redirect_url));
       GNUNET_assert (NULL != redir);
       GNUNET_assert (0 ==
                      json_object_set_new (feedback,
@@ -581,17 +575,17 @@ answer_feedback_cb (
     {
       json_t *pay;
 
-      pay = json_pack ("{s:s, s:s, s:s, s:o}",
-                       "state",
-                       "payment",
-                       "taler_pay_uri",
-                       csr->details.payment_required.taler_pay_uri,
-                       "provider",
-                       cd->provider_url,
-                       "payment_secret",
-                       GNUNET_JSON_from_data_auto (
-                         &csr->details.payment_required.payment_secret));
-      GNUNET_assert (NULL != pay);
+      pay = GNUNET_JSON_PACK (
+        GNUNET_JSON_pack_string ("state",
+                                 "payment"),
+        GNUNET_JSON_pack_string ("taler_pay_uri",
+                                 csr->details.payment_required.
+                                 taler_pay_uri),
+        GNUNET_JSON_pack_string ("provider",
+                                 cd->provider_url),
+        GNUNET_JSON_pack_data_auto (
+          "payment_secret",
+          &csr->details.payment_required.payment_secret));
       GNUNET_assert (0 ==
                      json_object_set_new (feedback,
                                           uuid,
@@ -604,11 +598,11 @@ answer_feedback_cb (
 
       GNUNET_assert (NULL != challenge);
       GNUNET_assert (0 ==
-                     json_object_set_new (challenge,
-                                          "payment_secret",
-                                          GNUNET_JSON_from_data_auto (
-                                            &csr->details.payment_required.
-                                            payment_secret)));
+                     json_object_set_new (
+                       challenge,
+                       "payment_secret",
+                       GNUNET_JSON_from_data_auto (
+                         &csr->details.payment_required.payment_secret)));
     }
     set_state (sctx->state,
                ANASTASIS_RECOVERY_STATE_CHALLENGE_PAYING);
@@ -621,14 +615,14 @@ answer_feedback_cb (
     {
       json_t *err;
 
-      err = json_pack ("{s:s, s:I, s:I}",
-                       "state",
-                       "server-failure",
-                       "http_status",
-                       (json_int_t) csr->details.server_failure.http_status,
-                       "error_code",
-                       (json_int_t) csr->details.server_failure.ec);
-      GNUNET_assert (NULL != err);
+      err = GNUNET_JSON_PACK (
+        GNUNET_JSON_pack_string ("state",
+                                 "server-failure"),
+        GNUNET_JSON_pack_uint64 ("http_status",
+                                 csr->details.server_failure.
+                                 http_status),
+        GNUNET_JSON_pack_uint64 ("error_code",
+                                 csr->details.server_failure.ec));
       GNUNET_assert (0 ==
                      json_object_set_new (feedback,
                                           uuid,
@@ -646,12 +640,11 @@ answer_feedback_cb (
     {
       json_t *err;
 
-      err = json_pack ("{s:s, s:I}",
-                       "state",
-                       "truth-unknown",
-                       "error_code",
-                       (json_int_t) TALER_EC_ANASTASIS_TRUTH_UNKNOWN);
-      GNUNET_assert (NULL != err);
+      err = GNUNET_JSON_PACK (
+        GNUNET_JSON_pack_string ("state",
+                                 "truth-unknown"),
+        GNUNET_JSON_pack_uint64 ("error_code",
+                                 TALER_EC_ANASTASIS_TRUTH_UNKNOWN));
       GNUNET_assert (0 ==
                      json_object_set_new (feedback,
                                           uuid,
@@ -668,13 +661,11 @@ answer_feedback_cb (
     {
       json_t *err;
 
-      err = json_pack ("{s:s, s:I}",
-                       "state",
-                       "rate-limit-exceeded",
-                       "error_code",
-                       (json_int_t) TALER_EC_ANASTASIS_TRUTH_RATE_LIMITED);
-
-      GNUNET_assert (NULL != err);
+      err = GNUNET_JSON_PACK (
+        GNUNET_JSON_pack_string ("state",
+                                 "rate-limit-exceeded"),
+        GNUNET_JSON_pack_uint64 ("error_code",
+                                 TALER_EC_ANASTASIS_TRUTH_RATE_LIMITED));
       GNUNET_assert (0 ==
                      json_object_set_new (feedback,
                                           uuid,
@@ -1585,13 +1576,13 @@ change_version (json_t *state,
                            "'identity_attributes' missing");
     return NULL;
   }
-  args = json_pack ("{s:I, s:O, s:s}",
-                    "version",
-                    (json_int_t) version,
-                    "identity_attributes",
-                    ia,
-                    "provider_url",
-                    provider_url);
+  args = GNUNET_JSON_PACK (
+    GNUNET_JSON_pack_uint64 ("version",
+                             version),
+    GNUNET_JSON_pack_object_incref ("identity_attributes",
+                                    (json_t *) ia),
+    GNUNET_JSON_pack_string ("provider_url",
+                             provider_url));
   if (NULL == args)
   {
     GNUNET_break (0);
@@ -2101,12 +2092,13 @@ return_no_policy (struct RecoverSecretState *rss,
 
   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
               "No provider online, need user to manually specify providers!\n");
-  msg = json_pack ("{s:s, s:b}",
-                   "hint",
-                   offline ? "could not contact provider" :
-                   "provider does not know you",
-                   "offline",
-                   offline);
+  msg = GNUNET_JSON_PACK (
+    GNUNET_JSON_pack_string ("hint",
+                             offline
+                             ? "could not contact provider"
+                             : "provider does not know you"),
+    GNUNET_JSON_pack_bool ("offline",
+                           offline));
   GNUNET_assert (0 ==
                  json_object_set_new (rss->state,
                                       "recovery_error",
@@ -2179,10 +2171,9 @@ policy_lookup_cb (void *cls,
       json_t *cj;
 
       cd = ANASTASIS_challenge_get_details (c);
-      cj = json_pack ("{s:o}",
-                      "uuid",
-                      GNUNET_JSON_from_data_auto (&cd->uuid));
-      GNUNET_assert (NULL != cj);
+      cj = GNUNET_JSON_PACK (
+        GNUNET_JSON_pack_data_auto ("uuid",
+                                    &cd->uuid));
       GNUNET_assert (0 ==
                      json_array_append_new (pchallenges,
                                             cj));
@@ -2221,29 +2212,33 @@ policy_lookup_cb (void *cls,
       return;
     }
 
-    cj = json_pack ("{s:o,s:o?,s:s,s:s}",
-                    "uuid",
-                    GNUNET_JSON_from_data_auto (&cd->uuid),
-                    "cost",
-                    (GNUNET_NO == ret)
-                    ? NULL
-                    : TALER_JSON_from_amount (&cost),
-                    "type",
-                    cd->type,
-                    "instructions",
-                    cd->instructions);
-    GNUNET_assert (NULL != cj);
+    cj = GNUNET_JSON_PACK (
+      GNUNET_JSON_pack_data_auto ("uuid",
+                                  &cd->uuid),
+      TALER_JSON_pack_amount ("cost",
+                              (GNUNET_NO == ret)
+                              ? NULL
+                              : &cost),
+      GNUNET_JSON_pack_string ("type",
+                               cd->type),
+      GNUNET_JSON_pack_string ("instructions",
+                               cd->instructions));
     GNUNET_assert (0 ==
                    json_array_append_new (challenges,
                                           cj));
   } /* end for all challenges */
-  recovery_information = json_pack ("{s:o, s:o, s:s?, s:s, s:I}",
-                                    "challenges", challenges,
-                                    "policies", policies,
-                                    "secret_name", ri->secret_name,
-                                    "provider_url", pd->backend_url,
-                                    "version", (json_int_t) ri->version);
-  GNUNET_assert (NULL != recovery_information);
+  recovery_information = GNUNET_JSON_PACK (
+    GNUNET_JSON_pack_array_steal ("challenges",
+                                  challenges),
+    GNUNET_JSON_pack_array_steal ("policies",
+                                  policies),
+    GNUNET_JSON_pack_allow_null (
+      GNUNET_JSON_pack_string ("secret_name",
+                               ri->secret_name)),
+    GNUNET_JSON_pack_string ("provider_url",
+                             pd->backend_url),
+    GNUNET_JSON_pack_uint64 ("version",
+                             ri->version));
   GNUNET_assert (0 ==
                  json_object_set_new (rss->state,
                                       "recovery_information",
diff --git a/src/reducer/anastasis_api_redux.c b/src/reducer/anastasis_api_redux.c
index 7b7e5d5..4246682 100644
--- a/src/reducer/anastasis_api_redux.c
+++ b/src/reducer/anastasis_api_redux.c
@@ -1684,8 +1684,8 @@ ANASTASIS_REDUX_load_continents_ ()
       if (NULL == ex)
       {
         ex = GNUNET_JSON_PACK (
-          GNUNET_JSON_pack_object_incref ("name",
-                                          (json_t *) continent));
+          GNUNET_JSON_pack_string ("name",
+                                   json_string_value (continent)));
         GNUNET_assert (0 ==
                        json_array_append_new (continents,
                                               ex));