src/reclaim/json_reclaim.c

   1 /*
   2    This file is part of GNUnet.
   3    Copyright (C) 2009-2018 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
  21 /**
  22  * @file rest-plugins/json_reclaim.c
  23  * @brief JSON handling of reclaim data
  24  * @author Martin Schanzenbach
  25  */
  26 #include "platform.h"
  27
  28 #include "gnunet_util_lib.h"
  29
  30 #include "gnunet_json_lib.h"
  31 #include "gnunet_reclaim_attribute_lib.h"
  32 #include "gnunet_reclaim_service.h"
  33
  34
  35 /**
  36  * Parse given JSON object to a claim
  37  *
  38  * @param cls closure, NULL
  39  * @param root the json object representing data
  40  * @param spec where to write the data
  41  * @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
  42  */
  43 static int
  44 parse_attr (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
  45 {
  46   struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr;
  47   const char *name_str = NULL;
  48   const char *val_str = NULL;
  49   const char *type_str = NULL;
  50   const char *id_str = NULL;
  51   char *data;
  52   int unpack_state;
  53   uint32_t type;
  54   size_t data_size;
  55
  56   GNUNET_assert (NULL != root);
  57
  58   if (! json_is_object (root))
  59   {
  60     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
  61                 "Error json is not array nor object!\n");
  62     return GNUNET_SYSERR;
  63   }
  64   // interpret single attribute
  65   unpack_state = json_unpack (root,
  66                               "{s:s, s?s, s:s, s:s!}",
  67                               "name",
  68                               &name_str,
  69                               "id",
  70                               &id_str,
  71                               "type",
  72                               &type_str,
  73                               "value",
  74                               &val_str);
  75   if ((0 != unpack_state) || (NULL == name_str) || (NULL == val_str) ||
  76       (NULL == type_str))
  77   {
  78     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
  79                 "Error json object has a wrong format!\n");
  80     return GNUNET_SYSERR;
  81   }
  82   type = GNUNET_RECLAIM_ATTRIBUTE_typename_to_number (type_str);
  83   if (GNUNET_SYSERR ==
  84       (GNUNET_RECLAIM_ATTRIBUTE_string_to_value (type,
  85                                                  val_str,
  86                                                  (void **) &data,
  87                                                  &data_size)))
  88   {
  89     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Attribute value invalid!\n");
  90     return GNUNET_SYSERR;
  91   }
  92   attr = GNUNET_RECLAIM_ATTRIBUTE_claim_new (name_str, type, data, data_size);
  93   if ((NULL == id_str) || (0 == strlen (id_str)))
  94     attr->id = 0;
  95   else
  96     GNUNET_STRINGS_string_to_data (id_str,
  97                                    strlen (id_str),
  98                                    &attr->id,
  99                                    sizeof (uint64_t));
 100
 101   *(struct GNUNET_RECLAIM_ATTRIBUTE_Claim **) spec->ptr = attr;
 102   return GNUNET_OK;
 103 }
 104
 105 /**
 106  * Cleanup data left from parsing RSA public key.
 107  *
 108  * @param cls closure, NULL
 109  * @param[out] spec where to free the data
 110  */
 111 static void
 112 clean_attr (void *cls, struct GNUNET_JSON_Specification *spec)
 113 {
 114   struct GNUNET_RECLAIM_ATTRIBUTE_Claim **attr;
 115   attr = (struct GNUNET_RECLAIM_ATTRIBUTE_Claim **) spec->ptr;
 116   if (NULL != *attr)
 117   {
 118     GNUNET_free (*attr);
 119     *attr = NULL;
 120   }
 121 }
 122
 123 /**
 124  * JSON Specification for Reclaim claims.
 125  *
 126  * @param ticket struct of GNUNET_RECLAIM_ATTRIBUTE_Claim to fill
 127  * @return JSON Specification
 128  */
 129 struct GNUNET_JSON_Specification
 130 GNUNET_RECLAIM_JSON_spec_claim (struct GNUNET_RECLAIM_ATTRIBUTE_Claim **attr)
 131 {
 132   struct GNUNET_JSON_Specification ret = {.parser = &parse_attr,
 133                                           .cleaner = &clean_attr,
 134                                           .cls = NULL,
 135                                           .field = NULL,
 136                                           .ptr = attr,
 137                                           .ptr_size = 0,
 138                                           .size_ptr = NULL};
 139   *attr = NULL;
 140   return ret;
 141 }
 142 /**
 143  * Parse given JSON object to a ticket
 144  *
 145  * @param cls closure, NULL
 146  * @param root the json object representing data
 147  * @param spec where to write the data
 148  * @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
 149  */
 150 static int
 151 parse_ticket (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
 152 {
 153   struct GNUNET_RECLAIM_Ticket *ticket;
 154   const char *rnd_str;
 155   const char *aud_str;
 156   const char *id_str;
 157   int unpack_state;
 158
 159   GNUNET_assert (NULL != root);
 160
 161   if (! json_is_object (root))
 162   {
 163     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 164                 "Error json is not array nor object!\n");
 165     return GNUNET_SYSERR;
 166   }
 167   // interpret single ticket
 168   unpack_state = json_unpack (root,
 169                               "{s:s, s:s, s:s!}",
 170                               "rnd",
 171                               &rnd_str,
 172                               "audience",
 173                               &aud_str,
 174                               "issuer",
 175                               &id_str);
 176   if (0 != unpack_state)
 177   {
 178     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 179                 "Error json object has a wrong format!\n");
 180     return GNUNET_SYSERR;
 181   }
 182   ticket = GNUNET_new (struct GNUNET_RECLAIM_Ticket);
 183   if (GNUNET_OK != GNUNET_STRINGS_string_to_data (rnd_str,
 184                                                   strlen (rnd_str),
 185                                                   &ticket->rnd,
 186                                                   sizeof (uint64_t)))
 187   {
 188     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Rnd invalid\n");
 189     GNUNET_free (ticket);
 190     return GNUNET_SYSERR;
 191   }
 192   if (GNUNET_OK !=
 193       GNUNET_STRINGS_string_to_data (id_str,
 194                                      strlen (id_str),
 195                                      &ticket->identity,
 196                                      sizeof (
 197                                        struct GNUNET_CRYPTO_EcdsaPublicKey)))
 198   {
 199     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Identity invalid\n");
 200     GNUNET_free (ticket);
 201     return GNUNET_SYSERR;
 202   }
 203
 204   if (GNUNET_OK !=
 205       GNUNET_STRINGS_string_to_data (aud_str,
 206                                  strlen (aud_str),
 207                                  &ticket->audience,
 208                                  sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
 209   {
 210     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Audience invalid\n");
 211     GNUNET_free (ticket);
 212     return GNUNET_SYSERR;
 213   }
 214
 215   *(struct GNUNET_RECLAIM_Ticket **) spec->ptr = ticket;
 216   return GNUNET_OK;
 217 }
 218
 219 /**
 220  * Cleanup data left from parsing RSA public key.
 221  *
 222  * @param cls closure, NULL
 223  * @param[out] spec where to free the data
 224  */
 225 static void
 226 clean_ticket (void *cls, struct GNUNET_JSON_Specification *spec)
 227 {
 228   struct GNUNET_RECLAIM_Ticket **ticket;
 229   ticket = (struct GNUNET_RECLAIM_Ticket **) spec->ptr;
 230   if (NULL != *ticket)
 231   {
 232     GNUNET_free (*ticket);
 233     *ticket = NULL;
 234   }
 235 }
 236
 237 /**
 238  * JSON Specification for Reclaim tickets.
 239  *
 240  * @param ticket struct of GNUNET_RECLAIM_Ticket to fill
 241  * @return JSON Specification
 242  */
 243 struct GNUNET_JSON_Specification
 244 GNUNET_RECLAIM_JSON_spec_ticket (struct GNUNET_RECLAIM_Ticket **ticket)
 245 {
 246   struct GNUNET_JSON_Specification ret = {.parser = &parse_ticket,
 247                                           .cleaner = &clean_ticket,
 248                                           .cls = NULL,
 249                                           .field = NULL,
 250                                           .ptr = ticket,
 251                                           .ptr_size = 0,
 252                                           .size_ptr = NULL};
 253   *ticket = NULL;
 254   return ret;
 255 }