third_party/upb/upb/json_decode.c

   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_decode.h"
  29
  30 #include <errno.h>
  31 #include <float.h>
  32 #include <inttypes.h>
  33 #include <limits.h>
  34 #include <math.h>
  35 #include <setjmp.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38
  39 #include "upb/encode.h"
  40 #include "upb/reflection.h"
  41
  42 /* Special header, must be included last. */
  43 #include "upb/port_def.inc"
  44
  45 typedef struct {
  46   const char *ptr, *end;
  47   upb_arena *arena;  /* TODO: should we have a tmp arena for tmp data? */
  48   const upb_symtab *any_pool;
  49   int depth;
  50   upb_status *status;
  51   jmp_buf err;
  52   int line;
  53   const char *line_begin;
  54   bool is_first;
  55   int options;
  56   const upb_fielddef *debug_field;
  57 } jsondec;
  58
  59 enum { JD_OBJECT, JD_ARRAY, JD_STRING, JD_NUMBER, JD_TRUE, JD_FALSE, JD_NULL };
  60
  61 /* Forward declarations of mutually-recursive functions. */
  62 static void jsondec_wellknown(jsondec *d, upb_msg *msg, const upb_msgdef *m);
  63 static upb_msgval jsondec_value(jsondec *d, const upb_fielddef *f);
  64 static void jsondec_wellknownvalue(jsondec *d, upb_msg *msg,
  65                                    const upb_msgdef *m);
  66 static void jsondec_object(jsondec *d, upb_msg *msg, const upb_msgdef *m);
  67
  68 static bool jsondec_streql(upb_strview str, const char *lit) {
  69   return str.size == strlen(lit) && memcmp(str.data, lit, str.size) == 0;
  70 }
  71
  72 static bool jsondec_isnullvalue(const upb_fielddef *f) {
  73   return upb_fielddef_type(f) == UPB_TYPE_ENUM &&
  74          strcmp(upb_enumdef_fullname(upb_fielddef_enumsubdef(f)),
  75                 "google.protobuf.NullValue") == 0;
  76 }
  77
  78 static bool jsondec_isvalue(const upb_fielddef *f) {
  79   return (upb_fielddef_type(f) == UPB_TYPE_MESSAGE &&
  80           upb_msgdef_wellknowntype(upb_fielddef_msgsubdef(f)) ==
  81               UPB_WELLKNOWN_VALUE) ||
  82          jsondec_isnullvalue(f);
  83 }
  84
  85 UPB_NORETURN static void jsondec_err(jsondec *d, const char *msg) {
  86   upb_status_seterrf(d->status, "Error parsing JSON @%d:%d: %s", d->line,
  87                      (int)(d->ptr - d->line_begin), msg);
  88   UPB_LONGJMP(d->err, 1);
  89 }
  90
  91 UPB_PRINTF(2, 3)
  92 UPB_NORETURN static void jsondec_errf(jsondec *d, const char *fmt, ...) {
  93   va_list argp;
  94   upb_status_seterrf(d->status, "Error parsing JSON @%d:%d: ", d->line,
  95                      (int)(d->ptr - d->line_begin));
  96   va_start(argp, fmt);
  97   upb_status_vappenderrf(d->status, fmt, argp);
  98   va_end(argp);
  99   UPB_LONGJMP(d->err, 1);
 100 }
 101
 102 static void jsondec_skipws(jsondec *d) {
 103   while (d->ptr != d->end) {
 104     switch (*d->ptr) {
 105       case '\n':
 106         d->line++;
 107         d->line_begin = d->ptr;
 108         /* Fallthrough. */
 109       case '\r':
 110       case '\t':
 111       case ' ':
 112         d->ptr++;
 113         break;
 114       default:
 115         return;
 116     }
 117   }
 118   jsondec_err(d, "Unexpected EOF");
 119 }
 120
 121 static bool jsondec_tryparsech(jsondec *d, char ch) {
 122   if (d->ptr == d->end || *d->ptr != ch) return false;
 123   d->ptr++;
 124   return true;
 125 }
 126
 127 static void jsondec_parselit(jsondec *d, const char *lit) {
 128   size_t avail = d->end - d->ptr;
 129   size_t len = strlen(lit);
 130   if (avail < len || memcmp(d->ptr, lit, len) != 0) {
 131     jsondec_errf(d, "Expected: '%s'", lit);
 132   }
 133   d->ptr += len;
 134 }
 135
 136 static void jsondec_wsch(jsondec *d, char ch) {
 137   jsondec_skipws(d);
 138   if (!jsondec_tryparsech(d, ch)) {
 139     jsondec_errf(d, "Expected: '%c'", ch);
 140   }
 141 }
 142
 143 static void jsondec_true(jsondec *d) { jsondec_parselit(d, "true"); }
 144 static void jsondec_false(jsondec *d) { jsondec_parselit(d, "false"); }
 145 static void jsondec_null(jsondec *d) { jsondec_parselit(d, "null"); }
 146
 147 static void jsondec_entrysep(jsondec *d) {
 148   jsondec_skipws(d);
 149   jsondec_parselit(d, ":");
 150 }
 151
 152 static int jsondec_rawpeek(jsondec *d) {
 153   switch (*d->ptr) {
 154     case '{':
 155       return JD_OBJECT;
 156     case '[':
 157       return JD_ARRAY;
 158     case '"':
 159       return JD_STRING;
 160     case '-':
 161     case '0':
 162     case '1':
 163     case '2':
 164     case '3':
 165     case '4':
 166     case '5':
 167     case '6':
 168     case '7':
 169     case '8':
 170     case '9':
 171       return JD_NUMBER;
 172     case 't':
 173       return JD_TRUE;
 174     case 'f':
 175       return JD_FALSE;
 176     case 'n':
 177       return JD_NULL;
 178     default:
 179       jsondec_errf(d, "Unexpected character: '%c'", *d->ptr);
 180   }
 181 }
 182
 183 /* JSON object/array **********************************************************/
 184
 185 /* These are used like so:
 186  *
 187  * jsondec_objstart(d);
 188  * while (jsondec_objnext(d)) {
 189  *   ...
 190  * }
 191  * jsondec_objend(d) */
 192
 193 static int jsondec_peek(jsondec *d) {
 194   jsondec_skipws(d);
 195   return jsondec_rawpeek(d);
 196 }
 197
 198 static void jsondec_push(jsondec *d) {
 199   if (--d->depth < 0) {
 200     jsondec_err(d, "Recursion limit exceeded");
 201   }
 202   d->is_first = true;
 203 }
 204
 205 static bool jsondec_seqnext(jsondec *d, char end_ch) {
 206   bool is_first = d->is_first;
 207   d->is_first = false;
 208   jsondec_skipws(d);
 209   if (*d->ptr == end_ch) return false;
 210   if (!is_first) jsondec_parselit(d, ",");
 211   return true;
 212 }
 213
 214 static void jsondec_arrstart(jsondec *d) {
 215   jsondec_push(d);
 216   jsondec_wsch(d, '[');
 217 }
 218
 219 static void jsondec_arrend(jsondec *d) {
 220   d->depth++;
 221   jsondec_wsch(d, ']');
 222 }
 223
 224 static bool jsondec_arrnext(jsondec *d) {
 225   return jsondec_seqnext(d, ']');
 226 }
 227
 228 static void jsondec_objstart(jsondec *d) {
 229   jsondec_push(d);
 230   jsondec_wsch(d, '{');
 231 }
 232
 233 static void jsondec_objend(jsondec *d) {
 234   d->depth++;
 235   jsondec_wsch(d, '}');
 236 }
 237
 238 static bool jsondec_objnext(jsondec *d) {
 239   if (!jsondec_seqnext(d, '}')) return false;
 240   if (jsondec_peek(d) != JD_STRING) {
 241     jsondec_err(d, "Object must start with string");
 242   }
 243   return true;
 244 }
 245
 246 /* JSON number ****************************************************************/
 247
 248 static bool jsondec_tryskipdigits(jsondec *d) {
 249   const char *start = d->ptr;
 250
 251   while (d->ptr < d->end) {
 252     if (*d->ptr < '0' || *d->ptr > '9') {
 253       break;
 254     }
 255     d->ptr++;
 256   }
 257
 258   return d->ptr != start;
 259 }
 260
 261 static void jsondec_skipdigits(jsondec *d) {
 262   if (!jsondec_tryskipdigits(d)) {
 263     jsondec_err(d, "Expected one or more digits");
 264   }
 265 }
 266
 267 static double jsondec_number(jsondec *d) {
 268   const char *start = d->ptr;
 269
 270   assert(jsondec_rawpeek(d) == JD_NUMBER);
 271
 272   /* Skip over the syntax of a number, as specified by JSON. */
 273   if (*d->ptr == '-') d->ptr++;
 274
 275   if (jsondec_tryparsech(d, '0')) {
 276     if (jsondec_tryskipdigits(d)) {
 277       jsondec_err(d, "number cannot have leading zero");
 278     }
 279   } else {
 280     jsondec_skipdigits(d);
 281   }
 282
 283   if (d->ptr == d->end) goto parse;
 284   if (jsondec_tryparsech(d, '.')) {
 285     jsondec_skipdigits(d);
 286   }
 287   if (d->ptr == d->end) goto parse;
 288
 289   if (*d->ptr == 'e' || *d->ptr == 'E') {
 290     d->ptr++;
 291     if (d->ptr == d->end) {
 292       jsondec_err(d, "Unexpected EOF in number");
 293     }
 294     if (*d->ptr == '+' || *d->ptr == '-') {
 295       d->ptr++;
 296     }
 297     jsondec_skipdigits(d);
 298   }
 299
 300 parse:
 301   /* Having verified the syntax of a JSON number, use strtod() to parse
 302    * (strtod() accepts a superset of JSON syntax). */
 303   errno = 0;
 304   {
 305     char* end;
 306     double val = strtod(start, &end);
 307     assert(end == d->ptr);
 308
 309     /* Currently the min/max-val conformance tests fail if we check this.  Does
 310      * this mean the conformance tests are wrong or strtod() is wrong, or
 311      * something else?  Investigate further. */
 312     /*
 313     if (errno == ERANGE) {
 314       jsondec_err(d, "Number out of range");
 315     }
 316     */
 317
 318     if (val > DBL_MAX || val < -DBL_MAX) {
 319       jsondec_err(d, "Number out of range");
 320     }
 321
 322     return val;
 323   }
 324 }
 325
 326 /* JSON string ****************************************************************/
 327
 328 static char jsondec_escape(jsondec *d) {
 329   switch (*d->ptr++) {
 330     case '"':
 331       return '\"';
 332     case '\\':
 333       return '\\';
 334     case '/':
 335       return '/';
 336     case 'b':
 337       return '\b';
 338     case 'f':
 339       return '\f';
 340     case 'n':
 341       return '\n';
 342     case 'r':
 343       return '\r';
 344     case 't':
 345       return '\t';
 346     default:
 347       jsondec_err(d, "Invalid escape char");
 348   }
 349 }
 350
 351 static uint32_t jsondec_codepoint(jsondec *d) {
 352   uint32_t cp = 0;
 353   const char *end;
 354
 355   if (d->end - d->ptr < 4) {
 356     jsondec_err(d, "EOF inside string");
 357   }
 358
 359   end = d->ptr + 4;
 360   while (d->ptr < end) {
 361     char ch = *d->ptr++;
 362     if (ch >= '0' && ch <= '9') {
 363       ch -= '0';
 364     } else if (ch >= 'a' && ch <= 'f') {
 365       ch = ch - 'a' + 10;
 366     } else if (ch >= 'A' && ch <= 'F') {
 367       ch = ch - 'A' + 10;
 368     } else {
 369       jsondec_err(d, "Invalid hex digit");
 370     }
 371     cp = (cp << 4) | ch;
 372   }
 373
 374   return cp;
 375 }
 376
 377 /* Parses a \uXXXX unicode escape (possibly a surrogate pair). */
 378 static size_t jsondec_unicode(jsondec *d, char* out) {
 379   uint32_t cp = jsondec_codepoint(d);
 380   if (cp >= 0xd800 && cp <= 0xdbff) {
 381     /* Surrogate pair: two 16-bit codepoints become a 32-bit codepoint. */
 382     uint32_t high = cp;
 383     uint32_t low;
 384     jsondec_parselit(d, "\\u");
 385     low = jsondec_codepoint(d);
 386     if (low < 0xdc00 || low > 0xdfff) {
 387       jsondec_err(d, "Invalid low surrogate");
 388     }
 389     cp = (high & 0x3ff) << 10;
 390     cp |= (low & 0x3ff);
 391     cp += 0x10000;
 392   } else if (cp >= 0xdc00 && cp <= 0xdfff) {
 393     jsondec_err(d, "Unpaired low surrogate");
 394   }
 395
 396   /* Write to UTF-8 */
 397   if (cp <= 0x7f) {
 398     out[0] = cp;
 399     return 1;
 400   } else if (cp <= 0x07FF) {
 401     out[0] = ((cp >> 6) & 0x1F) | 0xC0;
 402     out[1] = ((cp >> 0) & 0x3F) | 0x80;
 403     return 2;
 404   } else if (cp <= 0xFFFF) {
 405     out[0] = ((cp >> 12) & 0x0F) | 0xE0;
 406     out[1] = ((cp >> 6) & 0x3F) | 0x80;
 407     out[2] = ((cp >> 0) & 0x3F) | 0x80;
 408     return 3;
 409   } else if (cp < 0x10FFFF) {
 410     out[0] = ((cp >> 18) & 0x07) | 0xF0;
 411     out[1] = ((cp >> 12) & 0x3f) | 0x80;
 412     out[2] = ((cp >> 6) & 0x3f) | 0x80;
 413     out[3] = ((cp >> 0) & 0x3f) | 0x80;
 414     return 4;
 415   } else {
 416     jsondec_err(d, "Invalid codepoint");
 417   }
 418 }
 419
 420 static void jsondec_resize(jsondec *d, char **buf, char **end, char **buf_end) {
 421   size_t oldsize = *buf_end - *buf;
 422   size_t len = *end - *buf;
 423   size_t size = UPB_MAX(8, 2 * oldsize);
 424
 425   *buf = upb_arena_realloc(d->arena, *buf, len, size);
 426   if (!*buf) jsondec_err(d, "Out of memory");
 427
 428   *end = *buf + len;
 429   *buf_end = *buf + size;
 430 }
 431
 432 static upb_strview jsondec_string(jsondec *d) {
 433   char *buf = NULL;
 434   char *end = NULL;
 435   char *buf_end = NULL;
 436
 437   jsondec_skipws(d);
 438
 439   if (*d->ptr++ != '"') {
 440     jsondec_err(d, "Expected string");
 441   }
 442
 443   while (d->ptr < d->end) {
 444     char ch = *d->ptr++;
 445
 446     if (end == buf_end) {
 447       jsondec_resize(d, &buf, &end, &buf_end);
 448     }
 449
 450     switch (ch) {
 451       case '"': {
 452         upb_strview ret;
 453         ret.data = buf;
 454         ret.size = end - buf;
 455         *end = '\0';  /* Needed for possible strtod(). */
 456         return ret;
 457       }
 458       case '\\':
 459         if (d->ptr == d->end) goto eof;
 460         if (*d->ptr == 'u') {
 461           d->ptr++;
 462           if (buf_end - end < 4) {
 463             /* Allow space for maximum-sized code point (4 bytes). */
 464             jsondec_resize(d, &buf, &end, &buf_end);
 465           }
 466           end += jsondec_unicode(d, end);
 467         } else {
 468           *end++ = jsondec_escape(d);
 469         }
 470         break;
 471       default:
 472         if ((unsigned char)*d->ptr < 0x20) {
 473           jsondec_err(d, "Invalid char in JSON string");
 474         }
 475         *end++ = ch;
 476         break;
 477     }
 478   }
 479
 480 eof:
 481   jsondec_err(d, "EOF inside string");
 482 }
 483
 484 static void jsondec_skipval(jsondec *d) {
 485   switch (jsondec_peek(d)) {
 486     case JD_OBJECT:
 487       jsondec_objstart(d);
 488       while (jsondec_objnext(d)) {
 489         jsondec_string(d);
 490         jsondec_entrysep(d);
 491         jsondec_skipval(d);
 492       }
 493       jsondec_objend(d);
 494       break;
 495     case JD_ARRAY:
 496       jsondec_arrstart(d);
 497       while (jsondec_arrnext(d)) {
 498         jsondec_skipval(d);
 499       }
 500       jsondec_arrend(d);
 501       break;
 502     case JD_TRUE:
 503       jsondec_true(d);
 504       break;
 505     case JD_FALSE:
 506       jsondec_false(d);
 507       break;
 508     case JD_NULL:
 509       jsondec_null(d);
 510       break;
 511     case JD_STRING:
 512       jsondec_string(d);
 513       break;
 514     case JD_NUMBER:
 515       jsondec_number(d);
 516       break;
 517   }
 518 }
 519
 520 /* Base64 decoding for bytes fields. ******************************************/
 521
 522 static unsigned int jsondec_base64_tablelookup(const char ch) {
 523   /* Table includes the normal base64 chars plus the URL-safe variant. */
 524   const signed char table[256] = {
 525       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 526       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 527       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 528       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 529       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 530       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 531       -1,       62 /*+*/, -1,       62 /*-*/, -1,       63 /*/ */, 52 /*0*/,
 532       53 /*1*/, 54 /*2*/, 55 /*3*/, 56 /*4*/, 57 /*5*/, 58 /*6*/,  59 /*7*/,
 533       60 /*8*/, 61 /*9*/, -1,       -1,       -1,       -1,        -1,
 534       -1,       -1,       0 /*A*/,  1 /*B*/,  2 /*C*/,  3 /*D*/,   4 /*E*/,
 535       5 /*F*/,  6 /*G*/,  07 /*H*/, 8 /*I*/,  9 /*J*/,  10 /*K*/,  11 /*L*/,
 536       12 /*M*/, 13 /*N*/, 14 /*O*/, 15 /*P*/, 16 /*Q*/, 17 /*R*/,  18 /*S*/,
 537       19 /*T*/, 20 /*U*/, 21 /*V*/, 22 /*W*/, 23 /*X*/, 24 /*Y*/,  25 /*Z*/,
 538       -1,       -1,       -1,       -1,       63 /*_*/, -1,        26 /*a*/,
 539       27 /*b*/, 28 /*c*/, 29 /*d*/, 30 /*e*/, 31 /*f*/, 32 /*g*/,  33 /*h*/,
 540       34 /*i*/, 35 /*j*/, 36 /*k*/, 37 /*l*/, 38 /*m*/, 39 /*n*/,  40 /*o*/,
 541       41 /*p*/, 42 /*q*/, 43 /*r*/, 44 /*s*/, 45 /*t*/, 46 /*u*/,  47 /*v*/,
 542       48 /*w*/, 49 /*x*/, 50 /*y*/, 51 /*z*/, -1,       -1,        -1,
 543       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 544       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 545       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 546       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 547       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 548       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 549       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 550       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 551       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 552       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 553       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 554       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 555       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 556       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 557       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 558       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 559       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 560       -1,       -1,       -1,       -1,       -1,       -1,        -1,
 561       -1,       -1,       -1,       -1};
 562
 563   /* Sign-extend return value so high bit will be set on any unexpected char. */
 564   return table[(unsigned)ch];
 565 }
 566
 567 static char *jsondec_partialbase64(jsondec *d, const char *ptr, const char *end,
 568                                    char *out) {
 569   int32_t val = -1;
 570
 571   switch (end - ptr) {
 572     case 2:
 573       val = jsondec_base64_tablelookup(ptr[0]) << 18 |
 574             jsondec_base64_tablelookup(ptr[1]) << 12;
 575       out[0] = val >> 16;
 576       out += 1;
 577       break;
 578     case 3:
 579       val = jsondec_base64_tablelookup(ptr[0]) << 18 |
 580             jsondec_base64_tablelookup(ptr[1]) << 12 |
 581             jsondec_base64_tablelookup(ptr[2]) << 6;
 582       out[0] = val >> 16;
 583       out[1] = (val >> 8) & 0xff;
 584       out += 2;
 585       break;
 586   }
 587
 588   if (val < 0) {
 589     jsondec_err(d, "Corrupt base64");
 590   }
 591
 592   return out;
 593 }
 594
 595 static size_t jsondec_base64(jsondec *d, upb_strview str) {
 596   /* We decode in place. This is safe because this is a new buffer (not
 597    * aliasing the input) and because base64 decoding shrinks 4 bytes into 3. */
 598   char *out = (char*)str.data;
 599   const char *ptr = str.data;
 600   const char *end = ptr + str.size;
 601   const char *end4 = ptr + (str.size & -4);  /* Round down to multiple of 4. */
 602
 603   for (; ptr < end4; ptr += 4, out += 3) {
 604     int val = jsondec_base64_tablelookup(ptr[0]) << 18 |
 605               jsondec_base64_tablelookup(ptr[1]) << 12 |
 606               jsondec_base64_tablelookup(ptr[2]) << 6 |
 607               jsondec_base64_tablelookup(ptr[3]) << 0;
 608
 609     if (val < 0) {
 610       /* Junk chars or padding. Remove trailing padding, if any. */
 611       if (end - ptr == 4 && ptr[3] == '=') {
 612         if (ptr[2] == '=') {
 613           end -= 2;
 614         } else {
 615           end -= 1;
 616         }
 617       }
 618       break;
 619     }
 620
 621     out[0] = val >> 16;
 622     out[1] = (val >> 8) & 0xff;
 623     out[2] = val & 0xff;
 624   }
 625
 626   if (ptr < end) {
 627     /* Process remaining chars. We do not require padding. */
 628     out = jsondec_partialbase64(d, ptr, end, out);
 629   }
 630
 631   return out - str.data;
 632 }
 633
 634 /* Low-level integer parsing **************************************************/
 635
 636 /* We use these hand-written routines instead of strto[u]l() because the "long
 637  * long" variants aren't in c89. Also our version allows setting a ptr limit. */
 638
 639 static const char *jsondec_buftouint64(jsondec *d, const char *ptr,
 640                                        const char *end, uint64_t *val) {
 641   uint64_t u64 = 0;
 642   while (ptr < end) {
 643     unsigned ch = *ptr - '0';
 644     if (ch >= 10) break;
 645     if (u64 > UINT64_MAX / 10 || u64 * 10 > UINT64_MAX - ch) {
 646       jsondec_err(d, "Integer overflow");
 647     }
 648     u64 *= 10;
 649     u64 += ch;
 650     ptr++;
 651   }
 652
 653   *val = u64;
 654   return ptr;
 655 }
 656
 657 static const char *jsondec_buftoint64(jsondec *d, const char *ptr,
 658                                       const char *end, int64_t *val) {
 659   bool neg = false;
 660   uint64_t u64;
 661
 662   if (ptr != end && *ptr == '-') {
 663     ptr++;
 664     neg = true;
 665   }
 666
 667   ptr = jsondec_buftouint64(d, ptr, end, &u64);
 668   if (u64 > (uint64_t)INT64_MAX + neg) {
 669     jsondec_err(d, "Integer overflow");
 670   }
 671
 672   *val = neg ? -u64 : u64;
 673   return ptr;
 674 }
 675
 676 static uint64_t jsondec_strtouint64(jsondec *d, upb_strview str) {
 677   const char *end = str.data + str.size;
 678   uint64_t ret;
 679   if (jsondec_buftouint64(d, str.data, end, &ret) != end) {
 680     jsondec_err(d, "Non-number characters in quoted integer");
 681   }
 682   return ret;
 683 }
 684
 685 static int64_t jsondec_strtoint64(jsondec *d, upb_strview str) {
 686   const char *end = str.data + str.size;
 687   int64_t ret;
 688   if (jsondec_buftoint64(d, str.data, end, &ret) != end) {
 689     jsondec_err(d, "Non-number characters in quoted integer");
 690   }
 691   return ret;
 692 }
 693
 694 /* Primitive value types ******************************************************/
 695
 696 /* Parse INT32 or INT64 value. */
 697 static upb_msgval jsondec_int(jsondec *d, const upb_fielddef *f) {
 698   upb_msgval val;
 699
 700   switch (jsondec_peek(d)) {
 701     case JD_NUMBER: {
 702       double dbl = jsondec_number(d);
 703       if (dbl > 9223372036854774784.0 || dbl < -9223372036854775808.0) {
 704         jsondec_err(d, "JSON number is out of range.");
 705       }
 706       val.int64_val = dbl;  /* must be guarded, overflow here is UB */
 707       if (val.int64_val != dbl) {
 708         jsondec_errf(d, "JSON number was not integral (%f != %" PRId64 ")", dbl,
 709                      val.int64_val);
 710       }
 711       break;
 712     }
 713     case JD_STRING: {
 714       upb_strview str = jsondec_string(d);
 715       val.int64_val = jsondec_strtoint64(d, str);
 716       break;
 717     }
 718     default:
 719       jsondec_err(d, "Expected number or string");
 720   }
 721
 722   if (upb_fielddef_type(f) == UPB_TYPE_INT32) {
 723     if (val.int64_val > INT32_MAX || val.int64_val < INT32_MIN) {
 724       jsondec_err(d, "Integer out of range.");
 725     }
 726     val.int32_val = (int32_t)val.int64_val;
 727   }
 728
 729   return val;
 730 }
 731
 732 /* Parse UINT32 or UINT64 value. */
 733 static upb_msgval jsondec_uint(jsondec *d, const upb_fielddef *f) {
 734   upb_msgval val = {0};
 735
 736   switch (jsondec_peek(d)) {
 737     case JD_NUMBER: {
 738       double dbl = jsondec_number(d);
 739       if (dbl > 18446744073709549568.0 || dbl < 0) {
 740         jsondec_err(d, "JSON number is out of range.");
 741       }
 742       val.uint64_val = dbl;  /* must be guarded, overflow here is UB */
 743       if (val.uint64_val != dbl) {
 744         jsondec_errf(d, "JSON number was not integral (%f != %" PRIu64 ")", dbl,
 745                      val.uint64_val);
 746       }
 747       break;
 748     }
 749     case JD_STRING: {
 750       upb_strview str = jsondec_string(d);
 751       val.uint64_val = jsondec_strtouint64(d, str);
 752       break;
 753     }
 754     default:
 755       jsondec_err(d, "Expected number or string");
 756   }
 757
 758   if (upb_fielddef_type(f) == UPB_TYPE_UINT32) {
 759     if (val.uint64_val > UINT32_MAX) {
 760       jsondec_err(d, "Integer out of range.");
 761     }
 762     val.uint32_val = (uint32_t)val.uint64_val;
 763   }
 764
 765   return val;
 766 }
 767
 768 /* Parse DOUBLE or FLOAT value. */
 769 static upb_msgval jsondec_double(jsondec *d, const upb_fielddef *f) {
 770   upb_strview str;
 771   upb_msgval val = {0};
 772
 773   switch (jsondec_peek(d)) {
 774     case JD_NUMBER:
 775       val.double_val = jsondec_number(d);
 776       break;
 777     case JD_STRING:
 778       str = jsondec_string(d);
 779       if (jsondec_streql(str, "NaN")) {
 780         val.double_val = NAN;
 781       } else if (jsondec_streql(str, "Infinity")) {
 782         val.double_val = INFINITY;
 783       } else if (jsondec_streql(str, "-Infinity")) {
 784         val.double_val = -INFINITY;
 785       } else {
 786         val.double_val = strtod(str.data, NULL);
 787       }
 788       break;
 789     default:
 790       jsondec_err(d, "Expected number or string");
 791   }
 792
 793   if (upb_fielddef_type(f) == UPB_TYPE_FLOAT) {
 794     if (val.double_val != INFINITY && val.double_val != -INFINITY &&
 795         (val.double_val > FLT_MAX || val.double_val < -FLT_MAX)) {
 796       jsondec_err(d, "Float out of range");
 797     }
 798     val.float_val = val.double_val;
 799   }
 800
 801   return val;
 802 }
 803
 804 /* Parse STRING or BYTES value. */
 805 static upb_msgval jsondec_strfield(jsondec *d, const upb_fielddef *f) {
 806   upb_msgval val;
 807   val.str_val = jsondec_string(d);
 808   if (upb_fielddef_type(f) == UPB_TYPE_BYTES) {
 809     val.str_val.size = jsondec_base64(d, val.str_val);
 810   }
 811   return val;
 812 }
 813
 814 static upb_msgval jsondec_enum(jsondec *d, const upb_fielddef *f) {
 815   switch (jsondec_peek(d)) {
 816     case JD_STRING: {
 817       const upb_enumdef *e = upb_fielddef_enumsubdef(f);
 818       upb_strview str = jsondec_string(d);
 819       upb_msgval val;
 820       if (!upb_enumdef_ntoi(e, str.data, str.size, &val.int32_val)) {
 821         if (d->options & UPB_JSONDEC_IGNOREUNKNOWN) {
 822           val.int32_val = 0;
 823         } else {
 824           jsondec_errf(d, "Unknown enumerator: '" UPB_STRVIEW_FORMAT "'",
 825                        UPB_STRVIEW_ARGS(str));
 826         }
 827       }
 828       return val;
 829     }
 830     case JD_NULL: {
 831       if (jsondec_isnullvalue(f)) {
 832         upb_msgval val;
 833         jsondec_null(d);
 834         val.int32_val = 0;
 835         return val;
 836       }
 837     }
 838       /* Fallthrough. */
 839     default:
 840       return jsondec_int(d, f);
 841   }
 842 }
 843
 844 static upb_msgval jsondec_bool(jsondec *d, const upb_fielddef *f) {
 845   bool is_map_key = upb_fielddef_number(f) == 1 &&
 846                     upb_msgdef_mapentry(upb_fielddef_containingtype(f));
 847   upb_msgval val;
 848
 849   if (is_map_key) {
 850     upb_strview str = jsondec_string(d);
 851     if (jsondec_streql(str, "true")) {
 852       val.bool_val = true;
 853     } else if (jsondec_streql(str, "false")) {
 854       val.bool_val = false;
 855     } else {
 856       jsondec_err(d, "Invalid boolean map key");
 857     }
 858   } else {
 859     switch (jsondec_peek(d)) {
 860       case JD_TRUE:
 861         val.bool_val = true;
 862         jsondec_true(d);
 863         break;
 864       case JD_FALSE:
 865         val.bool_val = false;
 866         jsondec_false(d);
 867         break;
 868       default:
 869         jsondec_err(d, "Expected true or false");
 870     }
 871   }
 872
 873   return val;
 874 }
 875
 876 /* Composite types (array/message/map) ****************************************/
 877
 878 static void jsondec_array(jsondec *d, upb_msg *msg, const upb_fielddef *f) {
 879   upb_array *arr = upb_msg_mutable(msg, f, d->arena).array;
 880
 881   jsondec_arrstart(d);
 882   while (jsondec_arrnext(d)) {
 883     upb_msgval elem = jsondec_value(d, f);
 884     upb_array_append(arr, elem, d->arena);
 885   }
 886   jsondec_arrend(d);
 887 }
 888
 889 static void jsondec_map(jsondec *d, upb_msg *msg, const upb_fielddef *f) {
 890   upb_map *map = upb_msg_mutable(msg, f, d->arena).map;
 891   const upb_msgdef *entry = upb_fielddef_msgsubdef(f);
 892   const upb_fielddef *key_f = upb_msgdef_itof(entry, 1);
 893   const upb_fielddef *val_f = upb_msgdef_itof(entry, 2);
 894
 895   jsondec_objstart(d);
 896   while (jsondec_objnext(d)) {
 897     upb_msgval key, val;
 898     key = jsondec_value(d, key_f);
 899     jsondec_entrysep(d);
 900     val = jsondec_value(d, val_f);
 901     upb_map_set(map, key, val, d->arena);
 902   }
 903   jsondec_objend(d);
 904 }
 905
 906 static void jsondec_tomsg(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
 907   if (upb_msgdef_wellknowntype(m) == UPB_WELLKNOWN_UNSPECIFIED) {
 908     jsondec_object(d, msg, m);
 909   } else {
 910     jsondec_wellknown(d, msg, m);
 911   }
 912 }
 913
 914 static upb_msgval jsondec_msg(jsondec *d, const upb_fielddef *f) {
 915   const upb_msgdef *m = upb_fielddef_msgsubdef(f);
 916   upb_msg *msg = upb_msg_new(m, d->arena);
 917   upb_msgval val;
 918
 919   jsondec_tomsg(d, msg, m);
 920   val.msg_val = msg;
 921   return val;
 922 }
 923
 924 static void jsondec_field(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
 925   upb_strview name;
 926   const upb_fielddef *f;
 927   const upb_fielddef *preserved;
 928
 929   name = jsondec_string(d);
 930   jsondec_entrysep(d);
 931   f = upb_msgdef_lookupjsonname(m, name.data, name.size);
 932
 933   if (!f) {
 934     if ((d->options & UPB_JSONDEC_IGNOREUNKNOWN) == 0) {
 935       jsondec_errf(d, "No such field: " UPB_STRVIEW_FORMAT,
 936                    UPB_STRVIEW_ARGS(name));
 937     }
 938     jsondec_skipval(d);
 939     return;
 940   }
 941
 942   if (jsondec_peek(d) == JD_NULL && !jsondec_isvalue(f)) {
 943     /* JSON "null" indicates a default value, so no need to set anything. */
 944     jsondec_null(d);
 945     return;
 946   }
 947
 948   if (upb_fielddef_realcontainingoneof(f) &&
 949       upb_msg_whichoneof(msg, upb_fielddef_containingoneof(f))) {
 950     jsondec_err(d, "More than one field for this oneof.");
 951   }
 952
 953   preserved = d->debug_field;
 954   d->debug_field = f;
 955
 956   if (upb_fielddef_ismap(f)) {
 957     jsondec_map(d, msg, f);
 958   } else if (upb_fielddef_isseq(f)) {
 959     jsondec_array(d, msg, f);
 960   } else if (upb_fielddef_issubmsg(f)) {
 961     upb_msg *submsg = upb_msg_mutable(msg, f, d->arena).msg;
 962     const upb_msgdef *subm = upb_fielddef_msgsubdef(f);
 963     jsondec_tomsg(d, submsg, subm);
 964   } else {
 965     upb_msgval val = jsondec_value(d, f);
 966     upb_msg_set(msg, f, val, d->arena);
 967   }
 968
 969   d->debug_field = preserved;
 970 }
 971
 972 static void jsondec_object(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
 973   jsondec_objstart(d);
 974   while (jsondec_objnext(d)) {
 975     jsondec_field(d, msg, m);
 976   }
 977   jsondec_objend(d);
 978 }
 979
 980 static upb_msgval jsondec_value(jsondec *d, const upb_fielddef *f) {
 981   switch (upb_fielddef_type(f)) {
 982     case UPB_TYPE_BOOL:
 983       return jsondec_bool(d, f);
 984     case UPB_TYPE_FLOAT:
 985     case UPB_TYPE_DOUBLE:
 986       return jsondec_double(d, f);
 987     case UPB_TYPE_UINT32:
 988     case UPB_TYPE_UINT64:
 989       return jsondec_uint(d, f);
 990     case UPB_TYPE_INT32:
 991     case UPB_TYPE_INT64:
 992       return jsondec_int(d, f);
 993     case UPB_TYPE_STRING:
 994     case UPB_TYPE_BYTES:
 995       return jsondec_strfield(d, f);
 996     case UPB_TYPE_ENUM:
 997       return jsondec_enum(d, f);
 998     case UPB_TYPE_MESSAGE:
 999       return jsondec_msg(d, f);
1000     default:
1001       UPB_UNREACHABLE();
1002   }
1003 }
1004
1005 /* Well-known types ***********************************************************/
1006
1007 static int jsondec_tsdigits(jsondec *d, const char **ptr, size_t digits,
1008                             const char *after) {
1009   uint64_t val;
1010   const char *p = *ptr;
1011   const char *end = p + digits;
1012   size_t after_len = after ? strlen(after) : 0;
1013
1014   UPB_ASSERT(digits <= 9);  /* int can't overflow. */
1015
1016   if (jsondec_buftouint64(d, p, end, &val) != end ||
1017       (after_len && memcmp(end, after, after_len) != 0)) {
1018     jsondec_err(d, "Malformed timestamp");
1019   }
1020
1021   UPB_ASSERT(val < INT_MAX);
1022
1023   *ptr = end + after_len;
1024   return (int)val;
1025 }
1026
1027 static int jsondec_nanos(jsondec *d, const char **ptr, const char *end) {
1028   uint64_t nanos = 0;
1029   const char *p = *ptr;
1030
1031   if (p != end && *p == '.') {
1032     const char *nano_end = jsondec_buftouint64(d, p + 1, end, &nanos);
1033     int digits = (int)(nano_end - p - 1);
1034     int exp_lg10 = 9 - digits;
1035     if (digits > 9) {
1036       jsondec_err(d, "Too many digits for partial seconds");
1037     }
1038     while (exp_lg10--) nanos *= 10;
1039     *ptr = nano_end;
1040   }
1041
1042   UPB_ASSERT(nanos < INT_MAX);
1043
1044   return (int)nanos;
1045 }
1046
1047 /* jsondec_epochdays(1970, 1, 1) == 1970-01-01 == 0. */
1048 int jsondec_epochdays(int y, int m, int d) {
1049   const uint32_t year_base = 4800;    /* Before min year, multiple of 400. */
1050   const uint32_t m_adj = m - 3;       /* March-based month. */
1051   const uint32_t carry = m_adj > (uint32_t)m ? 1 : 0;
1052   const uint32_t adjust = carry ? 12 : 0;
1053   const uint32_t y_adj = y + year_base - carry;
1054   const uint32_t month_days = ((m_adj + adjust) * 62719 + 769) / 2048;
1055   const uint32_t leap_days = y_adj / 4 - y_adj / 100 + y_adj / 400;
1056   return y_adj * 365 + leap_days + month_days + (d - 1) - 2472632;
1057 }
1058
1059 static int64_t jsondec_unixtime(int y, int m, int d, int h, int min, int s) {
1060   return (int64_t)jsondec_epochdays(y, m, d) * 86400 + h * 3600 + min * 60 + s;
1061 }
1062
1063 static void jsondec_timestamp(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
1064   upb_msgval seconds;
1065   upb_msgval nanos;
1066   upb_strview str = jsondec_string(d);
1067   const char *ptr = str.data;
1068   const char *end = ptr + str.size;
1069
1070   if (str.size < 20) goto malformed;
1071
1072   {
1073     /* 1972-01-01T01:00:00 */
1074     int year = jsondec_tsdigits(d, &ptr, 4, "-");
1075     int mon = jsondec_tsdigits(d, &ptr, 2, "-");
1076     int day = jsondec_tsdigits(d, &ptr, 2, "T");
1077     int hour = jsondec_tsdigits(d, &ptr, 2, ":");
1078     int min = jsondec_tsdigits(d, &ptr, 2, ":");
1079     int sec = jsondec_tsdigits(d, &ptr, 2, NULL);
1080
1081     seconds.int64_val = jsondec_unixtime(year, mon, day, hour, min, sec);
1082   }
1083
1084   nanos.int32_val = jsondec_nanos(d, &ptr, end);
1085
1086   {
1087     /* [+-]08:00 or Z */
1088     int ofs_hour = 0;
1089     int ofs_min = 0;
1090     bool neg = false;
1091
1092     if (ptr == end) goto malformed;
1093
1094     switch (*ptr++) {
1095       case '-':
1096         neg = true;
1097         /* fallthrough */
1098       case '+':
1099         if ((end - ptr) != 5) goto malformed;
1100         ofs_hour = jsondec_tsdigits(d, &ptr, 2, ":");
1101         ofs_min = jsondec_tsdigits(d, &ptr, 2, NULL);
1102         ofs_min = ((ofs_hour * 60) + ofs_min) * 60;
1103         seconds.int64_val += (neg ? ofs_min : -ofs_min);
1104         break;
1105       case 'Z':
1106         if (ptr != end) goto malformed;
1107         break;
1108       default:
1109         goto malformed;
1110     }
1111   }
1112
1113   if (seconds.int64_val < -62135596800) {
1114     jsondec_err(d, "Timestamp out of range");
1115   }
1116
1117   upb_msg_set(msg, upb_msgdef_itof(m, 1), seconds, d->arena);
1118   upb_msg_set(msg, upb_msgdef_itof(m, 2), nanos, d->arena);
1119   return;
1120
1121 malformed:
1122   jsondec_err(d, "Malformed timestamp");
1123 }
1124
1125 static void jsondec_duration(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
1126   upb_msgval seconds;
1127   upb_msgval nanos;
1128   upb_strview str = jsondec_string(d);
1129   const char *ptr = str.data;
1130   const char *end = ptr + str.size;
1131   const int64_t max = (uint64_t)3652500 * 86400;
1132
1133   /* "3.000000001s", "3s", etc. */
1134   ptr = jsondec_buftoint64(d, ptr, end, &seconds.int64_val);
1135   nanos.int32_val = jsondec_nanos(d, &ptr, end);
1136
1137   if (end - ptr != 1 || *ptr != 's') {
1138     jsondec_err(d, "Malformed duration");
1139   }
1140
1141   if (seconds.int64_val < -max || seconds.int64_val > max) {
1142     jsondec_err(d, "Duration out of range");
1143   }
1144
1145   if (seconds.int64_val < 0) {
1146     nanos.int32_val = - nanos.int32_val;
1147   }
1148
1149   upb_msg_set(msg, upb_msgdef_itof(m, 1), seconds, d->arena);
1150   upb_msg_set(msg, upb_msgdef_itof(m, 2), nanos, d->arena);
1151 }
1152
1153 static void jsondec_listvalue(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
1154   const upb_fielddef *values_f = upb_msgdef_itof(m, 1);
1155   const upb_msgdef *value_m = upb_fielddef_msgsubdef(values_f);
1156   upb_array *values = upb_msg_mutable(msg, values_f, d->arena).array;
1157
1158   jsondec_arrstart(d);
1159   while (jsondec_arrnext(d)) {
1160     upb_msg *value_msg = upb_msg_new(value_m, d->arena);
1161     upb_msgval value;
1162     value.msg_val = value_msg;
1163     upb_array_append(values, value, d->arena);
1164     jsondec_wellknownvalue(d, value_msg, value_m);
1165   }
1166   jsondec_arrend(d);
1167 }
1168
1169 static void jsondec_struct(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
1170   const upb_fielddef *fields_f = upb_msgdef_itof(m, 1);
1171   const upb_msgdef *entry_m = upb_fielddef_msgsubdef(fields_f);
1172   const upb_fielddef *value_f = upb_msgdef_itof(entry_m, 2);
1173   const upb_msgdef *value_m = upb_fielddef_msgsubdef(value_f);
1174   upb_map *fields = upb_msg_mutable(msg, fields_f, d->arena).map;
1175
1176   jsondec_objstart(d);
1177   while (jsondec_objnext(d)) {
1178     upb_msgval key, value;
1179     upb_msg *value_msg = upb_msg_new(value_m, d->arena);
1180     key.str_val = jsondec_string(d);
1181     value.msg_val = value_msg;
1182     upb_map_set(fields, key, value, d->arena);
1183     jsondec_entrysep(d);
1184     jsondec_wellknownvalue(d, value_msg, value_m);
1185   }
1186   jsondec_objend(d);
1187 }
1188
1189 static void jsondec_wellknownvalue(jsondec *d, upb_msg *msg,
1190                                    const upb_msgdef *m) {
1191   upb_msgval val;
1192   const upb_fielddef *f;
1193   upb_msg *submsg;
1194
1195   switch (jsondec_peek(d)) {
1196     case JD_NUMBER:
1197       /* double number_value = 2; */
1198       f = upb_msgdef_itof(m, 2);
1199       val.double_val = jsondec_number(d);
1200       break;
1201     case JD_STRING:
1202       /* string string_value = 3; */
1203       f = upb_msgdef_itof(m, 3);
1204       val.str_val = jsondec_string(d);
1205       break;
1206     case JD_FALSE:
1207       /* bool bool_value = 4; */
1208       f = upb_msgdef_itof(m, 4);
1209       val.bool_val = false;
1210       jsondec_false(d);
1211       break;
1212     case JD_TRUE:
1213       /* bool bool_value = 4; */
1214       f = upb_msgdef_itof(m, 4);
1215       val.bool_val = true;
1216       jsondec_true(d);
1217       break;
1218     case JD_NULL:
1219       /* NullValue null_value = 1; */
1220       f = upb_msgdef_itof(m, 1);
1221       val.int32_val = 0;
1222       jsondec_null(d);
1223       break;
1224     /* Note: these cases return, because upb_msg_mutable() is enough. */
1225     case JD_OBJECT:
1226       /* Struct struct_value = 5; */
1227       f = upb_msgdef_itof(m, 5);
1228       submsg = upb_msg_mutable(msg, f, d->arena).msg;
1229       jsondec_struct(d, submsg, upb_fielddef_msgsubdef(f));
1230       return;
1231     case JD_ARRAY:
1232       /* ListValue list_value = 6; */
1233       f = upb_msgdef_itof(m, 6);
1234       submsg = upb_msg_mutable(msg, f, d->arena).msg;
1235       jsondec_listvalue(d, submsg, upb_fielddef_msgsubdef(f));
1236       return;
1237     default:
1238       UPB_UNREACHABLE();
1239   }
1240
1241   upb_msg_set(msg, f, val, d->arena);
1242 }
1243
1244 static upb_strview jsondec_mask(jsondec *d, const char *buf, const char *end) {
1245   /* FieldMask fields grow due to inserted '_' characters, so we can't do the
1246    * transform in place. */
1247   const char *ptr = buf;
1248   upb_strview ret;
1249   char *out;
1250
1251   ret.size = end - ptr;
1252   while (ptr < end) {
1253     ret.size += (*ptr >= 'A' && *ptr <= 'Z');
1254     ptr++;
1255   }
1256
1257   out = upb_arena_malloc(d->arena, ret.size);
1258   ptr = buf;
1259   ret.data = out;
1260
1261   while (ptr < end) {
1262     char ch = *ptr++;
1263     if (ch >= 'A' && ch <= 'Z') {
1264       *out++ = '_';
1265       *out++ = ch + 32;
1266     } else if (ch == '_') {
1267       jsondec_err(d, "field mask may not contain '_'");
1268     } else {
1269       *out++ = ch;
1270     }
1271   }
1272
1273   return ret;
1274 }
1275
1276 static void jsondec_fieldmask(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
1277   /* repeated string paths = 1; */
1278   const upb_fielddef *paths_f = upb_msgdef_itof(m, 1);
1279   upb_array *arr = upb_msg_mutable(msg, paths_f, d->arena).array;
1280   upb_strview str = jsondec_string(d);
1281   const char *ptr = str.data;
1282   const char *end = ptr + str.size;
1283   upb_msgval val;
1284
1285   while (ptr < end) {
1286     const char *elem_end = memchr(ptr, ',', end - ptr);
1287     if (elem_end) {
1288       val.str_val = jsondec_mask(d, ptr, elem_end);
1289       ptr = elem_end + 1;
1290     } else {
1291       val.str_val = jsondec_mask(d, ptr, end);
1292       ptr = end;
1293     }
1294     upb_array_append(arr, val, d->arena);
1295   }
1296 }
1297
1298 static void jsondec_anyfield(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
1299   if (upb_msgdef_wellknowntype(m) == UPB_WELLKNOWN_UNSPECIFIED) {
1300     /* For regular types: {"@type": "[user type]", "f1": <V1>, "f2": <V2>}
1301      * where f1, f2, etc. are the normal fields of this type. */
1302     jsondec_field(d, msg, m);
1303   } else {
1304     /* For well-known types: {"@type": "[well-known type]", "value": <X>}
1305      * where <X> is whatever encoding the WKT normally uses. */
1306     upb_strview str = jsondec_string(d);
1307     jsondec_entrysep(d);
1308     if (!jsondec_streql(str, "value")) {
1309       jsondec_err(d, "Key for well-known type must be 'value'");
1310     }
1311     jsondec_wellknown(d, msg, m);
1312   }
1313 }
1314
1315 static const upb_msgdef *jsondec_typeurl(jsondec *d, upb_msg *msg,
1316                                          const upb_msgdef *m) {
1317   const upb_fielddef *type_url_f = upb_msgdef_itof(m, 1);
1318   const upb_msgdef *type_m;
1319   upb_strview type_url = jsondec_string(d);
1320   const char *end = type_url.data + type_url.size;
1321   const char *ptr = end;
1322   upb_msgval val;
1323
1324   val.str_val = type_url;
1325   upb_msg_set(msg, type_url_f, val, d->arena);
1326
1327   /* Find message name after the last '/' */
1328   while (ptr > type_url.data && *--ptr != '/') {}
1329
1330   if (ptr == type_url.data || ptr == end) {
1331     jsondec_err(d, "Type url must have at least one '/' and non-empty host");
1332   }
1333
1334   ptr++;
1335   type_m = upb_symtab_lookupmsg2(d->any_pool, ptr, end - ptr);
1336
1337   if (!type_m) {
1338     jsondec_err(d, "Type was not found");
1339   }
1340
1341   return type_m;
1342 }
1343
1344 static void jsondec_any(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
1345   /* string type_url = 1;
1346    * bytes value = 2; */
1347   const upb_fielddef *value_f = upb_msgdef_itof(m, 2);
1348   upb_msg *any_msg;
1349   const upb_msgdef *any_m = NULL;
1350   const char *pre_type_data = NULL;
1351   const char *pre_type_end = NULL;
1352   upb_msgval encoded;
1353
1354   jsondec_objstart(d);
1355
1356   /* Scan looking for "@type", which is not necessarily first. */
1357   while (!any_m && jsondec_objnext(d)) {
1358     const char *start = d->ptr;
1359     upb_strview name = jsondec_string(d);
1360     jsondec_entrysep(d);
1361     if (jsondec_streql(name, "@type")) {
1362       any_m = jsondec_typeurl(d, msg, m);
1363       if (pre_type_data) {
1364         pre_type_end = start;
1365         while (*pre_type_end != ',') pre_type_end--;
1366       }
1367     } else {
1368       if (!pre_type_data) pre_type_data = start;
1369       jsondec_skipval(d);
1370     }
1371   }
1372
1373   if (!any_m) {
1374     jsondec_err(d, "Any object didn't contain a '@type' field");
1375   }
1376
1377   any_msg = upb_msg_new(any_m, d->arena);
1378
1379   if (pre_type_data) {
1380     size_t len = pre_type_end - pre_type_data + 1;
1381     char *tmp = upb_arena_malloc(d->arena, len);
1382     const char *saved_ptr = d->ptr;
1383     const char *saved_end = d->end;
1384     memcpy(tmp, pre_type_data, len - 1);
1385     tmp[len - 1] = '}';
1386     d->ptr = tmp;
1387     d->end = tmp + len;
1388     d->is_first = true;
1389     while (jsondec_objnext(d)) {
1390       jsondec_anyfield(d, any_msg, any_m);
1391     }
1392     d->ptr = saved_ptr;
1393     d->end = saved_end;
1394   }
1395
1396   while (jsondec_objnext(d)) {
1397     jsondec_anyfield(d, any_msg, any_m);
1398   }
1399
1400   jsondec_objend(d);
1401
1402   encoded.str_val.data = upb_encode(any_msg, upb_msgdef_layout(any_m), d->arena,
1403                                     &encoded.str_val.size);
1404   upb_msg_set(msg, value_f, encoded, d->arena);
1405 }
1406
1407 static void jsondec_wrapper(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
1408   const upb_fielddef *value_f = upb_msgdef_itof(m, 1);
1409   upb_msgval val = jsondec_value(d, value_f);
1410   upb_msg_set(msg, value_f, val, d->arena);
1411 }
1412
1413 static void jsondec_wellknown(jsondec *d, upb_msg *msg, const upb_msgdef *m) {
1414   switch (upb_msgdef_wellknowntype(m)) {
1415     case UPB_WELLKNOWN_ANY:
1416       jsondec_any(d, msg, m);
1417       break;
1418     case UPB_WELLKNOWN_FIELDMASK:
1419       jsondec_fieldmask(d, msg, m);
1420       break;
1421     case UPB_WELLKNOWN_DURATION:
1422       jsondec_duration(d, msg, m);
1423       break;
1424     case UPB_WELLKNOWN_TIMESTAMP:
1425       jsondec_timestamp(d, msg, m);
1426       break;
1427     case UPB_WELLKNOWN_VALUE:
1428       jsondec_wellknownvalue(d, msg, m);
1429       break;
1430     case UPB_WELLKNOWN_LISTVALUE:
1431       jsondec_listvalue(d, msg, m);
1432       break;
1433     case UPB_WELLKNOWN_STRUCT:
1434       jsondec_struct(d, msg, m);
1435       break;
1436     case UPB_WELLKNOWN_DOUBLEVALUE:
1437     case UPB_WELLKNOWN_FLOATVALUE:
1438     case UPB_WELLKNOWN_INT64VALUE:
1439     case UPB_WELLKNOWN_UINT64VALUE:
1440     case UPB_WELLKNOWN_INT32VALUE:
1441     case UPB_WELLKNOWN_UINT32VALUE:
1442     case UPB_WELLKNOWN_STRINGVALUE:
1443     case UPB_WELLKNOWN_BYTESVALUE:
1444     case UPB_WELLKNOWN_BOOLVALUE:
1445       jsondec_wrapper(d, msg, m);
1446       break;
1447     default:
1448       UPB_UNREACHABLE();
1449   }
1450 }
1451
1452 bool upb_json_decode(const char *buf, size_t size, upb_msg *msg,
1453                      const upb_msgdef *m, const upb_symtab *any_pool,
1454                      int options, upb_arena *arena, upb_status *status) {
1455   jsondec d;
1456
1457   if (size == 0) return true;
1458
1459   d.ptr = buf;
1460   d.end = buf + size;
1461   d.arena = arena;
1462   d.any_pool = any_pool;
1463   d.status = status;
1464   d.options = options;
1465   d.depth = 64;
1466   d.line = 1;
1467   d.line_begin = d.ptr;
1468   d.debug_field = NULL;
1469   d.is_first = false;
1470
1471   if (UPB_SETJMP(d.err)) return false;
1472
1473   jsondec_tomsg(&d, msg, m);
1474   return true;
1475 }