One Level Up Top Level

src/core/ngx_json_parse.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Maxim Dounin
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. /*
  9. * JSON parser. RFC 8259 for the JSON grammar.

  11. * Site http://json.org/ may be useful too.
  12. */


  15. #include <ngx_config.h>
  16. #include <ngx_core.h>
  17. #include <ngx_json_parse.h>


  20. ‌#define NGX_JSON_NOT_SKIPPING  (ngx_uint_t) -1
  21. ‌#define ngx_json_skipping(d)   ((d) != NGX_JSON_NOT_SKIPPING)
  22. ‌#define ngx_json_ws(c)  ((c) == ' ' || (c) == '\t' || (c) == CR || (c) == LF)


  25. static ngx_inline ngx_int_t ngx_json_end_number(ngx_json_ctx_t *ctx,
  26.     u_char *start, u_char *end, ngx_json_state_e *state);
  27. static ngx_inline ngx_int_t ngx_json_emit(ngx_json_ctx_t *ctx,
  28.     ngx_json_event_e event, u_char *data, size_t len);
  29. static ngx_inline ngx_json_state_e ngx_json_after_value(ngx_json_ctx_t *ctx);
  30. static ngx_inline ngx_int_t ngx_json_close(ngx_json_ctx_t *ctx,
  31.     ngx_json_event_e event, ngx_json_state_e *state, u_char *p);
  32. static ngx_int_t ngx_json_push_state(ngx_json_ctx_t *ctx,
  33.     ngx_json_container_e container);


  36. void
  37. ‌ngx_json_ctx_init(ngx_json_ctx_t *ctx, ngx_pool_t *pool)
  38. {
  39.     ctx->state = ngx_json_start;
  40.     ctx->pool = pool;
  41.     ctx->handler = NULL;
  42.     ctx->data = NULL;
  43.     ctx->codepoint = 0;
  44.     ctx->hex_left = 0;

  46.     ctx->depth = 0;
  47.     ctx->skip_until_depth = NGX_JSON_NOT_SKIPPING;
  48.     ctx->max_depth = NGX_JSON_DEFAULT_MAX_DEPTH;

  50.     /* stack is allocated lazily on first push, sized to max_depth */

  52.     ctx->stack = NULL;

  54.     ctx->in_key = 0;
  55.     ctx->escaped = 0;
  56. }


  59. ngx_int_t
  60. ‌ngx_json_parse_ctx(ngx_json_ctx_t *ctx, u_char *data, size_t len)
  61. {
  62.     u_char            *p, *last, *start;
  63.     ngx_int_t          rc, hd;
  64.     ngx_uint_t         skip_depth;
  65.     ngx_json_event_e   event;
  66.     ngx_json_state_e   state;

  68.     if (len == 0) {
  69.         return NGX_DECLINED;
  70.     }

  72.     if (data == NULL) {
  73.         return NGX_ERROR;
  74.     }

  76.     if (ctx->state == ngx_json_done) {
  77.         return NGX_DECLINED;
  78.     }

  80.     last = data + len;
  81.     state = ctx->state;
  82.     skip_depth = ctx->skip_until_depth;
  83.     start = NULL;

  85.     for (p = data; p < last; p++) {

  87.         /* skipping suppresses emission only; the machine still validates */

  89.         if (ngx_json_skipping(skip_depth) && ctx->depth <= skip_depth
  90.             && (state == ngx_json_object_value_separator
  91.                 || state == ngx_json_array_value_separator
  92.                 || state == ngx_json_done))
  93.         {
  94.             skip_depth = NGX_JSON_NOT_SKIPPING;
  95.             ctx->skip_until_depth = NGX_JSON_NOT_SKIPPING;
  96.             p--;

  98.             continue;
  99.         }

  101.         switch (state) {

  103.         case ngx_json_start:
  104.             if (ngx_json_ws(*p)) {
  105.                 break;
  106.             }

  108.             p--;
  109.             state = ngx_json_value;
  110.             break;

  112.         case ngx_json_object:
  113.             if (ngx_json_ws(*p)) {
  114.                 break;
  115.             }

  117.             if (*p == '}') {
  118.                 rc = ngx_json_close(ctx, NGX_JSON_OBJECT_CLOSE, &state, p);
  119.                 if (rc != NGX_OK) {
  120.                     return rc;
  121.                 }

  123.                 break;
  124.             }

  126.             /* fall through */

  128.         case ngx_json_object_next:
  129.             if (ngx_json_ws(*p)) {
  130.                 break;
  131.             }

  133.             if (*p == '"') {
  134.                 ctx->in_key = 1;
  135.                 ctx->escaped = 0;
  136.                 start = p + 1;
  137.                 state = ngx_json_string;
  138.                 break;
  139.             }

  141.             return NGX_DECLINED;

  143.         case ngx_json_object_name_separator:
  144.             if (ngx_json_ws(*p)) {
  145.                 break;
  146.             }

  148.             if (*p == ':') {
  149.                 state = ngx_json_value;
  150.                 break;
  151.             }

  153.             return NGX_DECLINED;

  155.         case ngx_json_object_value_separator:
  156.             if (ngx_json_ws(*p)) {
  157.                 break;
  158.             }

  160.             if (*p == ',') {
  161.                 state = ngx_json_object_next;
  162.                 break;
  163.             }

  165.             if (*p == '}') {
  166.                 rc = ngx_json_close(ctx, NGX_JSON_OBJECT_CLOSE, &state, p);
  167.                 if (rc != NGX_OK) {
  168.                     return rc;
  169.                 }

  171.                 break;
  172.             }

  174.             return NGX_DECLINED;

  176.         case ngx_json_array_value_separator:
  177.             if (ngx_json_ws(*p)) {
  178.                 break;
  179.             }

  181.             if (*p == ',') {
  182.                 state = ngx_json_value;
  183.                 break;
  184.             }

  186.             if (*p == ']') {
  187.                 rc = ngx_json_close(ctx, NGX_JSON_ARRAY_CLOSE, &state, p);
  188.                 if (rc != NGX_OK) {
  189.                     return rc;
  190.                 }

  192.                 break;
  193.             }

  195.             return NGX_DECLINED;

  197.         case ngx_json_array:
  198.             if (ngx_json_ws(*p)) {
  199.                 break;
  200.             }

  202.             if (*p == ']') {
  203.                 rc = ngx_json_close(ctx, NGX_JSON_ARRAY_CLOSE, &state, p);
  204.                 if (rc != NGX_OK) {
  205.                     return rc;
  206.                 }

  208.                 break;
  209.             }

  211.             /* fall through */

  213.         case ngx_json_value:
  214.             if (ngx_json_ws(*p)) {
  215.                 break;
  216.             }

  218.             start = p;

  220.             if (*p == '"') {
  221.                 ctx->in_key = 0;
  222.                 ctx->escaped = 0;
  223.                 start = p + 1;
  224.                 state = ngx_json_string;
  225.                 break;
  226.             }

  228.             if (*p == '{') {
  229.                 rc = ngx_json_emit(ctx, NGX_JSON_OBJECT_OPEN, p, 1);
  230.                 if (rc != NGX_OK) {
  231.                     return rc;
  232.                 }

  234.                 rc = ngx_json_push_state(ctx, ngx_json_ctx_object);
  235.                 if (rc != NGX_OK) {
  236.                     return rc;
  237.                 }

  239.                 state = ngx_json_object;
  240.                 break;
  241.             }

  243.             if (*p == '[') {
  244.                 rc = ngx_json_emit(ctx, NGX_JSON_ARRAY_OPEN, p, 1);
  245.                 if (rc != NGX_OK) {
  246.                     return rc;
  247.                 }

  249.                 rc = ngx_json_push_state(ctx, ngx_json_ctx_array);
  250.                 if (rc != NGX_OK) {
  251.                     return rc;
  252.                 }

  254.                 state = ngx_json_array;
  255.                 break;
  256.             }

  258.             if (*p == '-') {
  259.                 state = ngx_json_number_minus;
  260.                 break;
  261.             }

  263.             if (*p == '0') {
  264.                 state = ngx_json_number_int_zero;
  265.                 break;
  266.             }

  268.             if (*p >= '1' && *p <= '9') {
  269.                 state = ngx_json_number_int;
  270.                 break;
  271.             }

  273.             if (*p == 't') {
  274.                 state = ngx_json_true_t;
  275.                 break;
  276.             }

  278.             if (*p == 'f') {
  279.                 state = ngx_json_false_f;
  280.                 break;
  281.             }

  283.             if (*p == 'n') {
  284.                 state = ngx_json_null_n;
  285.                 break;
  286.             }

  288.             return NGX_DECLINED;

  290.         case ngx_json_string:
  291.             if (*p == '"') {

  293.                 if (ctx->in_key) {
  294.                     event = ctx->escaped ? NGX_JSON_KEY_ESCAPED
  295.                                          : NGX_JSON_KEY;

  297.                     rc = ngx_json_emit(ctx, event, start, p - start);
  298.                     if (rc != NGX_OK) {
  299.                         return rc;
  300.                     }

  302.                     ctx->in_key = 0;
  303.                     state = ngx_json_object_name_separator;

  305.                 } else {
  306.                     event = ctx->escaped ? NGX_JSON_VALUE_STRING_ESCAPED
  307.                                          : NGX_JSON_VALUE_STRING;

  309.                     rc = ngx_json_emit(ctx, event, start, p - start);
  310.                     if (rc != NGX_OK) {
  311.                         return rc;
  312.                     }

  314.                     state = ngx_json_after_value(ctx);
  315.                 }

  317.                 break;
  318.             }

  320.             if (*p == '\\') {
  321.                 ctx->escaped = 1;
  322.                 state = ngx_json_escaped;
  323.                 break;
  324.             }

  326.             if (*p < ' ') {
  327.                 return NGX_DECLINED;
  328.             }

  330.             break;

  332.         case ngx_json_escaped:
  333.             if (*p == '"' || *p == '\\' || *p == '/' || *p == 'b'
  334.                 || *p == 'f' || *p == 'n' || *p == 'r' || *p == 't')
  335.             {
  336.                 state = ngx_json_string;
  337.                 break;
  338.             }

  340.             if (*p == 'u') {
  341.                 ctx->codepoint = 0;
  342.                 ctx->hex_left = 4;
  343.                 state = ngx_json_escaped_hex;
  344.                 break;
  345.             }

  347.             return NGX_DECLINED;

  349.         case ngx_json_escaped_hex:

  351.             /* accumulate the four hex digits of the first \uXXXX escape */

  353.             hd = ngx_json_hex_digit(*p);
  354.             if (hd == NGX_ERROR) {
  355.                 return NGX_DECLINED;
  356.             }

  358.             ctx->codepoint = (ctx->codepoint << 4) | (uint32_t) hd;

  360.             if (--ctx->hex_left > 0) {
  361.                 break;
  362.             }

  364.             if (ctx->codepoint >= 0xD800 && ctx->codepoint <= 0xDBFF) {
  365.                 /* high surrogate - must be followed by \uDC00..\uDFFF */
  366.                 state = ngx_json_surrogate_start;
  367.                 break;
  368.             }

  370.             if (ctx->codepoint >= 0xDC00 && ctx->codepoint <= 0xDFFF) {
  371.                 /* lone low surrogate */
  372.                 return NGX_DECLINED;
  373.             }

  375.             state = ngx_json_string;
  376.             break;

  378.         case ngx_json_surrogate_start:
  379.             if (*p == '\\') {
  380.                 state = ngx_json_surrogate_u;
  381.                 break;
  382.             }

  384.             /* high surrogate not followed by \uXXXX */
  385.             return NGX_DECLINED;

  387.         case ngx_json_surrogate_u:
  388.             if (*p == 'u') {
  389.                 ctx->codepoint = 0;
  390.                 ctx->hex_left = 4;
  391.                 state = ngx_json_surrogate_hex;
  392.                 break;
  393.             }

  395.             /* high surrogate followed by non-\u escape */
  396.             return NGX_DECLINED;

  398.         case ngx_json_surrogate_hex:

  400.             /* accumulate the four hex digits of the low \uXXXX escape */

  402.             hd = ngx_json_hex_digit(*p);
  403.             if (hd == NGX_ERROR) {
  404.                 return NGX_DECLINED;
  405.             }

  407.             ctx->codepoint = (ctx->codepoint << 4) | (uint32_t) hd;

  409.             if (--ctx->hex_left > 0) {
  410.                 break;
  411.             }

  413.             if (ctx->codepoint >= 0xDC00 && ctx->codepoint <= 0xDFFF) {
  414.                 /* valid surrogate pair */
  415.                 state = ngx_json_string;
  416.                 break;
  417.             }

  419.             /* high surrogate not followed by low surrogate */
  420.             return NGX_DECLINED;

  422.         case ngx_json_number_minus:
  423.             if (*p >= '1' && *p <= '9') {
  424.                 state = ngx_json_number_int;
  425.                 break;
  426.             }

  428.             if (*p == '0') {
  429.                 state = ngx_json_number_int_zero;
  430.                 break;
  431.             }

  433.             return NGX_DECLINED;

  435.         case ngx_json_number_int_zero:
  436.             if (*p == '.') {
  437.                 state = ngx_json_number_frac;
  438.                 break;
  439.             }

  441.             if (*p == 'e' || *p == 'E') {
  442.                 /* No sense, but permitted by RFC */
  443.                 state = ngx_json_number_exp;
  444.                 break;
  445.             }

  447.             p--;

  449.             rc = ngx_json_end_number(ctx, start, p + 1, &state);
  450.             if (rc != NGX_OK) {
  451.                 return rc;
  452.             }

  454.             break;

  456.         case ngx_json_number_int:
  457.             if (*p >= '0' && *p <= '9') {
  458.                 break;
  459.             }

  461.             if (*p == '.') {
  462.                 state = ngx_json_number_frac;
  463.                 break;
  464.             }

  466.             if (*p == 'e' || *p == 'E') {
  467.                 /* No sense, but permitted by RFC */
  468.                 state = ngx_json_number_exp;
  469.                 break;
  470.             }

  472.             p--;

  474.             rc = ngx_json_end_number(ctx, start, p + 1, &state);
  475.             if (rc!= NGX_OK) {
  476.                 return rc;
  477.             }

  479.             break;

  481.         case ngx_json_number_frac:
  482.             if (*p >= '0' && *p <= '9') {
  483.                 state = ngx_json_number_frac_digit;
  484.                 break;
  485.             }

  487.             return NGX_DECLINED;

  489.         case ngx_json_number_frac_digit:
  490.             if (*p >= '0' && *p <= '9') {
  491.                 break;
  492.             }

  494.             if (*p == 'e' || *p == 'E') {
  495.                 state = ngx_json_number_exp;
  496.                 break;
  497.             }

  499.             p--;

  501.             rc = ngx_json_end_number(ctx, start, p + 1, &state);
  502.             if (rc != NGX_OK) {
  503.                 return rc;
  504.             }

  506.             break;

  508.         case ngx_json_number_exp:
  509.             if (*p == '-' || *p == '+') {
  510.                 state = ngx_json_number_exp_plusminus;
  511.                 break;
  512.             }

  514.             if (*p >= '0' && *p <= '9') {
  515.                 state = ngx_json_number_exp_digit;
  516.                 break;
  517.             }

  519.             return NGX_DECLINED;

  521.         case ngx_json_number_exp_plusminus:
  522.             if (*p >= '0' && *p <= '9') {
  523.                 state = ngx_json_number_exp_digit;
  524.                 break;
  525.             }

  527.             return NGX_DECLINED;

  529.         case ngx_json_number_exp_digit:
  530.             if (*p >= '0' && *p <= '9') {
  531.                 break;
  532.             }

  534.             p--;

  536.             rc = ngx_json_end_number(ctx, start, p + 1, &state);
  537.             if (rc != NGX_OK) {
  538.                 return rc;
  539.             }

  541.             break;

  543.         case ngx_json_true_t:
  544.             if (*p == 'r') {
  545.                 state = ngx_json_true_tr;
  546.                 break;
  547.             }

  549.             return NGX_DECLINED;

  551.         case ngx_json_true_tr:
  552.             if (*p == 'u') {
  553.                 state = ngx_json_true_tru;
  554.                 break;
  555.             }

  557.             return NGX_DECLINED;

  559.         case ngx_json_true_tru:
  560.             if (*p == 'e') {
  561.                 rc = ngx_json_emit(ctx, NGX_JSON_VALUE_BOOL, start,
  562.                                   p + 1 - start);
  563.                 if (rc != NGX_OK) {
  564.                     return rc;
  565.                 }

  567.                 state = ngx_json_after_value(ctx);
  568.                 break;
  569.             }

  571.             return NGX_DECLINED;

  573.         case ngx_json_false_f:
  574.             if (*p == 'a') {
  575.                 state = ngx_json_false_fa;
  576.                 break;
  577.             }

  579.             return NGX_DECLINED;

  581.         case ngx_json_false_fa:
  582.             if (*p == 'l') {
  583.                 state = ngx_json_false_fal;
  584.                 break;
  585.             }

  587.             return NGX_DECLINED;

  589.         case ngx_json_false_fal:
  590.             if (*p == 's') {
  591.                 state = ngx_json_false_fals;
  592.                 break;
  593.             }

  595.             return NGX_DECLINED;

  597.         case ngx_json_false_fals:
  598.             if (*p == 'e') {
  599.                 rc = ngx_json_emit(ctx, NGX_JSON_VALUE_BOOL, start,
  600.                                   p + 1 - start);
  601.                 if (rc != NGX_OK) {
  602.                     return rc;
  603.                 }

  605.                 state = ngx_json_after_value(ctx);
  606.                 break;
  607.             }

  609.             return NGX_DECLINED;

  611.         case ngx_json_null_n:
  612.             if (*p == 'u') {
  613.                 state = ngx_json_null_nu;
  614.                 break;
  615.             }

  617.             return NGX_DECLINED;

  619.         case ngx_json_null_nu:
  620.             if (*p == 'l') {
  621.                 state = ngx_json_null_nul;
  622.                 break;
  623.             }

  625.             return NGX_DECLINED;

  627.         case ngx_json_null_nul:
  628.             if (*p == 'l') {
  629.                 rc = ngx_json_emit(ctx, NGX_JSON_VALUE_NULL, start,
  630.                                   p + 1 - start);
  631.                 if (rc != NGX_OK) {
  632.                     return rc;
  633.                 }

  635.                 state = ngx_json_after_value(ctx);
  636.                 break;
  637.             }

  639.             return NGX_DECLINED;

  641.         case ngx_json_done:
  642.             if (ngx_json_ws(*p)) {
  643.                 break;
  644.             }

  646.             return NGX_DECLINED;
  647.         }

  649.         skip_depth = ctx->skip_until_depth;
  650.     }

  652.     /* a bare top-level number is not self-delimited; emit it at end of input */

  654.     if (ctx->depth == 0
  655.         && (state == ngx_json_number_int_zero
  656.             || state == ngx_json_number_int
  657.             || state == ngx_json_number_frac_digit
  658.             || state == ngx_json_number_exp_digit))
  659.     {
  660.         rc = ngx_json_emit(ctx, NGX_JSON_VALUE_NUMBER, start, last - start);
  661.         if (rc != NGX_OK) {
  662.             return rc;
  663.         }

  665.         state = ngx_json_done;
  666.     }

  668.     ctx->state = state;

  670.     if (state == ngx_json_done) {
  671.         return NGX_OK;
  672.     }

  674.     return NGX_DECLINED;
  675. }


  678. ngx_int_t
  679. ‌ngx_json_parse(ngx_pool_t *pool, ngx_str_t *json, ngx_json_handler_pt handler,
  680.     void *data)
  681. {
  682.     ngx_json_ctx_t  jctx;

  684.     ngx_json_ctx_init(&jctx, pool);

  686.     jctx.data = data;
  687.     jctx.handler = handler;

  689.     return ngx_json_parse_ctx(&jctx, json->data, json->len);
  690. }


  693. static ngx_inline ngx_int_t
  694. ‌ngx_json_end_number(ngx_json_ctx_t *ctx, u_char *start, u_char *end,
  695.     ngx_json_state_e *state)
  696. {
  697.     ngx_int_t  rc;

  699.     rc = ngx_json_emit(ctx, NGX_JSON_VALUE_NUMBER, start, end - start);
  700.     if (rc != NGX_OK) {
  701.         return rc;
  702.     }

  704.     *state = ngx_json_after_value(ctx);

  706.     return NGX_OK;
  707. }


  710. static ngx_inline ngx_int_t
  711. ‌ngx_json_emit(ngx_json_ctx_t *ctx, ngx_json_event_e event, u_char *data,
  712.     size_t len)
  713. {
  714.     ngx_int_t  rc;
  715.     ngx_str_t  token;

  717.     if (ngx_json_skipping(ctx->skip_until_depth)) {
  718.         return NGX_OK;
  719.     }

  721.     if (ctx->handler == NULL) {
  722.         return NGX_OK;
  723.     }

  725.     token.data = data;
  726.     token.len = len;
  727.     rc = ctx->handler(ctx, event, &token);

  729.     if (rc == NGX_JSON_SKIP) {

  731.         /*
  732.          * NGX_JSON_SKIP prunes the rest of the current container.  It is
  733.          * honoured only where it is meaningful:
  734.          *
  735.          *   - OBJECT_OPEN / ARRAY_OPEN: skip the whole container;
  736.          *   - a scalar VALUE_* that is an array element: skip the rest of
  737.          *     that array.
  738.          *
  739.          * A skip requested on a CLOSE, or on an object member value, is
  740.          * ignored: object members are navigated by KEY (use a KEY skip),
  741.          * and a CLOSE fires after the container is already complete.
  742.          */

  744.         switch (event) {

  746.         case NGX_JSON_KEY:
  747.         case NGX_JSON_KEY_ESCAPED:
  748.         case NGX_JSON_OBJECT_OPEN:
  749.         case NGX_JSON_ARRAY_OPEN:
  750.             ctx->skip_until_depth = ctx->depth;
  751.             break;

  753.         case NGX_JSON_VALUE_STRING:
  754.         case NGX_JSON_VALUE_STRING_ESCAPED:
  755.         case NGX_JSON_VALUE_NUMBER:
  756.         case NGX_JSON_VALUE_BOOL:
  757.         case NGX_JSON_VALUE_NULL:
  758.             if (ctx->depth > 0
  759.                 && ctx->stack[ctx->depth - 1] == ngx_json_ctx_array
  760.             ) {
  761.                 ctx->skip_until_depth = ctx->depth - 1;
  762.             }
  763.             break;

  765.         default:
  766.             break;
  767.         }

  769.         return NGX_OK;
  770.     }

  772.     return rc;
  773. }


  776. static ngx_inline ngx_json_state_e
  777. ‌ngx_json_after_value(ngx_json_ctx_t *ctx)
  778. {
  779.     if (ctx->depth == 0) {
  780.         return ngx_json_done;
  781.     }

  783.     if (ctx->stack[ctx->depth - 1] == ngx_json_ctx_object) {
  784.         return ngx_json_object_value_separator;
  785.     }

  787.     return ngx_json_array_value_separator;
  788. }


  791. static ngx_inline ngx_int_t
  792. ‌ngx_json_close(ngx_json_ctx_t *ctx, ngx_json_event_e event,
  793.     ngx_json_state_e *state, u_char *p)
  794. {
  795.     ngx_int_t  rc;

  797.     ctx->depth--;

  799.     rc = ngx_json_emit(ctx, event, p, 1);
  800.     if (rc != NGX_OK) {
  801.         return rc;
  802.     }

  804.     *state = ngx_json_after_value(ctx);

  806.     return NGX_OK;
  807. }


  810. static ngx_int_t
  811. ‌ngx_json_push_state(ngx_json_ctx_t *ctx, ngx_json_container_e container)
  812. {
  813.     ngx_json_container_e  *stack;

  815.     if (ctx->depth >= ctx->max_depth) {
  816.         return NGX_DECLINED;
  817.     }

  819.     if (ctx->stack == NULL) {
  820.         stack = ngx_palloc(ctx->pool,
  821.                            ctx->max_depth * sizeof(ngx_json_container_e));
  822.         if (stack == NULL) {
  823.             return NGX_ERROR;
  824.         }

  826.         ctx->stack = stack;
  827.     }

  829.     ctx->stack[ctx->depth] = container;
  830.     ctx->depth++;

  832.     return NGX_OK;
  833. }

One Level Up Top Level