1 /*
2 * Copyright (c) 2009-2021, Google LLC
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 * * Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * * Neither the name of Google LLC nor the
13 * names of its contributors may be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 * DISCLAIMED. IN NO EVENT SHALL Google LLC BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include "upb/json_encode.h"
29
30 #include <ctype.h>
31 #include <float.h>
32 #include <inttypes.h>
33 #include <math.h>
34 #include <setjmp.h>
35 #include <stdarg.h>
36 #include <stdio.h>
37 #include <string.h>
38
39 #include "upb/decode.h"
40 #include "upb/reflection.h"
41
42 /* Must be last. */
43 #include "upb/port_def.inc"
44
45 typedef struct {
46 char *buf, *ptr, *end;
47 size_t overflow;
48 int indent_depth;
49 int options;
50 const upb_symtab *ext_pool;
51 jmp_buf err;
52 upb_status *status;
53 upb_arena *arena;
54 } jsonenc;
55
56 static void jsonenc_msg(jsonenc *e, const upb_msg *msg, const upb_msgdef *m);
57 static void jsonenc_scalar(jsonenc *e, upb_msgval val, const upb_fielddef *f);
58 static void jsonenc_msgfield(jsonenc *e, const upb_msg *msg,
59 const upb_msgdef *m);
60 static void jsonenc_msgfields(jsonenc *e, const upb_msg *msg,
61 const upb_msgdef *m, bool first);
62 static void jsonenc_value(jsonenc *e, const upb_msg *msg, const upb_msgdef *m);
63
jsonenc_err(jsonenc * e,const char * msg)64 UPB_NORETURN static void jsonenc_err(jsonenc *e, const char *msg) {
65 upb_status_seterrmsg(e->status, msg);
66 longjmp(e->err, 1);
67 }
68
69 UPB_PRINTF(2, 3)
jsonenc_errf(jsonenc * e,const char * fmt,...)70 UPB_NORETURN static void jsonenc_errf(jsonenc *e, const char *fmt, ...) {
71 va_list argp;
72 va_start(argp, fmt);
73 upb_status_vseterrf(e->status, fmt, argp);
74 va_end(argp);
75 longjmp(e->err, 1);
76 }
77
jsonenc_arena(jsonenc * e)78 static upb_arena *jsonenc_arena(jsonenc *e) {
79 /* Create lazily, since it's only needed for Any */
80 if (!e->arena) {
81 e->arena = upb_arena_new();
82 }
83 return e->arena;
84 }
85
jsonenc_putbytes(jsonenc * e,const void * data,size_t len)86 static void jsonenc_putbytes(jsonenc *e, const void *data, size_t len) {
87 size_t have = e->end - e->ptr;
88 if (UPB_LIKELY(have >= len)) {
89 memcpy(e->ptr, data, len);
90 e->ptr += len;
91 } else {
92 if (have) {
93 memcpy(e->ptr, data, have);
94 e->ptr += have;
95 }
96 e->overflow += (len - have);
97 }
98 }
99
jsonenc_putstr(jsonenc * e,const char * str)100 static void jsonenc_putstr(jsonenc *e, const char *str) {
101 jsonenc_putbytes(e, str, strlen(str));
102 }
103
104 UPB_PRINTF(2, 3)
jsonenc_printf(jsonenc * e,const char * fmt,...)105 static void jsonenc_printf(jsonenc *e, const char *fmt, ...) {
106 size_t n;
107 size_t have = e->end - e->ptr;
108 va_list args;
109
110 va_start(args, fmt);
111 n = vsnprintf(e->ptr, have, fmt, args);
112 va_end(args);
113
114 if (UPB_LIKELY(have > n)) {
115 e->ptr += n;
116 } else {
117 e->ptr = UPB_PTRADD(e->ptr, have);
118 e->overflow += (n - have);
119 }
120 }
121
jsonenc_nanos(jsonenc * e,int32_t nanos)122 static void jsonenc_nanos(jsonenc *e, int32_t nanos) {
123 int digits = 9;
124
125 if (nanos == 0) return;
126 if (nanos < 0 || nanos >= 1000000000) {
127 jsonenc_err(e, "error formatting timestamp as JSON: invalid nanos");
128 }
129
130 while (nanos % 1000 == 0) {
131 nanos /= 1000;
132 digits -= 3;
133 }
134
135 jsonenc_printf(e, ".%.*" PRId32, digits, nanos);
136 }
137
jsonenc_timestamp(jsonenc * e,const upb_msg * msg,const upb_msgdef * m)138 static void jsonenc_timestamp(jsonenc *e, const upb_msg *msg,
139 const upb_msgdef *m) {
140 const upb_fielddef *seconds_f = upb_msgdef_itof(m, 1);
141 const upb_fielddef *nanos_f = upb_msgdef_itof(m, 2);
142 int64_t seconds = upb_msg_get(msg, seconds_f).int64_val;
143 int32_t nanos = upb_msg_get(msg, nanos_f).int32_val;
144 int L, N, I, J, K, hour, min, sec;
145
146 if (seconds < -62135596800) {
147 jsonenc_err(e,
148 "error formatting timestamp as JSON: minimum acceptable value "
149 "is 0001-01-01T00:00:00Z");
150 } else if (seconds > 253402300799) {
151 jsonenc_err(e,
152 "error formatting timestamp as JSON: maximum acceptable value "
153 "is 9999-12-31T23:59:59Z");
154 }
155
156 /* Julian Day -> Y/M/D, Algorithm from:
157 * Fliegel, H. F., and Van Flandern, T. C., "A Machine Algorithm for
158 * Processing Calendar Dates," Communications of the Association of
159 * Computing Machines, vol. 11 (1968), p. 657. */
160 L = (int)(seconds / 86400) + 68569 + 2440588;
161 N = 4 * L / 146097;
162 L = L - (146097 * N + 3) / 4;
163 I = 4000 * (L + 1) / 1461001;
164 L = L - 1461 * I / 4 + 31;
165 J = 80 * L / 2447;
166 K = L - 2447 * J / 80;
167 L = J / 11;
168 J = J + 2 - 12 * L;
169 I = 100 * (N - 49) + I + L;
170
171 sec = seconds % 60;
172 min = (seconds / 60) % 60;
173 hour = (seconds / 3600) % 24;
174
175 jsonenc_printf(e, "\"%04d-%02d-%02dT%02d:%02d:%02d", I, J, K, hour, min, sec);
176 jsonenc_nanos(e, nanos);
177 jsonenc_putstr(e, "Z\"");
178 }
179
jsonenc_duration(jsonenc * e,const upb_msg * msg,const upb_msgdef * m)180 static void jsonenc_duration(jsonenc *e, const upb_msg *msg, const upb_msgdef *m) {
181 const upb_fielddef *seconds_f = upb_msgdef_itof(m, 1);
182 const upb_fielddef *nanos_f = upb_msgdef_itof(m, 2);
183 int64_t seconds = upb_msg_get(msg, seconds_f).int64_val;
184 int32_t nanos = upb_msg_get(msg, nanos_f).int32_val;
185
186 if (seconds > 315576000000 || seconds < -315576000000 ||
187 (seconds < 0) != (nanos < 0)) {
188 jsonenc_err(e, "bad duration");
189 }
190
191 if (nanos < 0) {
192 nanos = -nanos;
193 }
194
195 jsonenc_printf(e, "\"%" PRId64, seconds);
196 jsonenc_nanos(e, nanos);
197 jsonenc_putstr(e, "s\"");
198 }
199
jsonenc_enum(int32_t val,const upb_fielddef * f,jsonenc * e)200 static void jsonenc_enum(int32_t val, const upb_fielddef *f, jsonenc *e) {
201 const upb_enumdef *e_def = upb_fielddef_enumsubdef(f);
202
203 if (strcmp(upb_enumdef_fullname(e_def), "google.protobuf.NullValue") == 0) {
204 jsonenc_putstr(e, "null");
205 } else {
206 const char *name = upb_enumdef_iton(e_def, val);
207
208 if (name) {
209 jsonenc_printf(e, "\"%s\"", name);
210 } else {
211 jsonenc_printf(e, "%" PRId32, val);
212 }
213 }
214 }
215
jsonenc_bytes(jsonenc * e,upb_strview str)216 static void jsonenc_bytes(jsonenc *e, upb_strview str) {
217 /* This is the regular base64, not the "web-safe" version. */
218 static const char base64[] =
219 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
220 const unsigned char *ptr = (unsigned char*)str.data;
221 const unsigned char *end = UPB_PTRADD(ptr, str.size);
222 char buf[4];
223
224 jsonenc_putstr(e, "\"");
225
226 while (end - ptr >= 3) {
227 buf[0] = base64[ptr[0] >> 2];
228 buf[1] = base64[((ptr[0] & 0x3) << 4) | (ptr[1] >> 4)];
229 buf[2] = base64[((ptr[1] & 0xf) << 2) | (ptr[2] >> 6)];
230 buf[3] = base64[ptr[2] & 0x3f];
231 jsonenc_putbytes(e, buf, 4);
232 ptr += 3;
233 }
234
235 switch (end - ptr) {
236 case 2:
237 buf[0] = base64[ptr[0] >> 2];
238 buf[1] = base64[((ptr[0] & 0x3) << 4) | (ptr[1] >> 4)];
239 buf[2] = base64[(ptr[1] & 0xf) << 2];
240 buf[3] = '=';
241 jsonenc_putbytes(e, buf, 4);
242 break;
243 case 1:
244 buf[0] = base64[ptr[0] >> 2];
245 buf[1] = base64[((ptr[0] & 0x3) << 4)];
246 buf[2] = '=';
247 buf[3] = '=';
248 jsonenc_putbytes(e, buf, 4);
249 break;
250 }
251
252 jsonenc_putstr(e, "\"");
253 }
254
jsonenc_stringbody(jsonenc * e,upb_strview str)255 static void jsonenc_stringbody(jsonenc *e, upb_strview str) {
256 const char *ptr = str.data;
257 const char *end = UPB_PTRADD(ptr, str.size);
258
259 while (ptr < end) {
260 switch (*ptr) {
261 case '\n':
262 jsonenc_putstr(e, "\\n");
263 break;
264 case '\r':
265 jsonenc_putstr(e, "\\r");
266 break;
267 case '\t':
268 jsonenc_putstr(e, "\\t");
269 break;
270 case '\"':
271 jsonenc_putstr(e, "\\\"");
272 break;
273 case '\f':
274 jsonenc_putstr(e, "\\f");
275 break;
276 case '\b':
277 jsonenc_putstr(e, "\\b");
278 break;
279 case '\\':
280 jsonenc_putstr(e, "\\\\");
281 break;
282 default:
283 if ((uint8_t)*ptr < 0x20) {
284 jsonenc_printf(e, "\\u%04x", (int)(uint8_t)*ptr);
285 } else {
286 /* This could be a non-ASCII byte. We rely on the string being valid
287 * UTF-8. */
288 jsonenc_putbytes(e, ptr, 1);
289 }
290 break;
291 }
292 ptr++;
293 }
294 }
295
jsonenc_string(jsonenc * e,upb_strview str)296 static void jsonenc_string(jsonenc *e, upb_strview str) {
297 jsonenc_putstr(e, "\"");
298 jsonenc_stringbody(e, str);
299 jsonenc_putstr(e, "\"");
300 }
301
jsonenc_double(jsonenc * e,const char * fmt,double val)302 static void jsonenc_double(jsonenc *e, const char *fmt, double val) {
303 if (val == INFINITY) {
304 jsonenc_putstr(e, "\"Infinity\"");
305 } else if (val == -INFINITY) {
306 jsonenc_putstr(e, "\"-Infinity\"");
307 } else if (val != val) {
308 jsonenc_putstr(e, "\"NaN\"");
309 } else {
310 char *p = e->ptr;
311 jsonenc_printf(e, fmt, val);
312
313 /* printf() is dependent on locales; sadly there is no easy and portable way
314 * to avoid this. This little post-processing step will translate 1,2 -> 1.2
315 * since JSON needs the latter. Arguably a hack, but it is simple and the
316 * alternatives are far more complicated, platform-dependent, and/or larger
317 * in code size. */
318 for (char *end = e->ptr; p < end; p++) {
319 if (*p == ',') *p = '.';
320 }
321 }
322 }
323
jsonenc_wrapper(jsonenc * e,const upb_msg * msg,const upb_msgdef * m)324 static void jsonenc_wrapper(jsonenc *e, const upb_msg *msg,
325 const upb_msgdef *m) {
326 const upb_fielddef *val_f = upb_msgdef_itof(m, 1);
327 upb_msgval val = upb_msg_get(msg, val_f);
328 jsonenc_scalar(e, val, val_f);
329 }
330
jsonenc_getanymsg(jsonenc * e,upb_strview type_url)331 static const upb_msgdef *jsonenc_getanymsg(jsonenc *e, upb_strview type_url) {
332 /* Find last '/', if any. */
333 const char *end = type_url.data + type_url.size;
334 const char *ptr = end;
335 const upb_msgdef *ret;
336
337 if (!e->ext_pool) {
338 jsonenc_err(e, "Tried to encode Any, but no symtab was provided");
339 }
340
341 if (type_url.size == 0) goto badurl;
342
343 while (true) {
344 if (--ptr == type_url.data) {
345 /* Type URL must contain at least one '/', with host before. */
346 goto badurl;
347 }
348 if (*ptr == '/') {
349 ptr++;
350 break;
351 }
352 }
353
354 ret = upb_symtab_lookupmsg2(e->ext_pool, ptr, end - ptr);
355
356 if (!ret) {
357 jsonenc_errf(e, "Couldn't find Any type: %.*s", (int)(end - ptr), ptr);
358 }
359
360 return ret;
361
362 badurl:
363 jsonenc_errf(
364 e, "Bad type URL: " UPB_STRVIEW_FORMAT, UPB_STRVIEW_ARGS(type_url));
365 }
366
jsonenc_any(jsonenc * e,const upb_msg * msg,const upb_msgdef * m)367 static void jsonenc_any(jsonenc *e, const upb_msg *msg, const upb_msgdef *m) {
368 const upb_fielddef *type_url_f = upb_msgdef_itof(m, 1);
369 const upb_fielddef *value_f = upb_msgdef_itof(m, 2);
370 upb_strview type_url = upb_msg_get(msg, type_url_f).str_val;
371 upb_strview value = upb_msg_get(msg, value_f).str_val;
372 const upb_msgdef *any_m = jsonenc_getanymsg(e, type_url);
373 const upb_msglayout *any_layout = upb_msgdef_layout(any_m);
374 upb_arena *arena = jsonenc_arena(e);
375 upb_msg *any = upb_msg_new(any_m, arena);
376
377 if (!upb_decode(value.data, value.size, any, any_layout, arena)) {
378 jsonenc_err(e, "Error decoding message in Any");
379 }
380
381 jsonenc_putstr(e, "{\"@type\":");
382 jsonenc_string(e, type_url);
383
384 if (upb_msgdef_wellknowntype(any_m) == UPB_WELLKNOWN_UNSPECIFIED) {
385 /* Regular messages: {"@type": "...","foo": 1, "bar": 2} */
386 jsonenc_msgfields(e, any, any_m, false);
387 } else {
388 /* Well-known type: {"@type": "...","value": <well-known encoding>} */
389 jsonenc_putstr(e, ",\"value\":");
390 jsonenc_msgfield(e, any, any_m);
391 }
392
393 jsonenc_putstr(e, "}");
394 }
395
jsonenc_putsep(jsonenc * e,const char * str,bool * first)396 static void jsonenc_putsep(jsonenc *e, const char *str, bool *first) {
397 if (*first) {
398 *first = false;
399 } else {
400 jsonenc_putstr(e, str);
401 }
402 }
403
jsonenc_fieldpath(jsonenc * e,upb_strview path)404 static void jsonenc_fieldpath(jsonenc *e, upb_strview path) {
405 const char *ptr = path.data;
406 const char *end = ptr + path.size;
407
408 while (ptr < end) {
409 char ch = *ptr;
410
411 if (ch >= 'A' && ch <= 'Z') {
412 jsonenc_err(e, "Field mask element may not have upper-case letter.");
413 } else if (ch == '_') {
414 if (ptr == end - 1 || *(ptr + 1) < 'a' || *(ptr + 1) > 'z') {
415 jsonenc_err(e, "Underscore must be followed by a lowercase letter.");
416 }
417 ch = *++ptr - 32;
418 }
419
420 jsonenc_putbytes(e, &ch, 1);
421 ptr++;
422 }
423 }
424
jsonenc_fieldmask(jsonenc * e,const upb_msg * msg,const upb_msgdef * m)425 static void jsonenc_fieldmask(jsonenc *e, const upb_msg *msg,
426 const upb_msgdef *m) {
427 const upb_fielddef *paths_f = upb_msgdef_itof(m, 1);
428 const upb_array *paths = upb_msg_get(msg, paths_f).array_val;
429 bool first = true;
430 size_t i, n = 0;
431
432 if (paths) n = upb_array_size(paths);
433
434 jsonenc_putstr(e, "\"");
435
436 for (i = 0; i < n; i++) {
437 jsonenc_putsep(e, ",", &first);
438 jsonenc_fieldpath(e, upb_array_get(paths, i).str_val);
439 }
440
441 jsonenc_putstr(e, "\"");
442 }
443
jsonenc_struct(jsonenc * e,const upb_msg * msg,const upb_msgdef * m)444 static void jsonenc_struct(jsonenc *e, const upb_msg *msg,
445 const upb_msgdef *m) {
446 const upb_fielddef *fields_f = upb_msgdef_itof(m, 1);
447 const upb_map *fields = upb_msg_get(msg, fields_f).map_val;
448 const upb_msgdef *entry_m = upb_fielddef_msgsubdef(fields_f);
449 const upb_fielddef *value_f = upb_msgdef_itof(entry_m, 2);
450 size_t iter = UPB_MAP_BEGIN;
451 bool first = true;
452
453 jsonenc_putstr(e, "{");
454
455 if (fields) {
456 while (upb_mapiter_next(fields, &iter)) {
457 upb_msgval key = upb_mapiter_key(fields, iter);
458 upb_msgval val = upb_mapiter_value(fields, iter);
459
460 jsonenc_putsep(e, ",", &first);
461 jsonenc_string(e, key.str_val);
462 jsonenc_putstr(e, ":");
463 jsonenc_value(e, val.msg_val, upb_fielddef_msgsubdef(value_f));
464 }
465 }
466
467 jsonenc_putstr(e, "}");
468 }
469
jsonenc_listvalue(jsonenc * e,const upb_msg * msg,const upb_msgdef * m)470 static void jsonenc_listvalue(jsonenc *e, const upb_msg *msg,
471 const upb_msgdef *m) {
472 const upb_fielddef *values_f = upb_msgdef_itof(m, 1);
473 const upb_msgdef *values_m = upb_fielddef_msgsubdef(values_f);
474 const upb_array *values = upb_msg_get(msg, values_f).array_val;
475 size_t i;
476 bool first = true;
477
478 jsonenc_putstr(e, "[");
479
480 if (values) {
481 const size_t size = upb_array_size(values);
482 for (i = 0; i < size; i++) {
483 upb_msgval elem = upb_array_get(values, i);
484
485 jsonenc_putsep(e, ",", &first);
486 jsonenc_value(e, elem.msg_val, values_m);
487 }
488 }
489
490 jsonenc_putstr(e, "]");
491 }
492
jsonenc_value(jsonenc * e,const upb_msg * msg,const upb_msgdef * m)493 static void jsonenc_value(jsonenc *e, const upb_msg *msg, const upb_msgdef *m) {
494 /* TODO(haberman): do we want a reflection method to get oneof case? */
495 size_t iter = UPB_MSG_BEGIN;
496 const upb_fielddef *f;
497 upb_msgval val;
498
499 if (!upb_msg_next(msg, m, NULL, &f, &val, &iter)) {
500 jsonenc_err(e, "No value set in Value proto");
501 }
502
503 switch (upb_fielddef_number(f)) {
504 case 1:
505 jsonenc_putstr(e, "null");
506 break;
507 case 2:
508 jsonenc_double(e, "%.17g", val.double_val);
509 break;
510 case 3:
511 jsonenc_string(e, val.str_val);
512 break;
513 case 4:
514 jsonenc_putstr(e, val.bool_val ? "true" : "false");
515 break;
516 case 5:
517 jsonenc_struct(e, val.msg_val, upb_fielddef_msgsubdef(f));
518 break;
519 case 6:
520 jsonenc_listvalue(e, val.msg_val, upb_fielddef_msgsubdef(f));
521 break;
522 }
523 }
524
jsonenc_msgfield(jsonenc * e,const upb_msg * msg,const upb_msgdef * m)525 static void jsonenc_msgfield(jsonenc *e, const upb_msg *msg,
526 const upb_msgdef *m) {
527 switch (upb_msgdef_wellknowntype(m)) {
528 case UPB_WELLKNOWN_UNSPECIFIED:
529 jsonenc_msg(e, msg, m);
530 break;
531 case UPB_WELLKNOWN_ANY:
532 jsonenc_any(e, msg, m);
533 break;
534 case UPB_WELLKNOWN_FIELDMASK:
535 jsonenc_fieldmask(e, msg, m);
536 break;
537 case UPB_WELLKNOWN_DURATION:
538 jsonenc_duration(e, msg, m);
539 break;
540 case UPB_WELLKNOWN_TIMESTAMP:
541 jsonenc_timestamp(e, msg, m);
542 break;
543 case UPB_WELLKNOWN_DOUBLEVALUE:
544 case UPB_WELLKNOWN_FLOATVALUE:
545 case UPB_WELLKNOWN_INT64VALUE:
546 case UPB_WELLKNOWN_UINT64VALUE:
547 case UPB_WELLKNOWN_INT32VALUE:
548 case UPB_WELLKNOWN_UINT32VALUE:
549 case UPB_WELLKNOWN_STRINGVALUE:
550 case UPB_WELLKNOWN_BYTESVALUE:
551 case UPB_WELLKNOWN_BOOLVALUE:
552 jsonenc_wrapper(e, msg, m);
553 break;
554 case UPB_WELLKNOWN_VALUE:
555 jsonenc_value(e, msg, m);
556 break;
557 case UPB_WELLKNOWN_LISTVALUE:
558 jsonenc_listvalue(e, msg, m);
559 break;
560 case UPB_WELLKNOWN_STRUCT:
561 jsonenc_struct(e, msg, m);
562 break;
563 }
564 }
565
jsonenc_scalar(jsonenc * e,upb_msgval val,const upb_fielddef * f)566 static void jsonenc_scalar(jsonenc *e, upb_msgval val, const upb_fielddef *f) {
567 switch (upb_fielddef_type(f)) {
568 case UPB_TYPE_BOOL:
569 jsonenc_putstr(e, val.bool_val ? "true" : "false");
570 break;
571 case UPB_TYPE_FLOAT:
572 jsonenc_double(e, "%.9g", val.float_val);
573 break;
574 case UPB_TYPE_DOUBLE:
575 jsonenc_double(e, "%.17g", val.double_val);
576 break;
577 case UPB_TYPE_INT32:
578 jsonenc_printf(e, "%" PRId32, val.int32_val);
579 break;
580 case UPB_TYPE_UINT32:
581 jsonenc_printf(e, "%" PRIu32, val.uint32_val);
582 break;
583 case UPB_TYPE_INT64:
584 jsonenc_printf(e, "\"%" PRId64 "\"", val.int64_val);
585 break;
586 case UPB_TYPE_UINT64:
587 jsonenc_printf(e, "\"%" PRIu64 "\"", val.uint64_val);
588 break;
589 case UPB_TYPE_STRING:
590 jsonenc_string(e, val.str_val);
591 break;
592 case UPB_TYPE_BYTES:
593 jsonenc_bytes(e, val.str_val);
594 break;
595 case UPB_TYPE_ENUM:
596 jsonenc_enum(val.int32_val, f, e);
597 break;
598 case UPB_TYPE_MESSAGE:
599 jsonenc_msgfield(e, val.msg_val, upb_fielddef_msgsubdef(f));
600 break;
601 }
602 }
603
jsonenc_mapkey(jsonenc * e,upb_msgval val,const upb_fielddef * f)604 static void jsonenc_mapkey(jsonenc *e, upb_msgval val, const upb_fielddef *f) {
605 jsonenc_putstr(e, "\"");
606
607 switch (upb_fielddef_type(f)) {
608 case UPB_TYPE_BOOL:
609 jsonenc_putstr(e, val.bool_val ? "true" : "false");
610 break;
611 case UPB_TYPE_INT32:
612 jsonenc_printf(e, "%" PRId32, val.int32_val);
613 break;
614 case UPB_TYPE_UINT32:
615 jsonenc_printf(e, "%" PRIu32, val.uint32_val);
616 break;
617 case UPB_TYPE_INT64:
618 jsonenc_printf(e, "%" PRId64, val.int64_val);
619 break;
620 case UPB_TYPE_UINT64:
621 jsonenc_printf(e, "%" PRIu64, val.uint64_val);
622 break;
623 case UPB_TYPE_STRING:
624 jsonenc_stringbody(e, val.str_val);
625 break;
626 default:
627 UPB_UNREACHABLE();
628 }
629
630 jsonenc_putstr(e, "\":");
631 }
632
jsonenc_array(jsonenc * e,const upb_array * arr,const upb_fielddef * f)633 static void jsonenc_array(jsonenc *e, const upb_array *arr,
634 const upb_fielddef *f) {
635 size_t i;
636 size_t size = arr ? upb_array_size(arr) : 0;
637 bool first = true;
638
639 jsonenc_putstr(e, "[");
640
641 for (i = 0; i < size; i++) {
642 jsonenc_putsep(e, ",", &first);
643 jsonenc_scalar(e, upb_array_get(arr, i), f);
644 }
645
646 jsonenc_putstr(e, "]");
647 }
648
jsonenc_map(jsonenc * e,const upb_map * map,const upb_fielddef * f)649 static void jsonenc_map(jsonenc *e, const upb_map *map, const upb_fielddef *f) {
650 const upb_msgdef *entry = upb_fielddef_msgsubdef(f);
651 const upb_fielddef *key_f = upb_msgdef_itof(entry, 1);
652 const upb_fielddef *val_f = upb_msgdef_itof(entry, 2);
653 size_t iter = UPB_MAP_BEGIN;
654 bool first = true;
655
656 jsonenc_putstr(e, "{");
657
658 if (map) {
659 while (upb_mapiter_next(map, &iter)) {
660 jsonenc_putsep(e, ",", &first);
661 jsonenc_mapkey(e, upb_mapiter_key(map, iter), key_f);
662 jsonenc_scalar(e, upb_mapiter_value(map, iter), val_f);
663 }
664 }
665
666 jsonenc_putstr(e, "}");
667 }
668
jsonenc_fieldval(jsonenc * e,const upb_fielddef * f,upb_msgval val,bool * first)669 static void jsonenc_fieldval(jsonenc *e, const upb_fielddef *f,
670 upb_msgval val, bool *first) {
671 const char *name;
672
673 if (e->options & UPB_JSONENC_PROTONAMES) {
674 name = upb_fielddef_name(f);
675 } else {
676 name = upb_fielddef_jsonname(f);
677 }
678
679 jsonenc_putsep(e, ",", first);
680 jsonenc_printf(e, "\"%s\":", name);
681
682 if (upb_fielddef_ismap(f)) {
683 jsonenc_map(e, val.map_val, f);
684 } else if (upb_fielddef_isseq(f)) {
685 jsonenc_array(e, val.array_val, f);
686 } else {
687 jsonenc_scalar(e, val, f);
688 }
689 }
690
jsonenc_msgfields(jsonenc * e,const upb_msg * msg,const upb_msgdef * m,bool first)691 static void jsonenc_msgfields(jsonenc *e, const upb_msg *msg,
692 const upb_msgdef *m, bool first) {
693 upb_msgval val;
694 const upb_fielddef *f;
695
696 if (e->options & UPB_JSONENC_EMITDEFAULTS) {
697 /* Iterate over all fields. */
698 int i = 0;
699 int n = upb_msgdef_fieldcount(m);
700 for (i = 0; i < n; i++) {
701 f = upb_msgdef_field(m, i);
702 if (!upb_fielddef_haspresence(f) || upb_msg_has(msg, f)) {
703 jsonenc_fieldval(e, f, upb_msg_get(msg, f), &first);
704 }
705 }
706 } else {
707 /* Iterate over non-empty fields. */
708 size_t iter = UPB_MSG_BEGIN;
709 while (upb_msg_next(msg, m, e->ext_pool, &f, &val, &iter)) {
710 jsonenc_fieldval(e, f, val, &first);
711 }
712 }
713 }
714
jsonenc_msg(jsonenc * e,const upb_msg * msg,const upb_msgdef * m)715 static void jsonenc_msg(jsonenc *e, const upb_msg *msg, const upb_msgdef *m) {
716 jsonenc_putstr(e, "{");
717 jsonenc_msgfields(e, msg, m, true);
718 jsonenc_putstr(e, "}");
719 }
720
jsonenc_nullz(jsonenc * e,size_t size)721 static size_t jsonenc_nullz(jsonenc *e, size_t size) {
722 size_t ret = e->ptr - e->buf + e->overflow;
723
724 if (size > 0) {
725 if (e->ptr == e->end) e->ptr--;
726 *e->ptr = '\0';
727 }
728
729 return ret;
730 }
731
upb_json_encode(const upb_msg * msg,const upb_msgdef * m,const upb_symtab * ext_pool,int options,char * buf,size_t size,upb_status * status)732 size_t upb_json_encode(const upb_msg *msg, const upb_msgdef *m,
733 const upb_symtab *ext_pool, int options, char *buf,
734 size_t size, upb_status *status) {
735 jsonenc e;
736
737 e.buf = buf;
738 e.ptr = buf;
739 e.end = UPB_PTRADD(buf, size);
740 e.overflow = 0;
741 e.options = options;
742 e.ext_pool = ext_pool;
743 e.status = status;
744 e.arena = NULL;
745
746 if (setjmp(e.err)) return -1;
747
748 jsonenc_msgfield(&e, msg, m);
749 if (e.arena) upb_arena_free(e.arena);
750 return jsonenc_nullz(&e, size);
751 }
752