-eliminating some legacy json_pack calls from Anastasis

1 files changed, 108 insertions, 113 deletions

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",