| // Protocol Buffers - Google's data interchange format |
| // Copyright 2023 Google LLC. All rights reserved. |
| // |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file or at |
| // https://developers.google.com/open-source/licenses/bsd |
| |
| #include "upb/json/decode.h" |
| |
| #include <errno.h> |
| #include <float.h> |
| #include <inttypes.h> |
| #include <limits.h> |
| #include <math.h> |
| #include <setjmp.h> |
| #include <stdarg.h> |
| #include <stddef.h> |
| #include <stdint.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "upb/base/descriptor_constants.h" |
| #include "upb/base/status.h" |
| #include "upb/base/string_view.h" |
| #include "upb/lex/atoi.h" |
| #include "upb/lex/unicode.h" |
| #include "upb/mem/arena.h" |
| #include "upb/message/array.h" |
| #include "upb/message/map.h" |
| #include "upb/message/message.h" |
| #include "upb/mini_table/message.h" |
| #include "upb/reflection/def.h" |
| #include "upb/reflection/message.h" |
| #include "upb/wire/encode.h" |
| |
| // Must be last. |
| #include "upb/port/def.inc" |
| |
| typedef struct { |
| const char *ptr, *end; |
| upb_Arena* arena; /* TODO: should we have a tmp arena for tmp data? */ |
| const upb_DefPool* symtab; |
| int depth; |
| upb_Status* status; |
| jmp_buf err; |
| int line; |
| const char* line_begin; |
| bool is_first; |
| int options; |
| const upb_FieldDef* debug_field; |
| } jsondec; |
| |
| typedef struct { |
| upb_MessageValue value; |
| bool ignore; |
| } upb_JsonMessageValue; |
| |
| enum { JD_OBJECT, JD_ARRAY, JD_STRING, JD_NUMBER, JD_TRUE, JD_FALSE, JD_NULL }; |
| |
| /* Forward declarations of mutually-recursive functions. */ |
| static void jsondec_wellknown(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m); |
| static upb_JsonMessageValue jsondec_value(jsondec* d, const upb_FieldDef* f); |
| static void jsondec_wellknownvalue(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m); |
| static void jsondec_object(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m); |
| |
| static bool jsondec_streql(upb_StringView str, const char* lit) { |
| return str.size == strlen(lit) && memcmp(str.data, lit, str.size) == 0; |
| } |
| |
| static bool jsondec_isnullvalue(const upb_FieldDef* f) { |
| return upb_FieldDef_CType(f) == kUpb_CType_Enum && |
| strcmp(upb_EnumDef_FullName(upb_FieldDef_EnumSubDef(f)), |
| "google.protobuf.NullValue") == 0; |
| } |
| |
| static bool jsondec_isvalue(const upb_FieldDef* f) { |
| return (upb_FieldDef_CType(f) == kUpb_CType_Message && |
| upb_MessageDef_WellKnownType(upb_FieldDef_MessageSubDef(f)) == |
| kUpb_WellKnown_Value) || |
| jsondec_isnullvalue(f); |
| } |
| |
| static void jsondec_seterrmsg(jsondec* d, const char* msg) { |
| upb_Status_SetErrorFormat(d->status, "Error parsing JSON @%d:%d: %s", d->line, |
| (int)(d->ptr - d->line_begin), msg); |
| } |
| |
| UPB_NORETURN static void jsondec_err(jsondec* d, const char* msg) { |
| jsondec_seterrmsg(d, msg); |
| UPB_LONGJMP(d->err, 1); |
| } |
| |
| UPB_PRINTF(2, 3) |
| UPB_NORETURN static void jsondec_errf(jsondec* d, const char* fmt, ...) { |
| va_list argp; |
| upb_Status_SetErrorFormat(d->status, "Error parsing JSON @%d:%d: ", d->line, |
| (int)(d->ptr - d->line_begin)); |
| va_start(argp, fmt); |
| upb_Status_VAppendErrorFormat(d->status, fmt, argp); |
| va_end(argp); |
| UPB_LONGJMP(d->err, 1); |
| } |
| |
| // Advances d->ptr until the next non-whitespace character or to the end of |
| // the buffer. |
| static void jsondec_consumews(jsondec* d) { |
| while (d->ptr != d->end) { |
| switch (*d->ptr) { |
| case '\n': |
| d->line++; |
| d->line_begin = d->ptr; |
| /* Fallthrough. */ |
| case '\r': |
| case '\t': |
| case ' ': |
| d->ptr++; |
| break; |
| default: |
| return; |
| } |
| } |
| } |
| |
| // Advances d->ptr until the next non-whitespace character. Postcondition that |
| // d->ptr is pointing at a valid non-whitespace character (will err if end of |
| // buffer is reached). |
| static void jsondec_skipws(jsondec* d) { |
| jsondec_consumews(d); |
| if (d->ptr == d->end) { |
| jsondec_err(d, "Unexpected EOF"); |
| } |
| } |
| |
| static bool jsondec_tryparsech(jsondec* d, char ch) { |
| if (d->ptr == d->end || *d->ptr != ch) return false; |
| d->ptr++; |
| return true; |
| } |
| |
| static void jsondec_parselit(jsondec* d, const char* lit) { |
| size_t avail = d->end - d->ptr; |
| size_t len = strlen(lit); |
| if (avail < len || memcmp(d->ptr, lit, len) != 0) { |
| jsondec_errf(d, "Expected: '%s'", lit); |
| } |
| d->ptr += len; |
| } |
| |
| static void jsondec_wsch(jsondec* d, char ch) { |
| jsondec_skipws(d); |
| if (!jsondec_tryparsech(d, ch)) { |
| jsondec_errf(d, "Expected: '%c'", ch); |
| } |
| } |
| |
| static void jsondec_true(jsondec* d) { jsondec_parselit(d, "true"); } |
| static void jsondec_false(jsondec* d) { jsondec_parselit(d, "false"); } |
| static void jsondec_null(jsondec* d) { jsondec_parselit(d, "null"); } |
| |
| static void jsondec_entrysep(jsondec* d) { |
| jsondec_skipws(d); |
| jsondec_parselit(d, ":"); |
| } |
| |
| static int jsondec_rawpeek(jsondec* d) { |
| if (d->ptr == d->end) { |
| jsondec_err(d, "Unexpected EOF"); |
| } |
| |
| switch (*d->ptr) { |
| case '{': |
| return JD_OBJECT; |
| case '[': |
| return JD_ARRAY; |
| case '"': |
| return JD_STRING; |
| case '-': |
| case '0': |
| case '1': |
| case '2': |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '7': |
| case '8': |
| case '9': |
| return JD_NUMBER; |
| case 't': |
| return JD_TRUE; |
| case 'f': |
| return JD_FALSE; |
| case 'n': |
| return JD_NULL; |
| default: |
| jsondec_errf(d, "Unexpected character: '%c'", *d->ptr); |
| } |
| } |
| |
| /* JSON object/array **********************************************************/ |
| |
| /* These are used like so: |
| * |
| * jsondec_objstart(d); |
| * while (jsondec_objnext(d)) { |
| * ... |
| * } |
| * jsondec_objend(d) */ |
| |
| static int jsondec_peek(jsondec* d) { |
| jsondec_skipws(d); |
| return jsondec_rawpeek(d); |
| } |
| |
| static void jsondec_push(jsondec* d) { |
| if (--d->depth < 0) { |
| jsondec_err(d, "Recursion limit exceeded"); |
| } |
| d->is_first = true; |
| } |
| |
| static bool jsondec_seqnext(jsondec* d, char end_ch) { |
| bool is_first = d->is_first; |
| d->is_first = false; |
| jsondec_skipws(d); |
| if (*d->ptr == end_ch) return false; |
| if (!is_first) jsondec_parselit(d, ","); |
| return true; |
| } |
| |
| static void jsondec_arrstart(jsondec* d) { |
| jsondec_push(d); |
| jsondec_wsch(d, '['); |
| } |
| |
| static void jsondec_arrend(jsondec* d) { |
| d->depth++; |
| jsondec_wsch(d, ']'); |
| } |
| |
| static bool jsondec_arrnext(jsondec* d) { return jsondec_seqnext(d, ']'); } |
| |
| static void jsondec_objstart(jsondec* d) { |
| jsondec_push(d); |
| jsondec_wsch(d, '{'); |
| } |
| |
| static void jsondec_objend(jsondec* d) { |
| d->depth++; |
| jsondec_wsch(d, '}'); |
| } |
| |
| static bool jsondec_objnext(jsondec* d) { |
| if (!jsondec_seqnext(d, '}')) return false; |
| if (jsondec_peek(d) != JD_STRING) { |
| jsondec_err(d, "Object must start with string"); |
| } |
| return true; |
| } |
| |
| /* JSON number ****************************************************************/ |
| |
| static bool jsondec_tryskipdigits(jsondec* d) { |
| const char* start = d->ptr; |
| |
| while (d->ptr < d->end) { |
| if (*d->ptr < '0' || *d->ptr > '9') { |
| break; |
| } |
| d->ptr++; |
| } |
| |
| return d->ptr != start; |
| } |
| |
| static void jsondec_skipdigits(jsondec* d) { |
| if (!jsondec_tryskipdigits(d)) { |
| jsondec_err(d, "Expected one or more digits"); |
| } |
| } |
| |
| static double jsondec_number(jsondec* d) { |
| const char* start = d->ptr; |
| |
| UPB_ASSERT(jsondec_rawpeek(d) == JD_NUMBER); |
| |
| /* Skip over the syntax of a number, as specified by JSON. */ |
| if (*d->ptr == '-') d->ptr++; |
| |
| if (jsondec_tryparsech(d, '0')) { |
| if (jsondec_tryskipdigits(d)) { |
| jsondec_err(d, "number cannot have leading zero"); |
| } |
| } else { |
| jsondec_skipdigits(d); |
| } |
| |
| if (d->ptr == d->end) goto parse; |
| if (jsondec_tryparsech(d, '.')) { |
| jsondec_skipdigits(d); |
| } |
| if (d->ptr == d->end) goto parse; |
| |
| if (*d->ptr == 'e' || *d->ptr == 'E') { |
| d->ptr++; |
| if (d->ptr == d->end) { |
| jsondec_err(d, "Unexpected EOF in number"); |
| } |
| if (*d->ptr == '+' || *d->ptr == '-') { |
| d->ptr++; |
| } |
| jsondec_skipdigits(d); |
| } |
| |
| parse: |
| /* Having verified the syntax of a JSON number, use strtod() to parse |
| * (strtod() accepts a superset of JSON syntax). */ |
| errno = 0; |
| { |
| // Copy the number into a null-terminated scratch buffer since strtod |
| // expects a null-terminated string. |
| char nullz[64]; |
| ptrdiff_t len = d->ptr - start; |
| if (len > (ptrdiff_t)(sizeof(nullz) - 1)) { |
| jsondec_err(d, "excessively long number"); |
| } |
| memcpy(nullz, start, len); |
| nullz[len] = '\0'; |
| |
| char* end; |
| double val = strtod(nullz, &end); |
| UPB_ASSERT(end - nullz == len); |
| |
| /* Currently the min/max-val conformance tests fail if we check this. Does |
| * this mean the conformance tests are wrong or strtod() is wrong, or |
| * something else? Investigate further. */ |
| /* |
| if (errno == ERANGE) { |
| jsondec_err(d, "Number out of range"); |
| } |
| */ |
| |
| if (val > DBL_MAX || val < -DBL_MAX) { |
| jsondec_err(d, "Number out of range"); |
| } |
| |
| return val; |
| } |
| } |
| |
| /* JSON string ****************************************************************/ |
| |
| static char jsondec_escape(jsondec* d) { |
| switch (*d->ptr++) { |
| case '"': |
| return '\"'; |
| case '\\': |
| return '\\'; |
| case '/': |
| return '/'; |
| case 'b': |
| return '\b'; |
| case 'f': |
| return '\f'; |
| case 'n': |
| return '\n'; |
| case 'r': |
| return '\r'; |
| case 't': |
| return '\t'; |
| default: |
| jsondec_err(d, "Invalid escape char"); |
| } |
| } |
| |
| static uint32_t jsondec_codepoint(jsondec* d) { |
| uint32_t cp = 0; |
| const char* end; |
| |
| if (d->end - d->ptr < 4) { |
| jsondec_err(d, "EOF inside string"); |
| } |
| |
| end = d->ptr + 4; |
| while (d->ptr < end) { |
| char ch = *d->ptr++; |
| if (ch >= '0' && ch <= '9') { |
| ch -= '0'; |
| } else if (ch >= 'a' && ch <= 'f') { |
| ch = ch - 'a' + 10; |
| } else if (ch >= 'A' && ch <= 'F') { |
| ch = ch - 'A' + 10; |
| } else { |
| jsondec_err(d, "Invalid hex digit"); |
| } |
| cp = (cp << 4) | ch; |
| } |
| |
| return cp; |
| } |
| |
| /* Parses a \uXXXX unicode escape (possibly a surrogate pair). */ |
| static size_t jsondec_unicode(jsondec* d, char* out) { |
| uint32_t cp = jsondec_codepoint(d); |
| if (upb_Unicode_IsHigh(cp)) { |
| /* Surrogate pair: two 16-bit codepoints become a 32-bit codepoint. */ |
| jsondec_parselit(d, "\\u"); |
| uint32_t low = jsondec_codepoint(d); |
| if (!upb_Unicode_IsLow(low)) jsondec_err(d, "Invalid low surrogate"); |
| cp = upb_Unicode_FromPair(cp, low); |
| } else if (upb_Unicode_IsLow(cp)) { |
| jsondec_err(d, "Unpaired low surrogate"); |
| } |
| |
| /* Write to UTF-8 */ |
| int bytes = upb_Unicode_ToUTF8(cp, out); |
| if (bytes == 0) jsondec_err(d, "Invalid codepoint"); |
| return bytes; |
| } |
| |
| static void jsondec_resize(jsondec* d, char** buf, char** end, char** buf_end) { |
| size_t oldsize = *buf_end - *buf; |
| size_t len = *end - *buf; |
| size_t size = UPB_MAX(8, 2 * oldsize); |
| |
| *buf = upb_Arena_Realloc(d->arena, *buf, len, size); |
| if (!*buf) jsondec_err(d, "Out of memory"); |
| |
| *end = *buf + len; |
| *buf_end = *buf + size; |
| } |
| |
| static upb_StringView jsondec_string(jsondec* d) { |
| char* buf = NULL; |
| char* end = NULL; |
| char* buf_end = NULL; |
| |
| jsondec_skipws(d); |
| |
| if (*d->ptr++ != '"') { |
| jsondec_err(d, "Expected string"); |
| } |
| |
| while (d->ptr < d->end) { |
| char ch = *d->ptr++; |
| |
| if (end == buf_end) { |
| jsondec_resize(d, &buf, &end, &buf_end); |
| } |
| |
| switch (ch) { |
| case '"': { |
| upb_StringView ret; |
| ret.data = buf; |
| ret.size = end - buf; |
| *end = '\0'; /* Needed for possible strtod(). */ |
| return ret; |
| } |
| case '\\': |
| if (d->ptr == d->end) goto eof; |
| if (*d->ptr == 'u') { |
| d->ptr++; |
| if (buf_end - end < 4) { |
| /* Allow space for maximum-sized codepoint (4 bytes). */ |
| jsondec_resize(d, &buf, &end, &buf_end); |
| } |
| end += jsondec_unicode(d, end); |
| } else { |
| *end++ = jsondec_escape(d); |
| } |
| break; |
| default: |
| if ((unsigned char)ch < 0x20) { |
| jsondec_err(d, "Invalid char in JSON string"); |
| } |
| *end++ = ch; |
| break; |
| } |
| } |
| |
| eof: |
| jsondec_err(d, "EOF inside string"); |
| } |
| |
| static void jsondec_skipval(jsondec* d) { |
| switch (jsondec_peek(d)) { |
| case JD_OBJECT: |
| jsondec_objstart(d); |
| while (jsondec_objnext(d)) { |
| jsondec_string(d); |
| jsondec_entrysep(d); |
| jsondec_skipval(d); |
| } |
| jsondec_objend(d); |
| break; |
| case JD_ARRAY: |
| jsondec_arrstart(d); |
| while (jsondec_arrnext(d)) { |
| jsondec_skipval(d); |
| } |
| jsondec_arrend(d); |
| break; |
| case JD_TRUE: |
| jsondec_true(d); |
| break; |
| case JD_FALSE: |
| jsondec_false(d); |
| break; |
| case JD_NULL: |
| jsondec_null(d); |
| break; |
| case JD_STRING: |
| jsondec_string(d); |
| break; |
| case JD_NUMBER: |
| jsondec_number(d); |
| break; |
| } |
| } |
| |
| /* Base64 decoding for bytes fields. ******************************************/ |
| |
| static unsigned int jsondec_base64_tablelookup(const char ch) { |
| /* Table includes the normal base64 chars plus the URL-safe variant. */ |
| const signed char table[256] = { |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, 62 /*+*/, -1, 62 /*-*/, -1, 63 /*/ */, 52 /*0*/, |
| 53 /*1*/, 54 /*2*/, 55 /*3*/, 56 /*4*/, 57 /*5*/, 58 /*6*/, 59 /*7*/, |
| 60 /*8*/, 61 /*9*/, -1, -1, -1, -1, -1, |
| -1, -1, 0 /*A*/, 1 /*B*/, 2 /*C*/, 3 /*D*/, 4 /*E*/, |
| 5 /*F*/, 6 /*G*/, 07 /*H*/, 8 /*I*/, 9 /*J*/, 10 /*K*/, 11 /*L*/, |
| 12 /*M*/, 13 /*N*/, 14 /*O*/, 15 /*P*/, 16 /*Q*/, 17 /*R*/, 18 /*S*/, |
| 19 /*T*/, 20 /*U*/, 21 /*V*/, 22 /*W*/, 23 /*X*/, 24 /*Y*/, 25 /*Z*/, |
| -1, -1, -1, -1, 63 /*_*/, -1, 26 /*a*/, |
| 27 /*b*/, 28 /*c*/, 29 /*d*/, 30 /*e*/, 31 /*f*/, 32 /*g*/, 33 /*h*/, |
| 34 /*i*/, 35 /*j*/, 36 /*k*/, 37 /*l*/, 38 /*m*/, 39 /*n*/, 40 /*o*/, |
| 41 /*p*/, 42 /*q*/, 43 /*r*/, 44 /*s*/, 45 /*t*/, 46 /*u*/, 47 /*v*/, |
| 48 /*w*/, 49 /*x*/, 50 /*y*/, 51 /*z*/, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1}; |
| |
| /* Sign-extend return value so high bit will be set on any unexpected char. */ |
| return table[(unsigned)ch]; |
| } |
| |
| static char* jsondec_partialbase64(jsondec* d, const char* ptr, const char* end, |
| char* out) { |
| int32_t val = -1; |
| |
| switch (end - ptr) { |
| case 2: |
| val = jsondec_base64_tablelookup(ptr[0]) << 18 | |
| jsondec_base64_tablelookup(ptr[1]) << 12; |
| out[0] = val >> 16; |
| out += 1; |
| break; |
| case 3: |
| val = jsondec_base64_tablelookup(ptr[0]) << 18 | |
| jsondec_base64_tablelookup(ptr[1]) << 12 | |
| jsondec_base64_tablelookup(ptr[2]) << 6; |
| out[0] = val >> 16; |
| out[1] = (val >> 8) & 0xff; |
| out += 2; |
| break; |
| } |
| |
| if (val < 0) { |
| jsondec_err(d, "Corrupt base64"); |
| } |
| |
| return out; |
| } |
| |
| static size_t jsondec_base64(jsondec* d, upb_StringView str) { |
| /* We decode in place. This is safe because this is a new buffer (not |
| * aliasing the input) and because base64 decoding shrinks 4 bytes into 3. */ |
| char* out = (char*)str.data; |
| const char* ptr = str.data; |
| const char* end = ptr + str.size; |
| const char* end4 = ptr + (str.size & -4); /* Round down to multiple of 4. */ |
| |
| for (; ptr < end4; ptr += 4, out += 3) { |
| int val = jsondec_base64_tablelookup(ptr[0]) << 18 | |
| jsondec_base64_tablelookup(ptr[1]) << 12 | |
| jsondec_base64_tablelookup(ptr[2]) << 6 | |
| jsondec_base64_tablelookup(ptr[3]) << 0; |
| |
| if (val < 0) { |
| /* Junk chars or padding. Remove trailing padding, if any. */ |
| if (end - ptr == 4 && ptr[3] == '=') { |
| if (ptr[2] == '=') { |
| end -= 2; |
| } else { |
| end -= 1; |
| } |
| } |
| break; |
| } |
| |
| out[0] = val >> 16; |
| out[1] = (val >> 8) & 0xff; |
| out[2] = val & 0xff; |
| } |
| |
| if (ptr < end) { |
| /* Process remaining chars. We do not require padding. */ |
| out = jsondec_partialbase64(d, ptr, end, out); |
| } |
| |
| return out - str.data; |
| } |
| |
| /* Low-level integer parsing **************************************************/ |
| |
| static const char* jsondec_buftouint64(jsondec* d, const char* ptr, |
| const char* end, uint64_t* val) { |
| const char* out = upb_BufToUint64(ptr, end, val); |
| if (!out) jsondec_err(d, "Integer overflow"); |
| return out; |
| } |
| |
| static const char* jsondec_buftoint64(jsondec* d, const char* ptr, |
| const char* end, int64_t* val, |
| bool* is_neg) { |
| const char* out = upb_BufToInt64(ptr, end, val, is_neg); |
| if (!out) jsondec_err(d, "Integer overflow"); |
| return out; |
| } |
| |
| static uint64_t jsondec_strtouint64(jsondec* d, upb_StringView str) { |
| const char* end = str.data + str.size; |
| uint64_t ret; |
| if (jsondec_buftouint64(d, str.data, end, &ret) != end) { |
| jsondec_err(d, "Non-number characters in quoted integer"); |
| } |
| return ret; |
| } |
| |
| static int64_t jsondec_strtoint64(jsondec* d, upb_StringView str) { |
| const char* end = str.data + str.size; |
| int64_t ret; |
| if (jsondec_buftoint64(d, str.data, end, &ret, NULL) != end) { |
| jsondec_err(d, "Non-number characters in quoted integer"); |
| } |
| return ret; |
| } |
| |
| /* Primitive value types ******************************************************/ |
| |
| /* Parse INT32 or INT64 value. */ |
| static upb_MessageValue jsondec_int(jsondec* d, const upb_FieldDef* f) { |
| upb_MessageValue val; |
| |
| switch (jsondec_peek(d)) { |
| case JD_NUMBER: { |
| double dbl = jsondec_number(d); |
| if (dbl > 9223372036854774784.0 || dbl < -9223372036854775808.0) { |
| jsondec_err(d, "JSON number is out of range."); |
| } |
| val.int64_val = dbl; /* must be guarded, overflow here is UB */ |
| if (val.int64_val != dbl) { |
| jsondec_errf(d, "JSON number was not integral (%f != %" PRId64 ")", dbl, |
| val.int64_val); |
| } |
| break; |
| } |
| case JD_STRING: { |
| upb_StringView str = jsondec_string(d); |
| val.int64_val = jsondec_strtoint64(d, str); |
| break; |
| } |
| default: |
| jsondec_err(d, "Expected number or string"); |
| } |
| |
| if (upb_FieldDef_CType(f) == kUpb_CType_Int32 || |
| upb_FieldDef_CType(f) == kUpb_CType_Enum) { |
| if (val.int64_val > INT32_MAX || val.int64_val < INT32_MIN) { |
| jsondec_err(d, "Integer out of range."); |
| } |
| val.int32_val = (int32_t)val.int64_val; |
| } |
| |
| return val; |
| } |
| |
| /* Parse UINT32 or UINT64 value. */ |
| static upb_MessageValue jsondec_uint(jsondec* d, const upb_FieldDef* f) { |
| upb_MessageValue val = {0}; |
| |
| switch (jsondec_peek(d)) { |
| case JD_NUMBER: { |
| double dbl = jsondec_number(d); |
| if (dbl > 18446744073709549568.0 || dbl < 0) { |
| jsondec_err(d, "JSON number is out of range."); |
| } |
| val.uint64_val = dbl; /* must be guarded, overflow here is UB */ |
| if (val.uint64_val != dbl) { |
| jsondec_errf(d, "JSON number was not integral (%f != %" PRIu64 ")", dbl, |
| val.uint64_val); |
| } |
| break; |
| } |
| case JD_STRING: { |
| upb_StringView str = jsondec_string(d); |
| val.uint64_val = jsondec_strtouint64(d, str); |
| break; |
| } |
| default: |
| jsondec_err(d, "Expected number or string"); |
| } |
| |
| if (upb_FieldDef_CType(f) == kUpb_CType_UInt32) { |
| if (val.uint64_val > UINT32_MAX) { |
| jsondec_err(d, "Integer out of range."); |
| } |
| val.uint32_val = (uint32_t)val.uint64_val; |
| } |
| |
| return val; |
| } |
| |
| /* Parse DOUBLE or FLOAT value. */ |
| static upb_MessageValue jsondec_double(jsondec* d, const upb_FieldDef* f) { |
| upb_StringView str; |
| upb_MessageValue val = {0}; |
| |
| switch (jsondec_peek(d)) { |
| case JD_NUMBER: |
| val.double_val = jsondec_number(d); |
| break; |
| case JD_STRING: |
| str = jsondec_string(d); |
| if (jsondec_streql(str, "NaN")) { |
| val.double_val = NAN; |
| } else if (jsondec_streql(str, "Infinity")) { |
| val.double_val = INFINITY; |
| } else if (jsondec_streql(str, "-Infinity")) { |
| val.double_val = -INFINITY; |
| } else { |
| val.double_val = strtod(str.data, NULL); |
| } |
| break; |
| default: |
| jsondec_err(d, "Expected number or string"); |
| } |
| |
| if (upb_FieldDef_CType(f) == kUpb_CType_Float) { |
| float f = val.double_val; |
| if (val.double_val != INFINITY && val.double_val != -INFINITY) { |
| if (f == INFINITY || f == -INFINITY) jsondec_err(d, "Float out of range"); |
| } |
| val.float_val = f; |
| } |
| |
| return val; |
| } |
| |
| /* Parse STRING or BYTES value. */ |
| static upb_MessageValue jsondec_strfield(jsondec* d, const upb_FieldDef* f) { |
| upb_MessageValue val; |
| val.str_val = jsondec_string(d); |
| if (upb_FieldDef_CType(f) == kUpb_CType_Bytes) { |
| val.str_val.size = jsondec_base64(d, val.str_val); |
| } |
| return val; |
| } |
| |
| static upb_JsonMessageValue jsondec_enum(jsondec* d, const upb_FieldDef* f) { |
| switch (jsondec_peek(d)) { |
| case JD_STRING: { |
| upb_StringView str = jsondec_string(d); |
| const upb_EnumDef* e = upb_FieldDef_EnumSubDef(f); |
| const upb_EnumValueDef* ev = |
| upb_EnumDef_FindValueByNameWithSize(e, str.data, str.size); |
| upb_JsonMessageValue val = {.ignore = false}; |
| if (ev) { |
| val.value.int32_val = upb_EnumValueDef_Number(ev); |
| } else { |
| if (d->options & upb_JsonDecode_IgnoreUnknown) { |
| val.ignore = true; |
| } else { |
| jsondec_errf(d, "Unknown enumerator: '" UPB_STRINGVIEW_FORMAT "'", |
| UPB_STRINGVIEW_ARGS(str)); |
| } |
| } |
| return val; |
| } |
| case JD_NULL: { |
| if (jsondec_isnullvalue(f)) { |
| upb_JsonMessageValue val = {.ignore = false}; |
| jsondec_null(d); |
| val.value.int32_val = 0; |
| return val; |
| } |
| } |
| /* Fallthrough. */ |
| default: |
| return (upb_JsonMessageValue){.value = jsondec_int(d, f), |
| .ignore = false}; |
| } |
| } |
| |
| static upb_MessageValue jsondec_bool(jsondec* d, const upb_FieldDef* f) { |
| bool is_map_key = upb_FieldDef_Number(f) == 1 && |
| upb_MessageDef_IsMapEntry(upb_FieldDef_ContainingType(f)); |
| upb_MessageValue val; |
| |
| if (is_map_key) { |
| upb_StringView str = jsondec_string(d); |
| if (jsondec_streql(str, "true")) { |
| val.bool_val = true; |
| } else if (jsondec_streql(str, "false")) { |
| val.bool_val = false; |
| } else { |
| jsondec_err(d, "Invalid boolean map key"); |
| } |
| } else { |
| switch (jsondec_peek(d)) { |
| case JD_TRUE: |
| val.bool_val = true; |
| jsondec_true(d); |
| break; |
| case JD_FALSE: |
| val.bool_val = false; |
| jsondec_false(d); |
| break; |
| default: |
| jsondec_err(d, "Expected true or false"); |
| } |
| } |
| |
| return val; |
| } |
| |
| /* Composite types (array/message/map) ****************************************/ |
| |
| static void jsondec_array(jsondec* d, upb_Message* msg, const upb_FieldDef* f) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| upb_Array* arr = upb_Message_Mutable(msg, f, d->arena).array; |
| |
| jsondec_arrstart(d); |
| while (jsondec_arrnext(d)) { |
| upb_JsonMessageValue elem = jsondec_value(d, f); |
| if (!elem.ignore) { |
| upb_Array_Append(arr, elem.value, d->arena); |
| } |
| } |
| jsondec_arrend(d); |
| } |
| |
| static void jsondec_map(jsondec* d, upb_Message* msg, const upb_FieldDef* f) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| upb_Map* map = upb_Message_Mutable(msg, f, d->arena).map; |
| const upb_MessageDef* entry = upb_FieldDef_MessageSubDef(f); |
| const upb_FieldDef* key_f = upb_MessageDef_FindFieldByNumber(entry, 1); |
| const upb_FieldDef* val_f = upb_MessageDef_FindFieldByNumber(entry, 2); |
| |
| jsondec_objstart(d); |
| while (jsondec_objnext(d)) { |
| upb_JsonMessageValue key, val; |
| key = jsondec_value(d, key_f); |
| UPB_ASSUME(!key.ignore); // Map key cannot be enum. |
| jsondec_entrysep(d); |
| val = jsondec_value(d, val_f); |
| if (!val.ignore) { |
| upb_Map_Set(map, key.value, val.value, d->arena); |
| } |
| } |
| jsondec_objend(d); |
| } |
| |
| static void jsondec_tomsg(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| if (upb_MessageDef_WellKnownType(m) == kUpb_WellKnown_Unspecified) { |
| jsondec_object(d, msg, m); |
| } else { |
| jsondec_wellknown(d, msg, m); |
| } |
| } |
| |
| static upb_MessageValue jsondec_msg(jsondec* d, const upb_FieldDef* f) { |
| const upb_MessageDef* m = upb_FieldDef_MessageSubDef(f); |
| const upb_MiniTable* layout = upb_MessageDef_MiniTable(m); |
| upb_Message* msg = upb_Message_New(layout, d->arena); |
| upb_MessageValue val; |
| |
| jsondec_tomsg(d, msg, m); |
| val.msg_val = msg; |
| return val; |
| } |
| |
| static void jsondec_field(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| upb_StringView name; |
| const upb_FieldDef* f; |
| const upb_FieldDef* preserved; |
| |
| name = jsondec_string(d); |
| jsondec_entrysep(d); |
| |
| if (name.size >= 2 && name.data[0] == '[' && |
| name.data[name.size - 1] == ']') { |
| f = upb_DefPool_FindExtensionByNameWithSize(d->symtab, name.data + 1, |
| name.size - 2); |
| if (f && upb_FieldDef_ContainingType(f) != m) { |
| jsondec_errf( |
| d, "Extension %s extends message %s, but was seen in message %s", |
| upb_FieldDef_FullName(f), |
| upb_MessageDef_FullName(upb_FieldDef_ContainingType(f)), |
| upb_MessageDef_FullName(m)); |
| } |
| } else { |
| f = upb_MessageDef_FindByJsonNameWithSize(m, name.data, name.size); |
| } |
| |
| if (!f) { |
| if ((d->options & upb_JsonDecode_IgnoreUnknown) == 0) { |
| jsondec_errf(d, "No such field: " UPB_STRINGVIEW_FORMAT, |
| UPB_STRINGVIEW_ARGS(name)); |
| } |
| jsondec_skipval(d); |
| return; |
| } |
| |
| if (jsondec_peek(d) == JD_NULL && !jsondec_isvalue(f)) { |
| /* JSON "null" indicates a default value, so no need to set anything. */ |
| jsondec_null(d); |
| return; |
| } |
| |
| if (upb_FieldDef_RealContainingOneof(f) && |
| upb_Message_WhichOneofByDef(msg, upb_FieldDef_ContainingOneof(f))) { |
| jsondec_err(d, "More than one field for this oneof."); |
| } |
| |
| preserved = d->debug_field; |
| d->debug_field = f; |
| |
| if (upb_FieldDef_IsMap(f)) { |
| jsondec_map(d, msg, f); |
| } else if (upb_FieldDef_IsRepeated(f)) { |
| jsondec_array(d, msg, f); |
| } else if (upb_FieldDef_IsSubMessage(f)) { |
| upb_Message* submsg = upb_Message_Mutable(msg, f, d->arena).msg; |
| const upb_MessageDef* subm = upb_FieldDef_MessageSubDef(f); |
| jsondec_tomsg(d, submsg, subm); |
| } else { |
| upb_JsonMessageValue val = jsondec_value(d, f); |
| if (!val.ignore) { |
| upb_Message_SetFieldByDef(msg, f, val.value, d->arena); |
| } |
| } |
| |
| d->debug_field = preserved; |
| } |
| |
| static void jsondec_object(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| jsondec_objstart(d); |
| while (jsondec_objnext(d)) { |
| jsondec_field(d, msg, m); |
| } |
| jsondec_objend(d); |
| } |
| |
| static upb_MessageValue jsondec_nonenum(jsondec* d, const upb_FieldDef* f) { |
| switch (upb_FieldDef_CType(f)) { |
| case kUpb_CType_Bool: |
| return jsondec_bool(d, f); |
| case kUpb_CType_Float: |
| case kUpb_CType_Double: |
| return jsondec_double(d, f); |
| case kUpb_CType_UInt32: |
| case kUpb_CType_UInt64: |
| return jsondec_uint(d, f); |
| case kUpb_CType_Int32: |
| case kUpb_CType_Int64: |
| return jsondec_int(d, f); |
| case kUpb_CType_String: |
| case kUpb_CType_Bytes: |
| return jsondec_strfield(d, f); |
| case kUpb_CType_Message: |
| return jsondec_msg(d, f); |
| case kUpb_CType_Enum: |
| default: |
| UPB_UNREACHABLE(); |
| } |
| } |
| |
| static upb_JsonMessageValue jsondec_value(jsondec* d, const upb_FieldDef* f) { |
| if (upb_FieldDef_CType(f) == kUpb_CType_Enum) { |
| return jsondec_enum(d, f); |
| } else { |
| return (upb_JsonMessageValue){.value = jsondec_nonenum(d, f), |
| .ignore = false}; |
| } |
| } |
| |
| /* Well-known types ***********************************************************/ |
| |
| static int jsondec_tsdigits(jsondec* d, const char** ptr, size_t digits, |
| const char* after) { |
| uint64_t val; |
| const char* p = *ptr; |
| const char* end = p + digits; |
| size_t after_len = after ? strlen(after) : 0; |
| |
| UPB_ASSERT(digits <= 9); /* int can't overflow. */ |
| |
| if (jsondec_buftouint64(d, p, end, &val) != end || |
| (after_len && memcmp(end, after, after_len) != 0)) { |
| jsondec_err(d, "Malformed timestamp"); |
| } |
| |
| UPB_ASSERT(val < INT_MAX); |
| |
| *ptr = end + after_len; |
| return (int)val; |
| } |
| |
| static int jsondec_nanos(jsondec* d, const char** ptr, const char* end) { |
| uint64_t nanos = 0; |
| const char* p = *ptr; |
| |
| if (p != end && *p == '.') { |
| const char* nano_end = jsondec_buftouint64(d, p + 1, end, &nanos); |
| int digits = (int)(nano_end - p - 1); |
| int exp_lg10 = 9 - digits; |
| if (digits > 9) { |
| jsondec_err(d, "Too many digits for partial seconds"); |
| } |
| while (exp_lg10--) nanos *= 10; |
| *ptr = nano_end; |
| } |
| |
| UPB_ASSERT(nanos < INT_MAX); |
| |
| return (int)nanos; |
| } |
| |
| /* jsondec_epochdays(1970, 1, 1) == 1970-01-01 == 0. */ |
| int jsondec_epochdays(int y, int m, int d) { |
| const uint32_t year_base = 4800; /* Before min year, multiple of 400. */ |
| const uint32_t m_adj = m - 3; /* March-based month. */ |
| const uint32_t carry = m_adj > (uint32_t)m ? 1 : 0; |
| const uint32_t adjust = carry ? 12 : 0; |
| const uint32_t y_adj = y + year_base - carry; |
| const uint32_t month_days = ((m_adj + adjust) * 62719 + 769) / 2048; |
| const uint32_t leap_days = y_adj / 4 - y_adj / 100 + y_adj / 400; |
| return y_adj * 365 + leap_days + month_days + (d - 1) - 2472632; |
| } |
| |
| static int64_t jsondec_unixtime(int y, int m, int d, int h, int min, int s) { |
| return (int64_t)jsondec_epochdays(y, m, d) * 86400 + h * 3600 + min * 60 + s; |
| } |
| |
| static void jsondec_timestamp(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| upb_MessageValue seconds; |
| upb_MessageValue nanos; |
| upb_StringView str = jsondec_string(d); |
| const char* ptr = str.data; |
| const char* end = ptr + str.size; |
| |
| if (str.size < 20) goto malformed; |
| |
| { |
| /* 1972-01-01T01:00:00 */ |
| int year = jsondec_tsdigits(d, &ptr, 4, "-"); |
| int mon = jsondec_tsdigits(d, &ptr, 2, "-"); |
| int day = jsondec_tsdigits(d, &ptr, 2, "T"); |
| int hour = jsondec_tsdigits(d, &ptr, 2, ":"); |
| int min = jsondec_tsdigits(d, &ptr, 2, ":"); |
| int sec = jsondec_tsdigits(d, &ptr, 2, NULL); |
| |
| seconds.int64_val = jsondec_unixtime(year, mon, day, hour, min, sec); |
| } |
| |
| nanos.int32_val = jsondec_nanos(d, &ptr, end); |
| |
| { |
| /* [+-]08:00 or Z */ |
| int ofs_hour = 0; |
| int ofs_min = 0; |
| bool neg = false; |
| |
| if (ptr == end) goto malformed; |
| |
| switch (*ptr++) { |
| case '-': |
| neg = true; |
| /* fallthrough */ |
| case '+': |
| if ((end - ptr) != 5) goto malformed; |
| ofs_hour = jsondec_tsdigits(d, &ptr, 2, ":"); |
| ofs_min = jsondec_tsdigits(d, &ptr, 2, NULL); |
| ofs_min = ((ofs_hour * 60) + ofs_min) * 60; |
| seconds.int64_val += (neg ? ofs_min : -ofs_min); |
| break; |
| case 'Z': |
| if (ptr != end) goto malformed; |
| break; |
| default: |
| goto malformed; |
| } |
| } |
| |
| if (seconds.int64_val < -62135596800) { |
| jsondec_err(d, "Timestamp out of range"); |
| } |
| |
| upb_Message_SetFieldByDef(msg, upb_MessageDef_FindFieldByNumber(m, 1), |
| seconds, d->arena); |
| upb_Message_SetFieldByDef(msg, upb_MessageDef_FindFieldByNumber(m, 2), nanos, |
| d->arena); |
| return; |
| |
| malformed: |
| jsondec_err(d, "Malformed timestamp"); |
| } |
| |
| static void jsondec_duration(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| upb_MessageValue seconds; |
| upb_MessageValue nanos; |
| upb_StringView str = jsondec_string(d); |
| const char* ptr = str.data; |
| const char* end = ptr + str.size; |
| const int64_t max = (uint64_t)3652500 * 86400; |
| bool neg = false; |
| |
| /* "3.000000001s", "3s", etc. */ |
| ptr = jsondec_buftoint64(d, ptr, end, &seconds.int64_val, &neg); |
| nanos.int32_val = jsondec_nanos(d, &ptr, end); |
| |
| if (end - ptr != 1 || *ptr != 's') { |
| jsondec_err(d, "Malformed duration"); |
| } |
| |
| if (seconds.int64_val < -max || seconds.int64_val > max) { |
| jsondec_err(d, "Duration out of range"); |
| } |
| |
| if (neg) { |
| nanos.int32_val = -nanos.int32_val; |
| } |
| |
| upb_Message_SetFieldByDef(msg, upb_MessageDef_FindFieldByNumber(m, 1), |
| seconds, d->arena); |
| upb_Message_SetFieldByDef(msg, upb_MessageDef_FindFieldByNumber(m, 2), nanos, |
| d->arena); |
| } |
| |
| static void jsondec_listvalue(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| const upb_FieldDef* values_f = upb_MessageDef_FindFieldByNumber(m, 1); |
| const upb_MessageDef* value_m = upb_FieldDef_MessageSubDef(values_f); |
| const upb_MiniTable* value_layout = upb_MessageDef_MiniTable(value_m); |
| upb_Array* values = upb_Message_Mutable(msg, values_f, d->arena).array; |
| |
| jsondec_arrstart(d); |
| while (jsondec_arrnext(d)) { |
| upb_Message* value_msg = upb_Message_New(value_layout, d->arena); |
| upb_MessageValue value; |
| value.msg_val = value_msg; |
| upb_Array_Append(values, value, d->arena); |
| jsondec_wellknownvalue(d, value_msg, value_m); |
| } |
| jsondec_arrend(d); |
| } |
| |
| static void jsondec_struct(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| const upb_FieldDef* fields_f = upb_MessageDef_FindFieldByNumber(m, 1); |
| const upb_MessageDef* entry_m = upb_FieldDef_MessageSubDef(fields_f); |
| const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(entry_m, 2); |
| const upb_MessageDef* value_m = upb_FieldDef_MessageSubDef(value_f); |
| const upb_MiniTable* value_layout = upb_MessageDef_MiniTable(value_m); |
| upb_Map* fields = upb_Message_Mutable(msg, fields_f, d->arena).map; |
| |
| jsondec_objstart(d); |
| while (jsondec_objnext(d)) { |
| upb_MessageValue key, value; |
| upb_Message* value_msg = upb_Message_New(value_layout, d->arena); |
| key.str_val = jsondec_string(d); |
| value.msg_val = value_msg; |
| upb_Map_Set(fields, key, value, d->arena); |
| jsondec_entrysep(d); |
| jsondec_wellknownvalue(d, value_msg, value_m); |
| } |
| jsondec_objend(d); |
| } |
| |
| static void jsondec_wellknownvalue(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| upb_MessageValue val; |
| const upb_FieldDef* f; |
| upb_Message* submsg; |
| |
| switch (jsondec_peek(d)) { |
| case JD_NUMBER: |
| /* double number_value = 2; */ |
| f = upb_MessageDef_FindFieldByNumber(m, 2); |
| val.double_val = jsondec_number(d); |
| break; |
| case JD_STRING: |
| /* string string_value = 3; */ |
| f = upb_MessageDef_FindFieldByNumber(m, 3); |
| val.str_val = jsondec_string(d); |
| break; |
| case JD_FALSE: |
| /* bool bool_value = 4; */ |
| f = upb_MessageDef_FindFieldByNumber(m, 4); |
| val.bool_val = false; |
| jsondec_false(d); |
| break; |
| case JD_TRUE: |
| /* bool bool_value = 4; */ |
| f = upb_MessageDef_FindFieldByNumber(m, 4); |
| val.bool_val = true; |
| jsondec_true(d); |
| break; |
| case JD_NULL: |
| /* NullValue null_value = 1; */ |
| f = upb_MessageDef_FindFieldByNumber(m, 1); |
| val.int32_val = 0; |
| jsondec_null(d); |
| break; |
| /* Note: these cases return, because upb_Message_Mutable() is enough. */ |
| case JD_OBJECT: |
| /* Struct struct_value = 5; */ |
| f = upb_MessageDef_FindFieldByNumber(m, 5); |
| submsg = upb_Message_Mutable(msg, f, d->arena).msg; |
| jsondec_struct(d, submsg, upb_FieldDef_MessageSubDef(f)); |
| return; |
| case JD_ARRAY: |
| /* ListValue list_value = 6; */ |
| f = upb_MessageDef_FindFieldByNumber(m, 6); |
| submsg = upb_Message_Mutable(msg, f, d->arena).msg; |
| jsondec_listvalue(d, submsg, upb_FieldDef_MessageSubDef(f)); |
| return; |
| default: |
| UPB_UNREACHABLE(); |
| } |
| |
| upb_Message_SetFieldByDef(msg, f, val, d->arena); |
| } |
| |
| static upb_StringView jsondec_mask(jsondec* d, const char* buf, |
| const char* end) { |
| /* FieldMask fields grow due to inserted '_' characters, so we can't do the |
| * transform in place. */ |
| const char* ptr = buf; |
| upb_StringView ret; |
| char* out; |
| |
| ret.size = end - ptr; |
| while (ptr < end) { |
| ret.size += (*ptr >= 'A' && *ptr <= 'Z'); |
| ptr++; |
| } |
| |
| out = upb_Arena_Malloc(d->arena, ret.size); |
| ptr = buf; |
| ret.data = out; |
| |
| while (ptr < end) { |
| char ch = *ptr++; |
| if (ch >= 'A' && ch <= 'Z') { |
| *out++ = '_'; |
| *out++ = ch + 32; |
| } else if (ch == '_') { |
| jsondec_err(d, "field mask may not contain '_'"); |
| } else { |
| *out++ = ch; |
| } |
| } |
| |
| return ret; |
| } |
| |
| static void jsondec_fieldmask(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| /* repeated string paths = 1; */ |
| const upb_FieldDef* paths_f = upb_MessageDef_FindFieldByNumber(m, 1); |
| upb_Array* arr = upb_Message_Mutable(msg, paths_f, d->arena).array; |
| upb_StringView str = jsondec_string(d); |
| const char* ptr = str.data; |
| const char* end = ptr + str.size; |
| upb_MessageValue val; |
| |
| while (ptr < end) { |
| const char* elem_end = memchr(ptr, ',', end - ptr); |
| if (elem_end) { |
| val.str_val = jsondec_mask(d, ptr, elem_end); |
| ptr = elem_end + 1; |
| } else { |
| val.str_val = jsondec_mask(d, ptr, end); |
| ptr = end; |
| } |
| upb_Array_Append(arr, val, d->arena); |
| } |
| } |
| |
| static void jsondec_anyfield(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| if (upb_MessageDef_WellKnownType(m) == kUpb_WellKnown_Unspecified) { |
| /* For regular types: {"@type": "[user type]", "f1": <V1>, "f2": <V2>} |
| * where f1, f2, etc. are the normal fields of this type. */ |
| jsondec_field(d, msg, m); |
| } else { |
| /* For well-known types: {"@type": "[well-known type]", "value": <X>} |
| * where <X> is whatever encoding the WKT normally uses. */ |
| upb_StringView str = jsondec_string(d); |
| jsondec_entrysep(d); |
| if (!jsondec_streql(str, "value")) { |
| jsondec_err(d, "Key for well-known type must be 'value'"); |
| } |
| jsondec_wellknown(d, msg, m); |
| } |
| } |
| |
| static const upb_MessageDef* jsondec_typeurl(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| const upb_FieldDef* type_url_f = upb_MessageDef_FindFieldByNumber(m, 1); |
| const upb_MessageDef* type_m; |
| upb_StringView type_url = jsondec_string(d); |
| const char* end = type_url.data + type_url.size; |
| const char* ptr = end; |
| upb_MessageValue val; |
| |
| val.str_val = type_url; |
| upb_Message_SetFieldByDef(msg, type_url_f, val, d->arena); |
| |
| /* Find message name after the last '/' */ |
| while (ptr > type_url.data && *--ptr != '/') { |
| } |
| |
| if (ptr == type_url.data || ptr == end) { |
| jsondec_err(d, "Type url must have at least one '/' and non-empty host"); |
| } |
| |
| ptr++; |
| type_m = upb_DefPool_FindMessageByNameWithSize(d->symtab, ptr, end - ptr); |
| |
| if (!type_m) { |
| jsondec_err(d, "Type was not found"); |
| } |
| |
| return type_m; |
| } |
| |
| static void jsondec_any(jsondec* d, upb_Message* msg, const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| /* string type_url = 1; |
| * bytes value = 2; */ |
| const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(m, 2); |
| upb_Message* any_msg; |
| const upb_MessageDef* any_m = NULL; |
| const char* pre_type_data = NULL; |
| const char* pre_type_end = NULL; |
| upb_MessageValue encoded; |
| |
| jsondec_objstart(d); |
| |
| /* Scan looking for "@type", which is not necessarily first. */ |
| while (!any_m && jsondec_objnext(d)) { |
| const char* start = d->ptr; |
| upb_StringView name = jsondec_string(d); |
| jsondec_entrysep(d); |
| if (jsondec_streql(name, "@type")) { |
| any_m = jsondec_typeurl(d, msg, m); |
| if (pre_type_data) { |
| pre_type_end = start; |
| while (*pre_type_end != ',') pre_type_end--; |
| } |
| } else { |
| if (!pre_type_data) pre_type_data = start; |
| jsondec_skipval(d); |
| } |
| } |
| |
| if (!any_m) { |
| jsondec_err(d, "Any object didn't contain a '@type' field"); |
| } |
| |
| const upb_MiniTable* any_layout = upb_MessageDef_MiniTable(any_m); |
| any_msg = upb_Message_New(any_layout, d->arena); |
| |
| if (pre_type_data) { |
| size_t len = pre_type_end - pre_type_data + 1; |
| char* tmp = upb_Arena_Malloc(d->arena, len); |
| const char* saved_ptr = d->ptr; |
| const char* saved_end = d->end; |
| memcpy(tmp, pre_type_data, len - 1); |
| tmp[len - 1] = '}'; |
| d->ptr = tmp; |
| d->end = tmp + len; |
| d->is_first = true; |
| while (jsondec_objnext(d)) { |
| jsondec_anyfield(d, any_msg, any_m); |
| } |
| d->ptr = saved_ptr; |
| d->end = saved_end; |
| } |
| |
| while (jsondec_objnext(d)) { |
| jsondec_anyfield(d, any_msg, any_m); |
| } |
| |
| jsondec_objend(d); |
| |
| upb_EncodeStatus status = |
| upb_Encode(any_msg, upb_MessageDef_MiniTable(any_m), 0, d->arena, |
| (char**)&encoded.str_val.data, &encoded.str_val.size); |
| // TODO: We should fail gracefully here on a bad return status. |
| UPB_ASSERT(status == kUpb_EncodeStatus_Ok); |
| upb_Message_SetFieldByDef(msg, value_f, encoded, d->arena); |
| } |
| |
| static void jsondec_wrapper(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| const upb_FieldDef* value_f = upb_MessageDef_FindFieldByNumber(m, 1); |
| upb_JsonMessageValue val = jsondec_value(d, value_f); |
| UPB_ASSUME(val.ignore == false); // Wrapper cannot be an enum. |
| upb_Message_SetFieldByDef(msg, value_f, val.value, d->arena); |
| } |
| |
| static void jsondec_wellknown(jsondec* d, upb_Message* msg, |
| const upb_MessageDef* m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| switch (upb_MessageDef_WellKnownType(m)) { |
| case kUpb_WellKnown_Any: |
| jsondec_any(d, msg, m); |
| break; |
| case kUpb_WellKnown_FieldMask: |
| jsondec_fieldmask(d, msg, m); |
| break; |
| case kUpb_WellKnown_Duration: |
| jsondec_duration(d, msg, m); |
| break; |
| case kUpb_WellKnown_Timestamp: |
| jsondec_timestamp(d, msg, m); |
| break; |
| case kUpb_WellKnown_Value: |
| jsondec_wellknownvalue(d, msg, m); |
| break; |
| case kUpb_WellKnown_ListValue: |
| jsondec_listvalue(d, msg, m); |
| break; |
| case kUpb_WellKnown_Struct: |
| jsondec_struct(d, msg, m); |
| break; |
| case kUpb_WellKnown_DoubleValue: |
| case kUpb_WellKnown_FloatValue: |
| case kUpb_WellKnown_Int64Value: |
| case kUpb_WellKnown_UInt64Value: |
| case kUpb_WellKnown_Int32Value: |
| case kUpb_WellKnown_UInt32Value: |
| case kUpb_WellKnown_StringValue: |
| case kUpb_WellKnown_BytesValue: |
| case kUpb_WellKnown_BoolValue: |
| jsondec_wrapper(d, msg, m); |
| break; |
| default: |
| UPB_UNREACHABLE(); |
| } |
| } |
| |
| static bool upb_JsonDecoder_Decode(jsondec* const d, upb_Message* const msg, |
| const upb_MessageDef* const m) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| if (UPB_SETJMP(d->err)) return false; |
| |
| jsondec_tomsg(d, msg, m); |
| |
| // Consume any trailing whitespace before checking if we read the entire |
| // input. |
| jsondec_consumews(d); |
| |
| if (d->ptr == d->end) { |
| return true; |
| } else { |
| jsondec_seterrmsg(d, "unexpected trailing characters"); |
| return false; |
| } |
| } |
| |
| bool upb_JsonDecode(const char* buf, size_t size, upb_Message* msg, |
| const upb_MessageDef* m, const upb_DefPool* symtab, |
| int options, upb_Arena* arena, upb_Status* status) { |
| UPB_ASSERT(!upb_Message_IsFrozen(msg)); |
| jsondec d; |
| |
| if (size == 0) return true; |
| |
| d.ptr = buf; |
| d.end = buf + size; |
| d.arena = arena; |
| d.symtab = symtab; |
| d.status = status; |
| d.options = options; |
| d.depth = 64; |
| d.line = 1; |
| d.line_begin = d.ptr; |
| d.debug_field = NULL; |
| d.is_first = false; |
| |
| return upb_JsonDecoder_Decode(&d, msg, m); |
| } |