GNUnet  0.11.x
json_reclaim.c
Go to the documentation of this file.
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 
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "gnunet_json_lib.h"
29 #include "gnunet_reclaim_lib.h"
30 #include "gnunet_reclaim_service.h"
31 
32 
41 static int
42 parse_attr (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
43 {
44  struct GNUNET_RECLAIM_Attribute *attr;
45  const char *name_str = NULL;
46  const char *val_str = NULL;
47  const char *type_str = NULL;
48  const char *id_str = NULL;
49  const char *cred_str = NULL;
50  const char *flag_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  {
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, s:s, s?s!}",
67  "name",
68  &name_str,
69  "id",
70  &id_str,
71  "credential",
72  &cred_str,
73  "type",
74  &type_str,
75  "value",
76  &val_str,
77  "flag",
78  &flag_str);
79  if ((0 != unpack_state) || (NULL == name_str) || (NULL == val_str) ||
80  (NULL == type_str))
81  {
83  "Error json object has a wrong format!\n");
84  return GNUNET_SYSERR;
85  }
87  if (GNUNET_SYSERR ==
89  val_str,
90  (void **) &data,
91  &data_size)))
92  {
93  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Attribute value invalid!\n");
94  return GNUNET_SYSERR;
95  }
96  attr = GNUNET_RECLAIM_attribute_new (name_str, NULL,
97  type, data, data_size);
98  if ((NULL != cred_str) && (0 != strlen (cred_str)))
99  {
101  strlen (cred_str),
102  &attr->credential,
103  sizeof(attr->credential));
104  }
105  if ((NULL == id_str) || (0 == strlen (id_str)))
106  memset (&attr->id, 0, sizeof (attr->id));
107  else
109  strlen (id_str),
110  &attr->id,
111  sizeof(attr->id));
112 
113  *(struct GNUNET_RECLAIM_Attribute **) spec->ptr = attr;
114  return GNUNET_OK;
115 }
116 
117 
124 static void
125 clean_attr (void *cls, struct GNUNET_JSON_Specification *spec)
126 {
127  struct GNUNET_RECLAIM_Attribute **attr;
128 
129  attr = (struct GNUNET_RECLAIM_Attribute **) spec->ptr;
130  if (NULL != *attr)
131  {
132  GNUNET_free (*attr);
133  *attr = NULL;
134  }
135 }
136 
137 
146 {
147  struct GNUNET_JSON_Specification ret = { .parser = &parse_attr,
148  .cleaner = &clean_attr,
149  .cls = NULL,
150  .field = NULL,
151  .ptr = attr,
152  .ptr_size = 0,
153  .size_ptr = NULL };
154 
155  *attr = NULL;
156  return ret;
157 }
158 
159 
168 static int
169 parse_ticket (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
170 {
172  const char *rnd_str;
173  const char *aud_str;
174  const char *id_str;
175  int unpack_state;
176 
177  GNUNET_assert (NULL != root);
178 
179  if (! json_is_object (root))
180  {
182  "Error json is not array nor object!\n");
183  return GNUNET_SYSERR;
184  }
185  // interpret single ticket
186  unpack_state = json_unpack (root,
187  "{s:s, s:s, s:s!}",
188  "rnd",
189  &rnd_str,
190  "audience",
191  &aud_str,
192  "issuer",
193  &id_str);
194  if (0 != unpack_state)
195  {
197  "Error json object has a wrong format!\n");
198  return GNUNET_SYSERR;
199  }
200  ticket = GNUNET_new (struct GNUNET_RECLAIM_Ticket);
202  strlen (rnd_str),
203  &ticket->rnd,
204  sizeof(ticket->rnd)))
205  {
206  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Rnd invalid\n");
207  GNUNET_free (ticket);
208  return GNUNET_SYSERR;
209  }
210  if (GNUNET_OK !=
212  strlen (id_str),
213  &ticket->identity,
214  sizeof(
216  {
217  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Identity invalid\n");
218  GNUNET_free (ticket);
219  return GNUNET_SYSERR;
220  }
221 
222  if (GNUNET_OK !=
224  strlen (aud_str),
225  &ticket->audience,
226  sizeof(struct
228  {
229  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Audience invalid\n");
230  GNUNET_free (ticket);
231  return GNUNET_SYSERR;
232  }
233 
234  *(struct GNUNET_RECLAIM_Ticket **) spec->ptr = ticket;
235  return GNUNET_OK;
236 }
237 
238 
245 static void
246 clean_ticket (void *cls, struct GNUNET_JSON_Specification *spec)
247 {
248  struct GNUNET_RECLAIM_Ticket **ticket;
249 
250  ticket = (struct GNUNET_RECLAIM_Ticket **) spec->ptr;
251  if (NULL != *ticket)
252  {
253  GNUNET_free (*ticket);
254  *ticket = NULL;
255  }
256 }
257 
258 
267 {
268  struct GNUNET_JSON_Specification ret = { .parser = &parse_ticket,
269  .cleaner = &clean_ticket,
270  .cls = NULL,
271  .field = NULL,
272  .ptr = ticket,
273  .ptr_size = 0,
274  .size_ptr = NULL };
275 
276  *ticket = NULL;
277  return ret;
278 }
279 
280 
289 static int
290 parse_credential (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
291 {
292  struct GNUNET_RECLAIM_Credential *cred;
293  const char *name_str = NULL;
294  const char *val_str = NULL;
295  const char *type_str = NULL;
296  const char *id_str = NULL;
297  char *data;
298  int unpack_state;
299  uint32_t type;
300  size_t data_size;
301 
302  GNUNET_assert (NULL != root);
303 
304  if (! json_is_object (root))
305  {
307  "Error json is not array nor object!\n");
308  return GNUNET_SYSERR;
309  }
310  // interpret single attribute
311  unpack_state = json_unpack (root,
312  "{s:s, s?s, s:s, s:s!}",
313  "name",
314  &name_str,
315  "id",
316  &id_str,
317  "type",
318  &type_str,
319  "value",
320  &val_str);
321  if ((0 != unpack_state) || (NULL == name_str) || (NULL == val_str) ||
322  (NULL == type_str))
323  {
325  "Error json object has a wrong format!\n");
326  return GNUNET_SYSERR;
327  }
329  if (GNUNET_SYSERR ==
331  val_str,
332  (void **) &data,
333  &data_size)))
334  {
335  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Credential value invalid!\n");
336  return GNUNET_SYSERR;
337  }
338  cred = GNUNET_RECLAIM_credential_new (name_str, type, data, data_size);
339  if ((NULL == id_str) || (0 == strlen (id_str)))
340  memset (&cred->id, 0, sizeof (cred->id));
341  else
343  strlen (id_str),
344  &cred->id,
345  sizeof(cred->id));
346 
347  *(struct GNUNET_RECLAIM_Credential **) spec->ptr = cred;
348  return GNUNET_OK;
349 }
350 
351 
358 static void
360 {
361  struct GNUNET_RECLAIM_Credential **attr;
362 
363  attr = (struct GNUNET_RECLAIM_Credential **) spec->ptr;
364  if (NULL != *attr)
365  {
366  GNUNET_free (*attr);
367  *attr = NULL;
368  }
369 }
370 
371 
381 {
383  .cleaner = &clean_credential,
384  .cls = NULL,
385  .field = NULL,
386  .ptr = cred,
387  .ptr_size = 0,
388  .size_ptr = NULL };
389 
390  *cred = NULL;
391  return ret;
392 }
void * cls
Closure for parser and cleaner.
The authorization ticket.
uint32_t GNUNET_RECLAIM_credential_typename_to_number(const char *typename)
Convert an credential type name to the corresponding number.
struct GNUNET_RECLAIM_Attribute * GNUNET_RECLAIM_attribute_new(const char *attr_name, const struct GNUNET_RECLAIM_Identifier *credential, uint32_t type, const void *data, size_t data_size)
Create a new attribute claim.
struct GNUNET_RECLAIM_Identifier id
ID.
int GNUNET_RECLAIM_credential_string_to_value(uint32_t type, const char *s, void **data, size_t *data_size)
Convert human-readable version of a &#39;claim&#39; of an credential to the binary representation.
functions to parse JSON objects into GNUnet objects
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
Entry in parser specification for GNUNET_JSON_parse().
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static void clean_attr(void *cls, struct GNUNET_JSON_Specification *spec)
Cleanup data left from parsing RSA public key.
Definition: json_reclaim.c:125
struct GNUNET_RECLAIM_Identifier credential
Referenced ID of credential (may be GNUNET_RECLAIM_ID_ZERO if self-creded)
struct GNUNET_JSON_Specification GNUNET_RECLAIM_JSON_spec_credential(struct GNUNET_RECLAIM_Credential **cred)
JSON Specification for credential claims.
Definition: json_reclaim.c:379
struct GNUNET_JSON_Specification GNUNET_RECLAIM_JSON_spec_attribute(struct GNUNET_RECLAIM_Attribute **attr)
JSON Specification for Reclaim claims.
Definition: json_reclaim.c:145
static void clean_credential(void *cls, struct GNUNET_JSON_Specification *spec)
Cleanup data left from parsing RSA public key.
Definition: json_reclaim.c:359
static struct GNUNET_RECLAIM_Ticket ticket
Ticket to consume.
struct GNUNET_IDENTITY_PublicKey identity
The ticket issuer (= the user)
static int parse_ticket(void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
Parse given JSON object to a ticket.
Definition: json_reclaim.c:169
uint32_t GNUNET_RECLAIM_attribute_typename_to_number(const char *typename)
Convert a type name to the corresponding number.
struct GNUNET_RECLAIM_Identifier id
ID.
static int parse_attr(void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
Parse given JSON object to a claim.
Definition: json_reclaim.c:42
GNUNET_JSON_Parser parser
Function for how to parse this type of entry.
int GNUNET_RECLAIM_attribute_string_to_value(uint32_t type, const char *s, void **data, size_t *data_size)
Convert human-readable version of a &#39;claim&#39; of an attribute to the binary representation.
static char * type_str
Attribute type.
void * ptr
Pointer, details specific to the parser.
static int parse_credential(void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
Parse given JSON object to a credential claim.
Definition: json_reclaim.c:290
struct GNUNET_RECLAIM_Identifier rnd
The ticket random identifier.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
struct GNUNET_IDENTITY_PublicKey audience
The ticket audience (= relying party)
#define GNUNET_log(kind,...)
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
struct GNUNET_RECLAIM_Credential * GNUNET_RECLAIM_credential_new(const char *name, uint32_t type, const void *data, size_t data_size)
Create a new credential.
uint32_t data
The data value.
static void clean_ticket(void *cls, struct GNUNET_JSON_Specification *spec)
Cleanup data left from parsing RSA public key.
Definition: json_reclaim.c:246
int GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert CrockfordBase32 encoding back to data.
Definition: strings.c:972
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_JSON_Specification GNUNET_RECLAIM_JSON_spec_ticket(struct GNUNET_RECLAIM_Ticket **ticket)
JSON Specification for Reclaim tickets.
Definition: json_reclaim.c:266