One Level Up Top Level

src/core/ngx_json_parse.c - nginx-1.31.7 nginx/ @ 939334eff

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. }


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

  66.     if (len == 0) {
  67.         return NGX_DECLINED;
  68.     }

  70.     if (data == NULL) {
  71.         return NGX_ERROR;
  72.     }

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

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

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

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

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

  96.             continue;
  97.         }

  99.         switch (state) {

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

  106.             p--;
  107.             state = ngx_json_value;
  108.             break;

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

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

  121.                 break;
  122.             }

  124.             /* fall through */

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

  131.             if (*p == '"') {
  132.                 ctx->in_key = 1;
  133.                 start = p + 1;
  134.                 state = ngx_json_string;
  135.                 break;
  136.             }

  138.             return NGX_DECLINED;

  140.         case ngx_json_object_name_separator:
  141.             if (ngx_json_ws(*p)) {
  142.                 break;
  143.             }

  145.             if (*p == ':') {
  146.                 state = ngx_json_value;
  147.                 break;
  148.             }

  150.             return NGX_DECLINED;

  152.         case ngx_json_object_value_separator:
  153.             if (ngx_json_ws(*p)) {
  154.                 break;
  155.             }

  157.             if (*p == ',') {
  158.                 state = ngx_json_object_next;
  159.                 break;
  160.             }

  162.             if (*p == '}') {
  163.                 rc = ngx_json_close(ctx, NGX_JSON_OBJECT_CLOSE, &state, p);
  164.                 if (rc != NGX_OK) {
  165.                     return rc;
  166.                 }

  168.                 break;
  169.             }

  171.             return NGX_DECLINED;

  173.         case ngx_json_array_value_separator:
  174.             if (ngx_json_ws(*p)) {
  175.                 break;
  176.             }

  178.             if (*p == ',') {
  179.                 state = ngx_json_value;
  180.                 break;
  181.             }

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

  189.                 break;
  190.             }

  192.             return NGX_DECLINED;

  194.         case ngx_json_array:
  195.             if (ngx_json_ws(*p)) {
  196.                 break;
  197.             }

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

  205.                 break;
  206.             }

  208.             /* fall through */

  210.         case ngx_json_value:
  211.             if (ngx_json_ws(*p)) {
  212.                 break;
  213.             }

  215.             start = p;

  217.             if (*p == '"') {
  218.                 ctx->in_key = 0;
  219.                 start = p + 1;
  220.                 state = ngx_json_string;
  221.                 break;
  222.             }

  224.             if (*p == '{') {
  225.                 rc = ngx_json_emit(ctx, NGX_JSON_OBJECT_OPEN, p, 1);
  226.                 if (rc != NGX_OK) {
  227.                     return rc;
  228.                 }

  230.                 rc = ngx_json_push_state(ctx, ngx_json_ctx_object);
  231.                 if (rc != NGX_OK) {
  232.                     return rc;
  233.                 }

  235.                 state = ngx_json_object;
  236.                 break;
  237.             }

  239.             if (*p == '[') {
  240.                 rc = ngx_json_emit(ctx, NGX_JSON_ARRAY_OPEN, p, 1);
  241.                 if (rc != NGX_OK) {
  242.                     return rc;
  243.                 }

  245.                 rc = ngx_json_push_state(ctx, ngx_json_ctx_array);
  246.                 if (rc != NGX_OK) {
  247.                     return rc;
  248.                 }

  250.                 state = ngx_json_array;
  251.                 break;
  252.             }

  254.             if (*p == '-') {
  255.                 state = ngx_json_number_minus;
  256.                 break;
  257.             }

  259.             if (*p == '0') {
  260.                 state = ngx_json_number_int_zero;
  261.                 break;
  262.             }

  264.             if (*p >= '1' && *p <= '9') {
  265.                 state = ngx_json_number_int;
  266.                 break;
  267.             }

  269.             if (*p == 't') {
  270.                 state = ngx_json_true_t;
  271.                 break;
  272.             }

  274.             if (*p == 'f') {
  275.                 state = ngx_json_false_f;
  276.                 break;
  277.             }

  279.             if (*p == 'n') {
  280.                 state = ngx_json_null_n;
  281.                 break;
  282.             }

  284.             return NGX_DECLINED;

  286.         case ngx_json_string:
  287.             if (*p == '"') {

  289.                 if (ctx->in_key) {
  290.                     rc = ngx_json_emit(ctx, NGX_JSON_KEY, start, p - start);
  291.                     if (rc != NGX_OK) {
  292.                         return rc;
  293.                     }

  295.                     ctx->in_key = 0;
  296.                     state = ngx_json_object_name_separator;

  298.                 } else {
  299.                     rc = ngx_json_emit(ctx, NGX_JSON_VALUE_STRING, start,
  300.                                       p - start);
  301.                     if (rc != NGX_OK) {
  302.                         return rc;
  303.                     }

  305.                     state = ngx_json_after_value(ctx);
  306.                 }

  308.                 break;
  309.             }

  311.             if (*p == '\\') {
  312.                 state = ngx_json_escaped;
  313.                 break;
  314.             }

  316.             if (*p < ' ') {
  317.                 return NGX_DECLINED;
  318.             }

  320.             break;

  322.         case ngx_json_escaped:
  323.             if (*p == '"' || *p == '\\' || *p == '/' || *p == 'b'
  324.                 || *p == 'f' || *p == 'n' || *p == 'r' || *p == 't')
  325.             {
  326.                 state = ngx_json_string;
  327.                 break;
  328.             }

  330.             if (*p == 'u') {
  331.                 ctx->codepoint = 0;
  332.                 ctx->hex_left = 4;
  333.                 state = ngx_json_escaped_hex;
  334.                 break;
  335.             }

  337.             return NGX_DECLINED;

  339.         case ngx_json_escaped_hex:

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

  343.             hd = ngx_json_hex_digit(*p);
  344.             if (hd == NGX_ERROR) {
  345.                 return NGX_DECLINED;
  346.             }

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

  350.             if (--ctx->hex_left > 0) {
  351.                 break;
  352.             }

  354.             if (ctx->codepoint >= 0xD800 && ctx->codepoint <= 0xDBFF) {
  355.                 /* high surrogate - must be followed by \uDC00..\uDFFF */
  356.                 state = ngx_json_surrogate_start;
  357.                 break;
  358.             }

  360.             if (ctx->codepoint >= 0xDC00 && ctx->codepoint <= 0xDFFF) {
  361.                 /* lone low surrogate */
  362.                 return NGX_DECLINED;
  363.             }

  365.             state = ngx_json_string;
  366.             break;

  368.         case ngx_json_surrogate_start:
  369.             if (*p == '\\') {
  370.                 state = ngx_json_surrogate_u;
  371.                 break;
  372.             }

  374.             /* high surrogate not followed by \uXXXX */
  375.             return NGX_DECLINED;

  377.         case ngx_json_surrogate_u:
  378.             if (*p == 'u') {
  379.                 ctx->codepoint = 0;
  380.                 ctx->hex_left = 4;
  381.                 state = ngx_json_surrogate_hex;
  382.                 break;
  383.             }

  385.             /* high surrogate followed by non-\u escape */
  386.             return NGX_DECLINED;

  388.         case ngx_json_surrogate_hex:

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

  392.             hd = ngx_json_hex_digit(*p);
  393.             if (hd == NGX_ERROR) {
  394.                 return NGX_DECLINED;
  395.             }

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

  399.             if (--ctx->hex_left > 0) {
  400.                 break;
  401.             }

  403.             if (ctx->codepoint >= 0xDC00 && ctx->codepoint <= 0xDFFF) {
  404.                 /* valid surrogate pair */
  405.                 state = ngx_json_string;
  406.                 break;
  407.             }

  409.             /* high surrogate not followed by low surrogate */
  410.             return NGX_DECLINED;

  412.         case ngx_json_number_minus:
  413.             if (*p >= '1' && *p <= '9') {
  414.                 state = ngx_json_number_int;
  415.                 break;
  416.             }

  418.             if (*p == '0') {
  419.                 state = ngx_json_number_int_zero;
  420.                 break;
  421.             }

  423.             return NGX_DECLINED;

  425.         case ngx_json_number_int_zero:
  426.             if (*p == '.') {
  427.                 state = ngx_json_number_frac;
  428.                 break;
  429.             }

  431.             if (*p == 'e' || *p == 'E') {
  432.                 /* No sense, but permitted by RFC */
  433.                 state = ngx_json_number_exp;
  434.                 break;
  435.             }

  437.             p--;

  439.             rc = ngx_json_end_number(ctx, start, p + 1, &state);
  440.             if (rc != NGX_OK) {
  441.                 return rc;
  442.             }

  444.             break;

  446.         case ngx_json_number_int:
  447.             if (*p >= '0' && *p <= '9') {
  448.                 break;
  449.             }

  451.             if (*p == '.') {
  452.                 state = ngx_json_number_frac;
  453.                 break;
  454.             }

  456.             if (*p == 'e' || *p == 'E') {
  457.                 /* No sense, but permitted by RFC */
  458.                 state = ngx_json_number_exp;
  459.                 break;
  460.             }

  462.             p--;

  464.             rc = ngx_json_end_number(ctx, start, p + 1, &state);
  465.             if (rc!= NGX_OK) {
  466.                 return rc;
  467.             }

  469.             break;

  471.         case ngx_json_number_frac:
  472.             if (*p >= '0' && *p <= '9') {
  473.                 state = ngx_json_number_frac_digit;
  474.                 break;
  475.             }

  477.             return NGX_DECLINED;

  479.         case ngx_json_number_frac_digit:
  480.             if (*p >= '0' && *p <= '9') {
  481.                 break;
  482.             }

  484.             if (*p == 'e' || *p == 'E') {
  485.                 state = ngx_json_number_exp;
  486.                 break;
  487.             }

  489.             p--;

  491.             rc = ngx_json_end_number(ctx, start, p + 1, &state);
  492.             if (rc != NGX_OK) {
  493.                 return rc;
  494.             }

  496.             break;

  498.         case ngx_json_number_exp:
  499.             if (*p == '-' || *p == '+') {
  500.                 state = ngx_json_number_exp_plusminus;
  501.                 break;
  502.             }

  504.             if (*p >= '0' && *p <= '9') {
  505.                 state = ngx_json_number_exp_digit;
  506.                 break;
  507.             }

  509.             return NGX_DECLINED;

  511.         case ngx_json_number_exp_plusminus:
  512.             if (*p >= '0' && *p <= '9') {
  513.                 state = ngx_json_number_exp_digit;
  514.                 break;
  515.             }

  517.             return NGX_DECLINED;

  519.         case ngx_json_number_exp_digit:
  520.             if (*p >= '0' && *p <= '9') {
  521.                 break;
  522.             }

  524.             p--;

  526.             rc = ngx_json_end_number(ctx, start, p + 1, &state);
  527.             if (rc != NGX_OK) {
  528.                 return rc;
  529.             }

  531.             break;

  533.         case ngx_json_true_t:
  534.             if (*p == 'r') {
  535.                 state = ngx_json_true_tr;
  536.                 break;
  537.             }

  539.             return NGX_DECLINED;

  541.         case ngx_json_true_tr:
  542.             if (*p == 'u') {
  543.                 state = ngx_json_true_tru;
  544.                 break;
  545.             }

  547.             return NGX_DECLINED;

  549.         case ngx_json_true_tru:
  550.             if (*p == 'e') {
  551.                 rc = ngx_json_emit(ctx, NGX_JSON_VALUE_BOOL, start,
  552.                                   p + 1 - start);
  553.                 if (rc != NGX_OK) {
  554.                     return rc;
  555.                 }

  557.                 state = ngx_json_after_value(ctx);
  558.                 break;
  559.             }

  561.             return NGX_DECLINED;

  563.         case ngx_json_false_f:
  564.             if (*p == 'a') {
  565.                 state = ngx_json_false_fa;
  566.                 break;
  567.             }

  569.             return NGX_DECLINED;

  571.         case ngx_json_false_fa:
  572.             if (*p == 'l') {
  573.                 state = ngx_json_false_fal;
  574.                 break;
  575.             }

  577.             return NGX_DECLINED;

  579.         case ngx_json_false_fal:
  580.             if (*p == 's') {
  581.                 state = ngx_json_false_fals;
  582.                 break;
  583.             }

  585.             return NGX_DECLINED;

  587.         case ngx_json_false_fals:
  588.             if (*p == 'e') {
  589.                 rc = ngx_json_emit(ctx, NGX_JSON_VALUE_BOOL, start,
  590.                                   p + 1 - start);
  591.                 if (rc != NGX_OK) {
  592.                     return rc;
  593.                 }

  595.                 state = ngx_json_after_value(ctx);
  596.                 break;
  597.             }

  599.             return NGX_DECLINED;

  601.         case ngx_json_null_n:
  602.             if (*p == 'u') {
  603.                 state = ngx_json_null_nu;
  604.                 break;
  605.             }

  607.             return NGX_DECLINED;

  609.         case ngx_json_null_nu:
  610.             if (*p == 'l') {
  611.                 state = ngx_json_null_nul;
  612.                 break;
  613.             }

  615.             return NGX_DECLINED;

  617.         case ngx_json_null_nul:
  618.             if (*p == 'l') {
  619.                 rc = ngx_json_emit(ctx, NGX_JSON_VALUE_NULL, start,
  620.                                   p + 1 - start);
  621.                 if (rc != NGX_OK) {
  622.                     return rc;
  623.                 }

  625.                 state = ngx_json_after_value(ctx);
  626.                 break;
  627.             }

  629.             return NGX_DECLINED;

  631.         case ngx_json_done:
  632.             if (ngx_json_ws(*p)) {
  633.                 break;
  634.             }

  636.             return NGX_DECLINED;
  637.         }

  639.         skip_depth = ctx->skip_until_depth;
  640.     }

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

  644.     if (ctx->depth == 0
  645.         && (state == ngx_json_number_int_zero
  646.             || state == ngx_json_number_int
  647.             || state == ngx_json_number_frac_digit
  648.             || state == ngx_json_number_exp_digit))
  649.     {
  650.         rc = ngx_json_emit(ctx, NGX_JSON_VALUE_NUMBER, start, last - start);
  651.         if (rc != NGX_OK) {
  652.             return rc;
  653.         }

  655.         state = ngx_json_done;
  656.     }

  658.     ctx->state = state;

  660.     if (state == ngx_json_done) {
  661.         return NGX_OK;
  662.     }

  664.     return NGX_DECLINED;
  665. }


  668. ngx_int_t
  669. ‌ngx_json_parse(ngx_pool_t *pool, ngx_str_t *json, ngx_json_handler_pt handler,
  670.     void *data)
  671. {
  672.     ngx_json_ctx_t  jctx;

  674.     ngx_json_ctx_init(&jctx, pool);

  676.     jctx.data = data;
  677.     jctx.handler = handler;

  679.     return ngx_json_parse_ctx(&jctx, json->data, json->len);
  680. }


  683. static ngx_inline ngx_int_t
  684. ‌ngx_json_end_number(ngx_json_ctx_t *ctx, u_char *start, u_char *end,
  685.     ngx_json_state_e *state)
  686. {
  687.     ngx_int_t  rc;

  689.     rc = ngx_json_emit(ctx, NGX_JSON_VALUE_NUMBER, start, end - start);
  690.     if (rc != NGX_OK) {
  691.         return rc;
  692.     }

  694.     *state = ngx_json_after_value(ctx);

  696.     return NGX_OK;
  697. }


  700. static ngx_inline ngx_int_t
  701. ‌ngx_json_emit(ngx_json_ctx_t *ctx, ngx_json_event_e event, u_char *data,
  702.     size_t len)
  703. {
  704.     ngx_int_t  rc;
  705.     ngx_str_t  token;

  707.     if (ngx_json_skipping(ctx->skip_until_depth)) {
  708.         return NGX_OK;
  709.     }

  711.     if (ctx->handler == NULL) {
  712.         return NGX_OK;
  713.     }

  715.     token.data = data;
  716.     token.len = len;
  717.     rc = ctx->handler(ctx, event, &token);

  719.     if (rc == NGX_JSON_SKIP) {

  721.         /*
  722.          * NGX_JSON_SKIP prunes the rest of the current container.  It is
  723.          * honoured only where it is meaningful:
  724.          *
  725.          *   - OBJECT_OPEN / ARRAY_OPEN: skip the whole container;
  726.          *   - a scalar VALUE_* that is an array element: skip the rest of
  727.          *     that array.
  728.          *
  729.          * A skip requested on a CLOSE, or on an object member value, is
  730.          * ignored: object members are navigated by KEY (use a KEY skip),
  731.          * and a CLOSE fires after the container is already complete.
  732.          */

  734.         switch (event) {

  736.         case NGX_JSON_KEY:
  737.         case NGX_JSON_OBJECT_OPEN:
  738.         case NGX_JSON_ARRAY_OPEN:
  739.             ctx->skip_until_depth = ctx->depth;
  740.             break;

  742.         case NGX_JSON_VALUE_STRING:
  743.         case NGX_JSON_VALUE_NUMBER:
  744.         case NGX_JSON_VALUE_BOOL:
  745.         case NGX_JSON_VALUE_NULL:
  746.             if (ctx->depth > 0
  747.                 && ctx->stack[ctx->depth - 1] == ngx_json_ctx_array
  748.             ) {
  749.                 ctx->skip_until_depth = ctx->depth - 1;
  750.             }
  751.             break;

  753.         default:
  754.             break;
  755.         }

  757.         return NGX_OK;
  758.     }

  760.     return rc;
  761. }


  764. static ngx_inline ngx_json_state_e
  765. ‌ngx_json_after_value(ngx_json_ctx_t *ctx)
  766. {
  767.     if (ctx->depth == 0) {
  768.         return ngx_json_done;
  769.     }

  771.     if (ctx->stack[ctx->depth - 1] == ngx_json_ctx_object) {
  772.         return ngx_json_object_value_separator;
  773.     }

  775.     return ngx_json_array_value_separator;
  776. }


  779. static ngx_inline ngx_int_t
  780. ‌ngx_json_close(ngx_json_ctx_t *ctx, ngx_json_event_e event,
  781.     ngx_json_state_e *state, u_char *p)
  782. {
  783.     ngx_int_t  rc;

  785.     ctx->depth--;

  787.     rc = ngx_json_emit(ctx, event, p, 1);
  788.     if (rc != NGX_OK) {
  789.         return rc;
  790.     }

  792.     *state = ngx_json_after_value(ctx);

  794.     return NGX_OK;
  795. }


  798. static ngx_int_t
  799. ‌ngx_json_push_state(ngx_json_ctx_t *ctx, ngx_json_container_e container)
  800. {
  801.     ngx_json_container_e  *stack;

  803.     if (ctx->depth >= ctx->max_depth) {
  804.         return NGX_DECLINED;
  805.     }

  807.     if (ctx->stack == NULL) {
  808.         stack = ngx_palloc(ctx->pool,
  809.                            ctx->max_depth * sizeof(ngx_json_container_e));
  810.         if (stack == NULL) {
  811.             return NGX_ERROR;
  812.         }

  814.         ctx->stack = stack;
  815.     }

  817.     ctx->stack[ctx->depth] = container;
  818.     ctx->depth++;

  820.     return NGX_OK;
  821. }

One Level Up Top Level