One Level Up Top Level

src/http/modules/ngx_http_json_module.c - nginx-1.31.7 nginx/ @ 939334eff

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                      current_key;
  64.     ngx_http_json_node_t          *current_node;
  65.     ngx_http_json_node_t          *root;
  66. ‌} ngx_http_json_state_t;


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


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


  98. ‌static ngx_command_t  ngx_http_json_commands[] = {

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

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

  114.       ngx_null_command
  115. };


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

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

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

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


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


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

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

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

  163.     name = value[1];

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

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

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

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

  186.     source = value[2];

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

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

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

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

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

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

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

  226.         src->index = sindex;

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

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

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

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

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

  252.     jv->source_index = si;

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

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

  263.     return NGX_CONF_OK;
  264. }


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

  280.     oi = (ngx_uint_t) data;

  282.     jmcf = ngx_http_get_module_main_conf(r, ngx_http_json_module);

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

  289.     values = ngx_http_get_module_ctx(r, ngx_http_json_module);

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

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

  301.     cached = &values[oi];

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

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

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

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

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

  320.     ngx_http_json_reset(values, jmcf, si);

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

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

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

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

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

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

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

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

  352.     ngx_http_json_reset(values, jmcf, si);

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

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

  363.     *v = *cached;

  365.     return NGX_OK;
  366. }


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

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

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

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


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

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

  415.     node = root;
  416.     start = NULL;

  418.     last = path->data + path->len;
  419.     state = sw_start;

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

  423.         switch (state) {

  425.         case sw_start:

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

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

  436.             start = p;
  437.             state = sw_key;
  438.             break;

  440.         case sw_key:

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

  444.                 seg.is_index = 0;
  445.                 seg.key.data = start;
  446.                 seg.key.len = p - start;
  447.                 seg.index = 0;

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

  454.                 state = (*p == '.') ? sw_dot : sw_bracket;
  455.             }

  457.             break;

  459.         case sw_dot:

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

  465.             start = p;
  466.             state = sw_key;
  467.             break;

  469.         case sw_bracket:

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

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

  483.             goto invalid;

  485.         case sw_index:

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

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

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

  500.             seg.is_index = 1;
  501.             seg.index = index;
  502.             ngx_str_null(&seg.key);

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

  509.             state = sw_after_bracket;
  510.             break;

  512.         case sw_quoted:

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

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

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

  526.                 ngx_memcpy(dst, start, p - start);

  528.                 seg.is_index = 0;
  529.                 seg.key.data = dst;
  530.                 seg.key.len = p - start;
  531.                 seg.index = 0;

  533.                 if (ngx_json_unescape_string(&seg.key) != NGX_OK) {
  534.                     goto invalid;
  535.                 }

  537.                 node = ngx_http_json_child(cf, node, &seg);
  538.                 if (node == NULL) {
  539.                     return NGX_CONF_ERROR;
  540.                 }

  542.                 state = sw_quoted_close;
  543.             }

  545.             break;

  547.         case sw_quoted_escape:

  549.             state = sw_quoted;
  550.             break;

  552.         case sw_quoted_close:

  554.             if (*p != ']') {
  555.                 goto invalid;
  556.             }

  558.             state = sw_after_bracket;
  559.             break;

  561.         case sw_after_bracket:

  563.             if (*p == '.') {
  564.                 state = sw_dot;
  565.                 break;
  566.             }

  568.             if (*p == '[') {
  569.                 state = sw_bracket;
  570.                 break;
  571.             }

  573.             goto invalid;
  574.         }
  575.     }

  577.     switch (state) {

  579.     case sw_key:

  581.         seg.is_index = 0;
  582.         seg.key.data = start;
  583.         seg.key.len = last - start;
  584.         seg.index = 0;

  586.         node = ngx_http_json_child(cf, node, &seg);
  587.         if (node == NULL) {
  588.             return NGX_CONF_ERROR;
  589.         }

  591.         break;

  593.     case sw_after_bracket:
  594.         break;

  596.     default:
  597.         goto invalid;
  598.     }

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

  605.     if (node->ndests) {
  606.         ngx_memcpy(term, node->dests, node->ndests * sizeof(ngx_uint_t));
  607.     }

  609.     term[node->ndests] = dest;
  610.     node->dests = term;
  611.     node->ndests++;

  613.     return NGX_CONF_OK;

  615. invalid:

  617.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  618.                        "invalid json_set path \"%V\"", path);
  619.     return NGX_CONF_ERROR;
  620. }


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

  631.     if (parent->children != NULL) {
  632.         elts = parent->children->elts;

  634.         for (i = 0; i < parent->children->nelts; i++) {
  635.             child = &elts[i];
  636.             cseg = &child->seg;

  638.             if (seg->is_index) {
  639.                 if (cseg->is_index && cseg->index == seg->index) {
  640.                     return child;
  641.                 }

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

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

  662.     child = ngx_array_push(parent->children);
  663.     if (child == NULL) {
  664.         return NULL;
  665.     }

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

  669.     child->seg = *seg;

  671.     return child;
  672. }


  675. static ngx_int_t
  676. ‌ngx_http_json_handler(ngx_json_ctx_t *ctx, ngx_json_event_e event,
  677.     ngx_str_t *token)
  678. {
  679.     ngx_str_t               slice, value;
  680.     ngx_uint_t              is_member;
  681.     ngx_http_json_node_t   *node;
  682.     ngx_http_json_state_t  *state;
  683.     ngx_http_json_frame_t  *top;

  685.     state = ctx->data;

  687.     top = NULL;
  688.     if (state->stack.nelts) {
  689.         top = (ngx_http_json_frame_t *) state->stack.elts
  690.               + state->stack.nelts - 1;
  691.     }

  693.     switch (event) {

  695.     case NGX_JSON_OBJECT_OPEN:
  696.     case NGX_JSON_ARRAY_OPEN:

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

  700.             ngx_str_null(&state->current_key);
  701.             state->current_node = NULL;

  703.             return ngx_http_json_push(state, event, token->data, state->root);
  704.         }

  706.         is_member = (state->current_key.data != NULL);
  707.         ngx_str_null(&state->current_key);

  709.         if (is_member) {

  711.             node = state->current_node;
  712.             state->current_node = NULL;

  714.         } else {

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

  718.             ngx_http_json_inc_index(state);

  720.             if (node == NULL) {
  721.                 return NGX_JSON_SKIP;
  722.             }
  723.         }

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

  727.     case NGX_JSON_OBJECT_CLOSE:
  728.     case NGX_JSON_ARRAY_CLOSE:

  730.         if (top != NULL) {

  732.             if (top->node->ndests > 0) {
  733.                 slice.data = top->start;
  734.                 slice.len = token->data - top->start + 1;

  736.                 if (ngx_http_json_store(state, top->node, &slice, 0)
  737.                     != NGX_OK)
  738.                 {
  739.                     return NGX_ERROR;
  740.                 }
  741.             }

  743.             state->stack.nelts--;
  744.         }

  746.         break;

  748.     case NGX_JSON_KEY:

  750.         if (ngx_strlchr(token->data, token->data + token->len, '\\') == NULL) {
  751.             state->current_key = *token;

  753.         } else {
  754.             state->current_key.data = ngx_pstrdup(ctx->pool, token);
  755.             if (state->current_key.data == NULL) {
  756.                 return NGX_ERROR;
  757.             }

  759.             state->current_key.len = token->len;

  761.             if (ngx_json_unescape_string(&state->current_key) != NGX_OK) {
  762.                 return NGX_ERROR;
  763.             }
  764.         }

  766.         node = ngx_http_json_lookup_key(top->node, &state->current_key);
  767.         if (node == NULL) {
  768.             ngx_str_null(&state->current_key);
  769.             state->current_node = NULL;
  770.             return NGX_JSON_SKIP;
  771.         }

  773.         state->current_node = node;

  775.         break;

  777.     case NGX_JSON_VALUE_STRING:
  778.     case NGX_JSON_VALUE_NUMBER:
  779.     case NGX_JSON_VALUE_BOOL:
  780.     case NGX_JSON_VALUE_NULL:

  782.         if (top == NULL) {
  783.             ngx_str_null(&state->current_key);
  784.             state->current_node = NULL;
  785.             break;
  786.         }

  788.         is_member = (state->current_key.data != NULL);
  789.         ngx_str_null(&state->current_key);

  791.         if (is_member) {

  793.             node = state->current_node;
  794.             state->current_node = NULL;

  796.         } else {

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

  800.             ngx_http_json_inc_index(state);
  801.         }

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

  805.             value = *token;

  807.             if (ngx_http_json_store(state, node, &value,
  808.                                           event == NGX_JSON_VALUE_STRING)
  809.                 != NGX_OK)
  810.             {
  811.                 return NGX_ERROR;
  812.             }
  813.         }

  815.         break;
  816.     }

  818.     return NGX_OK;
  819. }


  822. static void
  823. ‌ngx_http_json_inc_index(ngx_http_json_state_t *state)
  824. {
  825.     ngx_http_json_frame_t  *top;

  827.     if (state->stack.nelts == 0) {
  828.         return;
  829.     }

  831.     top = state->stack.elts;
  832.     top += state->stack.nelts - 1;

  834.     if (top->is_array) {
  835.         top->index++;
  836.     }
  837. }


  840. static ngx_http_json_node_t *
  841. ‌ngx_http_json_lookup_key(ngx_http_json_node_t *parent, ngx_str_t *key)
  842. {
  843.     ngx_uint_t             i;
  844.     ngx_http_json_seg_t   *seg;
  845.     ngx_http_json_node_t  *child, *elts;

  847.     if (parent->children == NULL) {
  848.         return NULL;
  849.     }

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

  853.     for (i = 0; i < parent->children->nelts; i++) {
  854.         child = &elts[i];
  855.         seg = &child->seg;

  857.         if (!seg->is_index
  858.             && seg->key.len == key->len
  859.             && ngx_memcmp(seg->key.data, key->data, key->len) == 0)
  860.         {
  861.             return child;
  862.         }
  863.     }

  865.     return NULL;
  866. }


  869. static ngx_http_json_node_t *
  870. ‌ngx_http_json_lookup_index(ngx_http_json_node_t *parent, ngx_uint_t index)
  871. {
  872.     ngx_uint_t             i;
  873.     ngx_http_json_seg_t   *seg;
  874.     ngx_http_json_node_t  *child, *elts;

  876.     if (parent->children == NULL) {
  877.         return NULL;
  878.     }

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

  882.     for (i = 0; i < parent->children->nelts; i++) {
  883.         child = &elts[i];
  884.         seg = &child->seg;

  886.         if (seg->is_index && seg->index == index) {
  887.             return child;
  888.         }
  889.     }

  891.     return NULL;
  892. }


  895. static ngx_int_t
  896. ‌ngx_http_json_store(ngx_http_json_state_t *state, ngx_http_json_node_t *node,
  897.     ngx_str_t *value, ngx_uint_t unescape)
  898. {
  899.     ngx_str_t                   val;
  900.     ngx_uint_t                  i;
  901.     ngx_http_variable_value_t  *slot;

  903.     if (value->len == 0) {
  904.         val.len = 0;
  905.         val.data = (u_char *) "";

  907.     } else {
  908.         val.data = ngx_pstrdup(state->r->pool, value);
  909.         if (val.data == NULL) {
  910.             return NGX_ERROR;
  911.         }

  913.         val.len = value->len;

  915.         if (unescape && ngx_json_unescape_string(&val) != NGX_OK) {
  916.             return NGX_ERROR;
  917.         }
  918.     }

  920.     for (i = 0; i < node->ndests; i++) {
  921.         slot = &state->values[node->dests[i]];
  922.         slot->valid = 1;
  923.         slot->not_found = 0;
  924.         slot->no_cacheable = 0;
  925.         slot->escape = 0;
  926.         slot->len = val.len;
  927.         slot->data = val.data;
  928.     }

  930.     return NGX_OK;
  931. }


  934. static ngx_int_t
  935. ‌ngx_http_json_push(ngx_http_json_state_t *state, ngx_json_event_e event,
  936.     u_char *start, ngx_http_json_node_t *node)
  937. {
  938.     ngx_http_json_frame_t  *frame;

  940.     frame = ngx_array_push(&state->stack);
  941.     if (frame == NULL) {
  942.         return NGX_ERROR;
  943.     }

  945.     frame->index = 0;
  946.     frame->start = start;
  947.     frame->is_array = (event == NGX_JSON_ARRAY_OPEN);
  948.     frame->node = node;

  950.     return NGX_OK;
  951. }


  954. static void *
  955. ‌ngx_http_json_create_main_conf(ngx_conf_t *cf)
  956. {
  957.     ngx_http_json_main_conf_t  *jmcf;

  959.     jmcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_json_main_conf_t));
  960.     if (jmcf == NULL) {
  961.         return NULL;
  962.     }

  964.     jmcf->max_depth = NGX_CONF_UNSET;

  966.     return jmcf;
  967. }


  970. static char *
  971. ‌ngx_http_json_init_main_conf(ngx_conf_t *cf, void *conf)
  972. {
  973.     ngx_http_json_main_conf_t  *jmcf = conf;

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

  977.     return NGX_CONF_OK;
  978. }

One Level Up Top Level