One Level Up Top Level

src/http/modules/ngx_http_json_module.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


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


  7. #include <ngx_config.h>
  8. #include <ngx_core.h>
  9. #include <ngx_http.h>
  10. #include <ngx_json_parse.h>


  13. ‌#define NGX_HTTP_JSON_DEFAULT_MAX_DEPTH       32

  15. ‌typedef struct {
  16.     ngx_uint_t                     is_index;
  17.     ngx_str_t                      key;
  18.     ngx_uint_t                     index;
  19. ‌} ngx_http_json_seg_t;


  22. ‌typedef struct ngx_http_json_node_s  ngx_http_json_node_t;


  25. ‌struct ngx_http_json_node_s {
  26.     ngx_http_json_seg_t            seg;
  27.     ngx_array_t                   *children;  /* ngx_http_json_node_t */
  28.     ngx_uint_t                    *dests;
  29.     ngx_uint_t                     ndests;
  30. };


  33. ‌typedef struct {
  34.     ngx_int_t                      index;
  35.     ngx_http_json_node_t          *root;
  36. ‌} ngx_http_json_source_t;


  39. ‌typedef struct {
  40.     ngx_uint_t                     source_index;
  41. ‌} ngx_http_json_variable_t;


  44. ‌typedef struct {
  45.     ngx_uint_t                     index;
  46.     u_char                        *start;
  47.     ngx_http_json_node_t          *node;
  48.     ngx_uint_t                     is_array;
  49. ‌} ngx_http_json_frame_t;


  52. ‌typedef struct {
  53.     ngx_int_t                      max_depth;
  54.     ngx_array_t                   *sources;
  55.     ngx_array_t                   *variables;
  56. ‌} ngx_http_json_main_conf_t;


  59. ‌typedef struct {
  60.     ngx_http_request_t            *r;
  61.     ngx_http_variable_value_t     *values;
  62.     ngx_array_t                    stack;
  63.     ngx_str_t                      key_buffer;
  64.     ngx_uint_t                     in_member;
  65.     ngx_http_json_node_t          *current_node;
  66.     ngx_http_json_node_t          *root;
  67. ‌} ngx_http_json_state_t;


  70. static char *ngx_http_json_set(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  71. static ngx_int_t ngx_http_json_variable(ngx_http_request_t *r,
  72.     ngx_http_variable_value_t *v, uintptr_t data);
  73. static void ngx_http_json_reset(ngx_http_variable_value_t *values,
  74.     ngx_http_json_main_conf_t *jmcf, ngx_uint_t source_index);
  75. static char *ngx_http_json_insert_path(ngx_conf_t *cf,
  76.     ngx_http_json_node_t *root, ngx_uint_t dest, ngx_str_t *path);
  77. static ngx_http_json_node_t *ngx_http_json_child(ngx_conf_t *cf,
  78.     ngx_http_json_node_t *parent, ngx_http_json_seg_t *seg);
  79. static ngx_int_t ngx_http_json_handler(ngx_json_ctx_t *ctx,
  80.     ngx_json_event_e event, ngx_str_t *token);
  81. static void ngx_http_json_inc_index(ngx_http_json_state_t *state);
  82. static ngx_http_json_node_t *ngx_http_json_lookup_key(
  83.     ngx_http_json_node_t *parent, ngx_str_t *key);
  84. static ngx_http_json_node_t *ngx_http_json_lookup_index(
  85.     ngx_http_json_node_t *parent, ngx_uint_t index);
  86. static ngx_int_t ngx_http_json_store(ngx_http_json_state_t *state,
  87.     ngx_http_json_node_t *node, ngx_str_t *value, ngx_uint_t unescape);
  88. static ngx_int_t ngx_http_json_push(ngx_http_json_state_t *state,
  89.     ngx_json_event_e event, u_char *start, ngx_http_json_node_t *node);
  90. static void *ngx_http_json_create_main_conf(ngx_conf_t *cf);
  91. static char *ngx_http_json_init_main_conf(ngx_conf_t *cf, void *conf);


  94. ‌static ngx_conf_num_bounds_t  ngx_http_json_max_depth_bounds = {
  95.     ngx_conf_check_num_bounds, 1, 256
  96. };


  99. ‌static ngx_command_t  ngx_http_json_commands[] = {

  101.     { ngx_string("json_set"),
  102.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE3,
  103.       ngx_http_json_set,
  104.       NGX_HTTP_MAIN_CONF_OFFSET,
  105.       0,
  106.       NULL },

  108.     { ngx_string("json_max_depth"),
  109.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE1,
  110.       ngx_conf_set_num_slot,
  111.       NGX_HTTP_MAIN_CONF_OFFSET,
  112.       offsetof(ngx_http_json_main_conf_t, max_depth),
  113.       &ngx_http_json_max_depth_bounds },

  115.       ngx_null_command
  116. };


  119. ‌static ngx_http_module_t  ngx_http_json_module_ctx = {
  120.     NULL,                            /* preconfiguration */
  121.     NULL,                            /* postconfiguration */

  123.     ngx_http_json_create_main_conf,  /* create main configuration */
  124.     ngx_http_json_init_main_conf,    /* init main configuration */

  126.     NULL,                            /* create server configuration */
  127.     NULL,                            /* merge server configuration */

  129.     NULL,                            /* create location configuration */
  130.     NULL                             /* merge location configuration */
  131. };


  134. ‌ngx_module_t  ngx_http_json_module = {
  135.     NGX_MODULE_V1,
  136.     &ngx_http_json_module_ctx,       /* module context */
  137.     ngx_http_json_commands,          /* module directives */
  138.     NGX_HTTP_MODULE,                 /* module type */
  139.     NULL,                            /* init master */
  140.     NULL,                            /* init module */
  141.     NULL,                            /* init process */
  142.     NULL,                            /* init thread */
  143.     NULL,                            /* exit thread */
  144.     NULL,                            /* exit process */
  145.     NULL,                            /* exit master */
  146.     NGX_MODULE_V1_PADDING
  147. };


  150. static char *
  151. ‌ngx_http_json_set(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  152. {
  153.     ngx_http_json_main_conf_t  *jmcf = conf;

  155.     ngx_str_t                 *value, name, source;
  156.     ngx_int_t                  sindex;
  157.     ngx_uint_t                 i, oi, si;
  158.     ngx_http_variable_t       *var;
  159.     ngx_http_json_source_t    *src, *srcs;
  160.     ngx_http_json_variable_t  *jv;

  162.     value = cf->args->elts;

  164.     name = value[1];

  166.     if (name.data[0] != '$') {
  167.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  168.                            "invalid variable name \"%V\"", &name);
  169.         return NGX_CONF_ERROR;
  170.     }

  172.     name.len--;
  173.     name.data++;

  175.     var = ngx_http_add_variable(cf, &name, NGX_HTTP_VAR_CHANGEABLE);
  176.     if (var == NULL) {
  177.         return NGX_CONF_ERROR;
  178.     }

  180.     if (var->get_handler == ngx_http_json_variable) {
  181.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  182.                            "json_set variable \"%V\" is already defined",
  183.                            &name);
  184.         return NGX_CONF_ERROR;
  185.     }

  187.     source = value[2];

  189.     if (source.data[0] != '$') {
  190.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  191.                            "invalid variable name \"%V\"", &source);
  192.         return NGX_CONF_ERROR;
  193.     }

  195.     source.len--;
  196.     source.data++;

  198.     sindex = ngx_http_get_variable_index(cf, &source);
  199.     if (sindex == NGX_ERROR) {
  200.         return NGX_CONF_ERROR;
  201.     }

  203.     if (jmcf->sources == NULL) {
  204.         jmcf->sources = ngx_array_create(cf->pool, 4,
  205.                                          sizeof(ngx_http_json_source_t));
  206.         if (jmcf->sources == NULL) {
  207.             return NGX_CONF_ERROR;
  208.         }
  209.     }

  211.     srcs = jmcf->sources->elts;
  212.     si = jmcf->sources->nelts;

  214.     for (i = 0; i < jmcf->sources->nelts; i++) {
  215.         if (srcs[i].index == sindex) {
  216.             si = i;
  217.             break;
  218.         }
  219.     }

  221.     if (si == jmcf->sources->nelts) {
  222.         src = ngx_array_push(jmcf->sources);
  223.         if (src == NULL) {
  224.             return NGX_CONF_ERROR;
  225.         }

  227.         src->index = sindex;

  229.         src->root = ngx_pcalloc(cf->pool, sizeof(ngx_http_json_node_t));
  230.         if (src->root == NULL) {
  231.             return NGX_CONF_ERROR;
  232.         }

  234.     } else {
  235.         src = &srcs[si];
  236.     }

  238.     if (jmcf->variables == NULL) {
  239.         jmcf->variables = ngx_array_create(cf->pool, 4,
  240.                                            sizeof(ngx_http_json_variable_t));
  241.         if (jmcf->variables == NULL) {
  242.             return NGX_CONF_ERROR;
  243.         }
  244.     }

  246.     oi = jmcf->variables->nelts;

  248.     jv = ngx_array_push(jmcf->variables);
  249.     if (jv == NULL) {
  250.         return NGX_CONF_ERROR;
  251.     }

  253.     jv->source_index = si;

  255.     if (ngx_http_json_insert_path(cf, src->root, oi, &value[3])
  256.         != NGX_CONF_OK)
  257.     {
  258.         return NGX_CONF_ERROR;
  259.     }

  261.     var->get_handler = ngx_http_json_variable;
  262.     var->data = (uintptr_t) oi;

  264.     return NGX_CONF_OK;
  265. }


  268. static ngx_int_t
  269. ‌ngx_http_json_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  270.     uintptr_t data)
  271. {
  272.     ngx_int_t                   rc;
  273.     ngx_uint_t                  oi, si;
  274.     ngx_json_ctx_t              jctx;
  275.     ngx_http_json_state_t       state;
  276.     ngx_http_json_source_t     *src, *srcs;
  277.     ngx_http_json_variable_t   *jv;
  278.     ngx_http_variable_value_t  *cached, *values, *vv;
  279.     ngx_http_json_main_conf_t  *jmcf;

  281.     oi = (ngx_uint_t) data;

  283.     jmcf = ngx_http_get_module_main_conf(r, ngx_http_json_module);

  285.     if (jmcf->variables == NULL || oi >= jmcf->variables->nelts) {
  286.         v->not_found = 1;
  287.         return NGX_OK;
  288.     }

  290.     values = ngx_http_get_module_ctx(r, ngx_http_json_module);

  292.     if (values == NULL) {
  293.         values = ngx_pcalloc(r->pool, jmcf->variables->nelts
  294.                              * sizeof(ngx_http_variable_value_t));
  295.         if (values == NULL) {
  296.             return NGX_ERROR;
  297.         }

  299.         ngx_http_set_ctx(r, values, ngx_http_json_module);
  300.     }

  302.     cached = &values[oi];

  304.     if (cached->valid || cached->not_found) {
  305.         *v = *cached;
  306.         return NGX_OK;
  307.     }

  309.     jv = jmcf->variables->elts;
  310.     si = jv[oi].source_index;

  312.     srcs = jmcf->sources->elts;
  313.     src = &srcs[si];

  315.     vv = ngx_http_get_flushed_variable(r, (ngx_uint_t) src->index);

  317.     if (vv == NULL) {
  318.         return NGX_ERROR;
  319.     }

  321.     ngx_http_json_reset(values, jmcf, si);

  323.     if (vv->not_found || vv->len == 0) {
  324.         *v = *cached;
  325.         return NGX_OK;
  326.     }

  328.     ngx_memzero(&state, sizeof(ngx_http_json_state_t));

  330.     state.r = r;
  331.     state.values = values;
  332.     state.root = src->root;

  334.     if (ngx_array_init(&state.stack, r->pool, 8, sizeof(ngx_http_json_frame_t))
  335.         != NGX_OK)
  336.     {
  337.         return NGX_ERROR;
  338.     }

  340.     ngx_json_ctx_init(&jctx, r->pool);

  342.     jctx.handler = ngx_http_json_handler;
  343.     jctx.data = &state;
  344.     jctx.max_depth = jmcf->max_depth;

  346.     rc = ngx_json_parse_ctx(&jctx, vv->data, vv->len);

  348.     if (rc == NGX_OK) {
  349.         *v = *cached;
  350.         return NGX_OK;
  351.     }

  353.     ngx_http_json_reset(values, jmcf, si);

  355.     if (rc == NGX_DECLINED) {
  356.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  357.                        "json_set: invalid JSON source");
  358.     }

  360.     if (rc == NGX_ERROR) {
  361.         return NGX_ERROR;
  362.     }

  364.     *v = *cached;

  366.     return NGX_OK;
  367. }


  370. static void
  371. ‌ngx_http_json_reset(ngx_http_variable_value_t *values,
  372.     ngx_http_json_main_conf_t *jmcf, ngx_uint_t source_index)
  373. {
  374.     ngx_uint_t                 i;
  375.     ngx_http_json_variable_t  *jv;

  377.     jv = jmcf->variables->elts;

  379.     for (i = 0; i < jmcf->variables->nelts; i++) {
  380.         if (jv[i].source_index != source_index) {
  381.             continue;
  382.         }

  384.         values[i].valid = 0;
  385.         values[i].not_found = 1;
  386.     }
  387. }


  390. static char *
  391. ‌ngx_http_json_insert_path(ngx_conf_t *cf, ngx_http_json_node_t *root,
  392.     ngx_uint_t dest, ngx_str_t *path)
  393. {
  394.     u_char                *p, *last, *start, *dst;
  395.     ngx_int_t              index;
  396.     ngx_str_t              raw;
  397.     ngx_uint_t            *term;
  398.     ngx_http_json_seg_t    seg;
  399.     ngx_http_json_node_t  *node;
  400. ‌    enum {
  401.         sw_start = 0,
  402.         sw_key,
  403.         sw_dot,
  404.         sw_bracket,
  405.         sw_index,
  406.         sw_quoted,
  407.         sw_quoted_escape,
  408.         sw_quoted_close,
  409.         sw_after_bracket
  410.     } state;

  412.     if (path->len == 0) {
  413.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty json_set path");
  414.         return NGX_CONF_ERROR;
  415.     }

  417.     node = root;
  418.     start = NULL;

  420.     last = path->data + path->len;
  421.     state = sw_start;

  423.     for (p = path->data; p < last; p++) {

  425.         switch (state) {

  427.         case sw_start:

  429.             if (*p == '[') {
  430.                 state = sw_bracket;
  431.                 break;
  432.             }

  434.             if (*p == '.' || *p == '$') {
  435.                 goto invalid;
  436.             }

  438.             start = p;
  439.             state = sw_key;
  440.             break;

  442.         case sw_key:

  444.             if (*p == '.' || *p == '[') {

  446.                 seg.is_index = 0;
  447.                 seg.key.data = start;
  448.                 seg.key.len = p - start;
  449.                 seg.index = 0;

  451.                 node = ngx_http_json_child(cf, node, &seg);
  452.                 if (node == NULL) {
  453.                     return NGX_CONF_ERROR;
  454.                 }

  456.                 state = (*p == '.') ? sw_dot : sw_bracket;
  457.             }

  459.             break;

  461.         case sw_dot:

  463.             if (*p == '.' || *p == '[' || *p == '$') {
  464.                 goto invalid;
  465.             }

  467.             start = p;
  468.             state = sw_key;
  469.             break;

  471.         case sw_bracket:

  473.             if (*p == '"') {
  474.                 start = p + 1;
  475.                 state = sw_quoted;
  476.                 break;
  477.             }

  479.             if (*p >= '0' && *p <= '9') {
  480.                 start = p;
  481.                 state = sw_index;
  482.                 break;
  483.             }

  485.             goto invalid;

  487.         case sw_index:

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

  493.             if (*p != ']') {
  494.                 goto invalid;
  495.             }

  497.             index = ngx_atoi(start, p - start);
  498.             if (index == NGX_ERROR) {
  499.                 goto invalid;
  500.             }

  502.             seg.is_index = 1;
  503.             seg.index = index;
  504.             ngx_str_null(&seg.key);

  506.             node = ngx_http_json_child(cf, node, &seg);
  507.             if (node == NULL) {
  508.                 return NGX_CONF_ERROR;
  509.             }

  511.             state = sw_after_bracket;
  512.             break;

  514.         case sw_quoted:

  516.             if (*p == '\\') {
  517.                 state = sw_quoted_escape;
  518.                 break;
  519.             }

  521.             if (*p == '"') {

  523.                 dst = ngx_pnalloc(cf->pool, (size_t) (p - start));
  524.                 if (dst == NULL) {
  525.                     return NGX_CONF_ERROR;
  526.                 }

  528.                 raw.data = start;
  529.                 raw.len = p - start;

  531.                 seg.is_index = 0;
  532.                 seg.key.data = dst;
  533.                 seg.key.len = p - start;
  534.                 seg.index = 0;

  536.                 if (ngx_json_unescape_string(&seg.key, &raw) != NGX_OK) {
  537.                     goto invalid;
  538.                 }

  540.                 node = ngx_http_json_child(cf, node, &seg);
  541.                 if (node == NULL) {
  542.                     return NGX_CONF_ERROR;
  543.                 }

  545.                 state = sw_quoted_close;
  546.             }

  548.             break;

  550.         case sw_quoted_escape:

  552.             state = sw_quoted;
  553.             break;

  555.         case sw_quoted_close:

  557.             if (*p != ']') {
  558.                 goto invalid;
  559.             }

  561.             state = sw_after_bracket;
  562.             break;

  564.         case sw_after_bracket:

  566.             if (*p == '.') {
  567.                 state = sw_dot;
  568.                 break;
  569.             }

  571.             if (*p == '[') {
  572.                 state = sw_bracket;
  573.                 break;
  574.             }

  576.             goto invalid;
  577.         }
  578.     }

  580.     switch (state) {

  582.     case sw_key:

  584.         seg.is_index = 0;
  585.         seg.key.data = start;
  586.         seg.key.len = last - start;
  587.         seg.index = 0;

  589.         node = ngx_http_json_child(cf, node, &seg);
  590.         if (node == NULL) {
  591.             return NGX_CONF_ERROR;
  592.         }

  594.         break;

  596.     case sw_after_bracket:
  597.         break;

  599.     default:
  600.         goto invalid;
  601.     }

  603.     term = ngx_palloc(cf->pool, (node->ndests + 1) * sizeof(ngx_uint_t));
  604.     if (term == NULL) {
  605.         return NGX_CONF_ERROR;
  606.     }

  608.     if (node->ndests) {
  609.         ngx_memcpy(term, node->dests, node->ndests * sizeof(ngx_uint_t));
  610.     }

  612.     term[node->ndests] = dest;
  613.     node->dests = term;
  614.     node->ndests++;

  616.     return NGX_CONF_OK;

  618. invalid:

  620.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  621.                        "invalid json_set path \"%V\"", path);
  622.     return NGX_CONF_ERROR;
  623. }


  626. static ngx_http_json_node_t *
  627. ‌ngx_http_json_child(ngx_conf_t *cf, ngx_http_json_node_t *parent,
  628.     ngx_http_json_seg_t *seg)
  629. {
  630.     ngx_uint_t             i;
  631.     ngx_http_json_seg_t   *cseg;
  632.     ngx_http_json_node_t  *child, *elts;

  634.     if (parent->children != NULL) {
  635.         elts = parent->children->elts;

  637.         for (i = 0; i < parent->children->nelts; i++) {
  638.             child = &elts[i];
  639.             cseg = &child->seg;

  641.             if (seg->is_index) {
  642.                 if (cseg->is_index && cseg->index == seg->index) {
  643.                     return child;
  644.                 }

  646.             } else {
  647.                 if (!cseg->is_index
  648.                     && cseg->key.len == seg->key.len
  649.                     && ngx_memcmp(cseg->key.data, seg->key.data, seg->key.len)
  650.                        == 0)
  651.                 {
  652.                     return child;
  653.                 }
  654.             }
  655.         }

  657.     } else {
  658.         parent->children = ngx_array_create(cf->pool, 1,
  659.                                             sizeof(ngx_http_json_node_t));
  660.         if (parent->children == NULL) {
  661.             return NULL;
  662.         }
  663.     }

  665.     child = ngx_array_push(parent->children);
  666.     if (child == NULL) {
  667.         return NULL;
  668.     }

  670.     ngx_memzero(child, sizeof(ngx_http_json_node_t));

  672.     child->seg = *seg;

  674.     return child;
  675. }


  678. static ngx_int_t
  679. ‌ngx_http_json_handler(ngx_json_ctx_t *ctx, ngx_json_event_e event,
  680.     ngx_str_t *token)
  681. {
  682.     size_t                  size;
  683.     u_char                 *p;
  684.     ngx_str_t               key, slice, value;
  685.     ngx_uint_t              is_member;
  686.     ngx_http_json_node_t   *node;
  687.     ngx_http_json_state_t  *state;
  688.     ngx_http_json_frame_t  *top;

  690.     state = ctx->data;

  692.     top = NULL;
  693.     if (state->stack.nelts) {
  694.         top = (ngx_http_json_frame_t *) state->stack.elts
  695.               + state->stack.nelts - 1;
  696.     }

  698.     switch (event) {

  700.     case NGX_JSON_OBJECT_OPEN:
  701.     case NGX_JSON_ARRAY_OPEN:

  703.         if (state->stack.nelts == 0) {

  705.             state->in_member = 0;
  706.             state->current_node = NULL;

  708.             return ngx_http_json_push(state, event, token->data, state->root);
  709.         }

  711.         is_member = state->in_member;
  712.         state->in_member = 0;

  714.         if (is_member) {

  716.             node = state->current_node;
  717.             state->current_node = NULL;

  719.         } else {

  721.             node = ngx_http_json_lookup_index(top->node, top->index);

  723.             ngx_http_json_inc_index(state);

  725.             if (node == NULL) {
  726.                 return NGX_JSON_SKIP;
  727.             }
  728.         }

  730.         return ngx_http_json_push(state, event, token->data, node);

  732.     case NGX_JSON_OBJECT_CLOSE:
  733.     case NGX_JSON_ARRAY_CLOSE:

  735.         if (top != NULL) {

  737.             if (top->node->ndests > 0) {
  738.                 slice.data = top->start;
  739.                 slice.len = token->data - top->start + 1;

  741.                 if (ngx_http_json_store(state, top->node, &slice, 0)
  742.                     != NGX_OK)
  743.                 {
  744.                     return NGX_ERROR;
  745.                 }
  746.             }

  748.             state->stack.nelts--;
  749.         }

  751.         break;

  753.     case NGX_JSON_KEY:
  754.     case NGX_JSON_KEY_ESCAPED:

  756.         key = *token;

  758.         if (event == NGX_JSON_KEY_ESCAPED) {
  759.             if (token->len > state->key_buffer.len) {
  760.                 size = token->len;

  762.                 if (state->key_buffer.len <= NGX_MAX_SIZE_T_VALUE / 2) {
  763.                     size = ngx_max(size, state->key_buffer.len * 2);
  764.                 }

  766.                 p = ngx_pnalloc(ctx->pool, size);
  767.                 if (p == NULL) {
  768.                     return NGX_ERROR;
  769.                 }

  771.                 state->key_buffer.data = p;
  772.                 state->key_buffer.len = size;
  773.             }

  775.             key = state->key_buffer;

  777.             if (ngx_json_unescape_string(&key, token) != NGX_OK) {
  778.                 return NGX_ERROR;
  779.             }
  780.         }

  782.         node = ngx_http_json_lookup_key(top->node, &key);
  783.         if (node == NULL) {
  784.             state->in_member = 0;
  785.             state->current_node = NULL;
  786.             return NGX_JSON_SKIP;
  787.         }

  789.         state->in_member = 1;
  790.         state->current_node = node;

  792.         break;

  794.     case NGX_JSON_VALUE_STRING:
  795.     case NGX_JSON_VALUE_STRING_ESCAPED:
  796.     case NGX_JSON_VALUE_NUMBER:
  797.     case NGX_JSON_VALUE_BOOL:
  798.     case NGX_JSON_VALUE_NULL:

  800.         if (top == NULL) {
  801.             state->in_member = 0;
  802.             state->current_node = NULL;
  803.             break;
  804.         }

  806.         is_member = state->in_member;
  807.         state->in_member = 0;

  809.         if (is_member) {

  811.             node = state->current_node;
  812.             state->current_node = NULL;

  814.         } else {

  816.             node = ngx_http_json_lookup_index(top->node, top->index);

  818.             ngx_http_json_inc_index(state);
  819.         }

  821.         if (node != NULL && node->ndests > 0) {

  823.             value = *token;

  825.             if (ngx_http_json_store(state, node, &value,
  826.                                     event == NGX_JSON_VALUE_STRING_ESCAPED)
  827.                 != NGX_OK)
  828.             {
  829.                 return NGX_ERROR;
  830.             }
  831.         }

  833.         break;
  834.     }

  836.     return NGX_OK;
  837. }


  840. static void
  841. ‌ngx_http_json_inc_index(ngx_http_json_state_t *state)
  842. {
  843.     ngx_http_json_frame_t  *top;

  845.     if (state->stack.nelts == 0) {
  846.         return;
  847.     }

  849.     top = state->stack.elts;
  850.     top += state->stack.nelts - 1;

  852.     if (top->is_array) {
  853.         top->index++;
  854.     }
  855. }


  858. static ngx_http_json_node_t *
  859. ‌ngx_http_json_lookup_key(ngx_http_json_node_t *parent, ngx_str_t *key)
  860. {
  861.     ngx_uint_t             i;
  862.     ngx_http_json_seg_t   *seg;
  863.     ngx_http_json_node_t  *child, *elts;

  865.     if (parent->children == NULL) {
  866.         return NULL;
  867.     }

  869.     elts = parent->children->elts;

  871.     for (i = 0; i < parent->children->nelts; i++) {
  872.         child = &elts[i];
  873.         seg = &child->seg;

  875.         if (!seg->is_index
  876.             && seg->key.len == key->len
  877.             && ngx_memcmp(seg->key.data, key->data, key->len) == 0)
  878.         {
  879.             return child;
  880.         }
  881.     }

  883.     return NULL;
  884. }


  887. static ngx_http_json_node_t *
  888. ‌ngx_http_json_lookup_index(ngx_http_json_node_t *parent, ngx_uint_t index)
  889. {
  890.     ngx_uint_t             i;
  891.     ngx_http_json_seg_t   *seg;
  892.     ngx_http_json_node_t  *child, *elts;

  894.     if (parent->children == NULL) {
  895.         return NULL;
  896.     }

  898.     elts = parent->children->elts;

  900.     for (i = 0; i < parent->children->nelts; i++) {
  901.         child = &elts[i];
  902.         seg = &child->seg;

  904.         if (seg->is_index && seg->index == index) {
  905.             return child;
  906.         }
  907.     }

  909.     return NULL;
  910. }


  913. static ngx_int_t
  914. ‌ngx_http_json_store(ngx_http_json_state_t *state, ngx_http_json_node_t *node,
  915.     ngx_str_t *value, ngx_uint_t unescape)
  916. {
  917.     ngx_str_t                   val;
  918.     ngx_uint_t                  i;
  919.     ngx_http_variable_value_t  *slot;

  921.     if (value->len == 0) {
  922.         val.len = 0;
  923.         val.data = (u_char *) "";

  925.     } else if (unescape) {
  926.         val.data = ngx_pnalloc(state->r->pool, value->len);
  927.         if (val.data == NULL) {
  928.             return NGX_ERROR;
  929.         }

  931.         val.len = value->len;

  933.         if (ngx_json_unescape_string(&val, value) != NGX_OK) {
  934.             return NGX_ERROR;
  935.         }

  937.     } else {
  938.         val.data = ngx_pstrdup(state->r->pool, value);
  939.         if (val.data == NULL) {
  940.             return NGX_ERROR;
  941.         }

  943.         val.len = value->len;
  944.     }

  946.     for (i = 0; i < node->ndests; i++) {
  947.         slot = &state->values[node->dests[i]];
  948.         slot->valid = 1;
  949.         slot->not_found = 0;
  950.         slot->no_cacheable = 0;
  951.         slot->escape = 0;
  952.         slot->len = val.len;
  953.         slot->data = val.data;
  954.     }

  956.     return NGX_OK;
  957. }


  960. static ngx_int_t
  961. ‌ngx_http_json_push(ngx_http_json_state_t *state, ngx_json_event_e event,
  962.     u_char *start, ngx_http_json_node_t *node)
  963. {
  964.     ngx_http_json_frame_t  *frame;

  966.     frame = ngx_array_push(&state->stack);
  967.     if (frame == NULL) {
  968.         return NGX_ERROR;
  969.     }

  971.     frame->index = 0;
  972.     frame->start = start;
  973.     frame->is_array = (event == NGX_JSON_ARRAY_OPEN);
  974.     frame->node = node;

  976.     return NGX_OK;
  977. }


  980. static void *
  981. ‌ngx_http_json_create_main_conf(ngx_conf_t *cf)
  982. {
  983.     ngx_http_json_main_conf_t  *jmcf;

  985.     jmcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_json_main_conf_t));
  986.     if (jmcf == NULL) {
  987.         return NULL;
  988.     }

  990.     jmcf->max_depth = NGX_CONF_UNSET;

  992.     return jmcf;
  993. }


  996. static char *
  997. ‌ngx_http_json_init_main_conf(ngx_conf_t *cf, void *conf)
  998. {
  999.     ngx_http_json_main_conf_t  *jmcf = conf;

  1001.     ngx_conf_init_value(jmcf->max_depth, NGX_HTTP_JSON_DEFAULT_MAX_DEPTH);

  1003.     return NGX_CONF_OK;
  1004. }

One Level Up Top Level