One Level Up Top Level

src/http/ngx_http_script.c - nginx-1.31.4 nginx/ @ 8d9666701

Global variables defined

Functions defined

Macros defined

Source code


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


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


  13. static ngx_int_t ngx_http_script_init_arrays(ngx_http_script_compile_t *sc);
  14. static ngx_int_t ngx_http_script_done(ngx_http_script_compile_t *sc);
  15. static ngx_int_t ngx_http_script_add_copy_code(ngx_http_script_compile_t *sc,
  16.     ngx_str_t *value, ngx_uint_t last);
  17. static ngx_int_t ngx_http_script_add_var_code(ngx_http_script_compile_t *sc,
  18.     ngx_str_t *name);
  19. static ngx_int_t ngx_http_script_add_args_code(ngx_http_script_compile_t *sc);
  20. #if (NGX_PCRE)
  21. static ngx_int_t ngx_http_script_add_capture_code(ngx_http_script_compile_t *sc,
  22.     ngx_uint_t n);
  23. #endif
  24. static ngx_int_t
  25.     ngx_http_script_add_full_name_code(ngx_http_script_compile_t *sc);
  26. static size_t ngx_http_script_full_name_len_code(ngx_http_script_engine_t *e);
  27. static void ngx_http_script_full_name_code(ngx_http_script_engine_t *e);


  30. ‌#define ngx_http_script_exit  (u_char *) &ngx_http_script_exit_code

  32. ‌static uintptr_t ngx_http_script_exit_code = (uintptr_t) NULL;


  35. void
  36. ‌ngx_http_script_flush_complex_value(ngx_http_request_t *r,
  37.     ngx_http_complex_value_t *val)
  38. {
  39.     ngx_uint_t *index;

  41.     index = val->flushes;

  43.     if (index) {
  44.         while (*index != (ngx_uint_t) -1) {

  46.             if (r->variables[*index].no_cacheable) {
  47.                 r->variables[*index].valid = 0;
  48.                 r->variables[*index].not_found = 0;
  49.             }

  51.             index++;
  52.         }
  53.     }
  54. }


  57. ngx_int_t
  58. ‌ngx_http_complex_value(ngx_http_request_t *r, ngx_http_complex_value_t *val,
  59.     ngx_str_t *value)
  60. {
  61.     size_t                        len;
  62.     ngx_http_script_code_pt       code;
  63.     ngx_http_script_len_code_pt   lcode;
  64.     ngx_http_script_engine_t      e;

  66.     if (val->lengths == NULL) {
  67.         *value = val->value;
  68.         return NGX_OK;
  69.     }

  71.     ngx_http_script_flush_complex_value(r, val);

  73.     ngx_memzero(&e, sizeof(ngx_http_script_engine_t));

  75.     e.ip = val->lengths;
  76.     e.request = r;
  77.     e.flushed = 1;

  79.     len = 0;

  81.     while (*(uintptr_t *) e.ip) {
  82.         lcode = *(ngx_http_script_len_code_pt *) e.ip;
  83.         len += lcode(&e);
  84.     }

  86.     value->len = len;
  87.     value->data = ngx_pnalloc(r->pool, len);
  88.     if (value->data == NULL) {
  89.         return NGX_ERROR;
  90.     }

  92.     e.ip = val->values;
  93.     e.pos = value->data;
  94.     e.buf = *value;
  95.     e.end = value->data + len;

  97.     while (*(uintptr_t *) e.ip) {
  98.         code = *(ngx_http_script_code_pt *) e.ip;
  99.         code((ngx_http_script_engine_t *) &e);
  100.     }

  102.     if (e.status) {
  103.         return NGX_ERROR;
  104.     }

  106.     value->data = e.buf.data;
  107.     value->len = e.pos - e.buf.data;

  109.     return NGX_OK;
  110. }


  113. size_t
  114. ‌ngx_http_complex_value_size(ngx_http_request_t *r,
  115.     ngx_http_complex_value_t *val, size_t default_value)
  116. {
  117.     size_t     size;
  118.     ngx_str_t  value;

  120.     if (val == NULL) {
  121.         return default_value;
  122.     }

  124.     if (val->lengths == NULL) {
  125.         return val->u.size;
  126.     }

  128.     if (ngx_http_complex_value(r, val, &value) != NGX_OK) {
  129.         return default_value;
  130.     }

  132.     size = ngx_parse_size(&value);

  134.     if (size == (size_t) NGX_ERROR) {
  135.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  136.                       "invalid size \"%V\"", &value);
  137.         return default_value;
  138.     }

  140.     return size;
  141. }


  144. ngx_int_t
  145. ‌ngx_http_compile_complex_value(ngx_http_compile_complex_value_t *ccv)
  146. {
  147.     ngx_str_t                  *v;
  148.     ngx_uint_t                  i, n, nv, nc;
  149.     ngx_array_t                 flushes, lengths, values, *pf, *pl, *pv;
  150.     ngx_http_script_compile_t   sc;

  152.     v = ccv->value;

  154.     nv = 0;
  155.     nc = 0;

  157.     for (i = 0; i < v->len; i++) {
  158.         if (v->data[i] == '$') {
  159.             if (i + 1 < v->len
  160.                 && v->data[i + 1] >= '1' && v->data[i + 1] <= '9')
  161.             {
  162.                 nc++;

  164.             } else {
  165.                 nv++;
  166.             }
  167.         }
  168.     }

  170.     if ((v->len == 0 || v->data[0] != '$')
  171.         && (ccv->conf_prefix || ccv->root_prefix))
  172.     {
  173.         if (ngx_conf_full_name(ccv->cf->cycle, v, ccv->conf_prefix) != NGX_OK) {
  174.             return NGX_ERROR;
  175.         }

  177.         ccv->conf_prefix = 0;
  178.         ccv->root_prefix = 0;
  179.     }

  181.     ccv->complex_value->value = *v;
  182.     ccv->complex_value->flushes = NULL;
  183.     ccv->complex_value->lengths = NULL;
  184.     ccv->complex_value->values = NULL;

  186.     if (nv == 0 && nc == 0) {
  187.         return NGX_OK;
  188.     }

  190.     n = nv + 1;

  192.     if (ngx_array_init(&flushes, ccv->cf->pool, n, sizeof(ngx_uint_t))
  193.         != NGX_OK)
  194.     {
  195.         return NGX_ERROR;
  196.     }

  198.     n = nv * (2 * sizeof(ngx_http_script_copy_code_t)
  199.                   + sizeof(ngx_http_script_var_code_t))
  200.         + sizeof(uintptr_t);

  202.     if (ngx_array_init(&lengths, ccv->cf->pool, n, 1) != NGX_OK) {
  203.         return NGX_ERROR;
  204.     }

  206.     n = (nv * (2 * sizeof(ngx_http_script_copy_code_t)
  207.                    + sizeof(ngx_http_script_var_code_t))
  208.                 + sizeof(uintptr_t)
  209.                 + v->len
  210.                 + sizeof(uintptr_t) - 1)
  211.             & ~(sizeof(uintptr_t) - 1);

  213.     if (ngx_array_init(&values, ccv->cf->pool, n, 1) != NGX_OK) {
  214.         return NGX_ERROR;
  215.     }

  217.     pf = &flushes;
  218.     pl = &lengths;
  219.     pv = &values;

  221.     ngx_memzero(&sc, sizeof(ngx_http_script_compile_t));

  223.     sc.cf = ccv->cf;
  224.     sc.source = v;
  225.     sc.flushes = &pf;
  226.     sc.lengths = &pl;
  227.     sc.values = &pv;
  228.     sc.complete_lengths = 1;
  229.     sc.complete_values = 1;
  230.     sc.zero = ccv->zero;
  231.     sc.conf_prefix = ccv->conf_prefix;
  232.     sc.root_prefix = ccv->root_prefix;

  234.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  235.         return NGX_ERROR;
  236.     }

  238.     if (flushes.nelts) {
  239.         ccv->complex_value->flushes = flushes.elts;
  240.         ccv->complex_value->flushes[flushes.nelts] = (ngx_uint_t) -1;
  241.     }

  243.     ccv->complex_value->lengths = lengths.elts;
  244.     ccv->complex_value->values = values.elts;

  246.     return NGX_OK;
  247. }


  250. char *
  251. ‌ngx_http_set_complex_value_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  252. {
  253.     char  *p = conf;

  255.     ngx_str_t                          *value;
  256.     ngx_http_complex_value_t          **cv;
  257.     ngx_http_compile_complex_value_t    ccv;

  259.     cv = (ngx_http_complex_value_t **) (p + cmd->offset);

  261.     if (*cv != NGX_CONF_UNSET_PTR && *cv != NULL) {
  262.         return "is duplicate";
  263.     }

  265.     *cv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  266.     if (*cv == NULL) {
  267.         return NGX_CONF_ERROR;
  268.     }

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

  272.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  274.     ccv.cf = cf;
  275.     ccv.value = &value[1];
  276.     ccv.complex_value = *cv;

  278.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  279.         return NGX_CONF_ERROR;
  280.     }

  282.     return NGX_CONF_OK;
  283. }


  286. char *
  287. ‌ngx_http_set_complex_value_zero_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  288.     void *conf)
  289. {
  290.     char  *p = conf;

  292.     ngx_str_t                          *value;
  293.     ngx_http_complex_value_t          **cv;
  294.     ngx_http_compile_complex_value_t    ccv;

  296.     cv = (ngx_http_complex_value_t **) (p + cmd->offset);

  298.     if (*cv != NGX_CONF_UNSET_PTR) {
  299.         return "is duplicate";
  300.     }

  302.     *cv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  303.     if (*cv == NULL) {
  304.         return NGX_CONF_ERROR;
  305.     }

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

  309.     ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  311.     ccv.cf = cf;
  312.     ccv.value = &value[1];
  313.     ccv.complex_value = *cv;
  314.     ccv.zero = 1;

  316.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  317.         return NGX_CONF_ERROR;
  318.     }

  320.     return NGX_CONF_OK;
  321. }


  324. char *
  325. ‌ngx_http_set_complex_value_size_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  326.     void *conf)
  327. {
  328.     char  *p = conf;

  330.     char                      *rv;
  331.     ngx_http_complex_value_t  *cv;

  333.     rv = ngx_http_set_complex_value_slot(cf, cmd, conf);

  335.     if (rv != NGX_CONF_OK) {
  336.         return rv;
  337.     }

  339.     cv = *(ngx_http_complex_value_t **) (p + cmd->offset);

  341.     if (cv->lengths) {
  342.         return NGX_CONF_OK;
  343.     }

  345.     cv->u.size = ngx_parse_size(&cv->value);
  346.     if (cv->u.size == (size_t) NGX_ERROR) {
  347.         return "invalid value";
  348.     }

  350.     return NGX_CONF_OK;
  351. }


  354. ngx_int_t
  355. ‌ngx_http_test_predicates(ngx_http_request_t *r, ngx_array_t *predicates)
  356. {
  357.     ngx_str_t                  val;
  358.     ngx_uint_t                 i;
  359.     ngx_http_complex_value_t  *cv;

  361.     if (predicates == NULL) {
  362.         return NGX_OK;
  363.     }

  365.     cv = predicates->elts;

  367.     for (i = 0; i < predicates->nelts; i++) {
  368.         if (ngx_http_complex_value(r, &cv[i], &val) != NGX_OK) {
  369.             return NGX_ERROR;
  370.         }

  372.         if (val.len && (val.len != 1 || val.data[0] != '0')) {
  373.             return NGX_DECLINED;
  374.         }
  375.     }

  377.     return NGX_OK;
  378. }


  381. ngx_int_t
  382. ‌ngx_http_test_required_predicates(ngx_http_request_t *r,
  383.     ngx_array_t *predicates)
  384. {
  385.     ngx_str_t                  val;
  386.     ngx_uint_t                 i;
  387.     ngx_http_complex_value_t  *cv;

  389.     if (predicates == NULL) {
  390.         return NGX_OK;
  391.     }

  393.     cv = predicates->elts;

  395.     for (i = 0; i < predicates->nelts; i++) {
  396.         if (ngx_http_complex_value(r, &cv[i], &val) != NGX_OK) {
  397.             return NGX_ERROR;
  398.         }

  400.         if (val.len == 0 || (val.len == 1 && val.data[0] == '0')) {
  401.             return NGX_DECLINED;
  402.         }
  403.     }

  405.     return NGX_OK;
  406. }


  409. char *
  410. ‌ngx_http_set_predicate_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  411. {
  412.     char  *p = conf;

  414.     ngx_str_t                          *value;
  415.     ngx_uint_t                          i;
  416.     ngx_array_t                       **a;
  417.     ngx_http_complex_value_t           *cv;
  418.     ngx_http_compile_complex_value_t    ccv;

  420.     a = (ngx_array_t **) (p + cmd->offset);

  422.     if (*a == NGX_CONF_UNSET_PTR) {
  423.         *a = ngx_array_create(cf->pool, 1, sizeof(ngx_http_complex_value_t));
  424.         if (*a == NULL) {
  425.             return NGX_CONF_ERROR;
  426.         }
  427.     }

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

  431.     for (i = 1; i < cf->args->nelts; i++) {
  432.         cv = ngx_array_push(*a);
  433.         if (cv == NULL) {
  434.             return NGX_CONF_ERROR;
  435.         }

  437.         ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  439.         ccv.cf = cf;
  440.         ccv.value = &value[i];
  441.         ccv.complex_value = cv;

  443.         if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  444.             return NGX_CONF_ERROR;
  445.         }
  446.     }

  448.     return NGX_CONF_OK;
  449. }


  452. ngx_uint_t
  453. ‌ngx_http_script_variables_count(ngx_str_t *value)
  454. {
  455.     ngx_uint_t  i, n;

  457.     for (n = 0, i = 0; i < value->len; i++) {
  458.         if (value->data[i] == '$') {
  459.             n++;
  460.         }
  461.     }

  463.     return n;
  464. }


  467. ngx_int_t
  468. ‌ngx_http_script_compile(ngx_http_script_compile_t *sc)
  469. {
  470.     u_char       ch;
  471.     ngx_str_t    name;
  472.     ngx_uint_t   i, bracket;

  474.     if (ngx_http_script_init_arrays(sc) != NGX_OK) {
  475.         return NGX_ERROR;
  476.     }

  478.     for (i = 0; i < sc->source->len; /* void */ ) {

  480.         name.len = 0;

  482.         if (sc->source->data[i] == '$') {

  484.             if (++i == sc->source->len) {
  485.                 goto invalid_variable;
  486.             }

  488.             if (sc->source->data[i] >= '1' && sc->source->data[i] <= '9') {
  489. #if (NGX_PCRE)
  490.                 ngx_uint_t  n;

  492.                 n = sc->source->data[i] - '0';

  494.                 if (sc->captures_mask & ((ngx_uint_t) 1 << n)) {
  495.                     sc->dup_capture = 1;
  496.                 }

  498.                 sc->captures_mask |= (ngx_uint_t) 1 << n;

  500.                 if (ngx_http_script_add_capture_code(sc, n) != NGX_OK) {
  501.                     return NGX_ERROR;
  502.                 }

  504.                 i++;

  506.                 continue;
  507. #else
  508.                 ngx_conf_log_error(NGX_LOG_EMERG, sc->cf, 0,
  509.                                    "using variable \"$%c\" requires "
  510.                                    "PCRE library", sc->source->data[i]);
  511.                 return NGX_ERROR;
  512. #endif
  513.             }

  515.             if (sc->source->data[i] == '{') {
  516.                 bracket = 1;

  518.                 if (++i == sc->source->len) {
  519.                     goto invalid_variable;
  520.                 }

  522.                 name.data = &sc->source->data[i];

  524.             } else {
  525.                 bracket = 0;
  526.                 name.data = &sc->source->data[i];
  527.             }

  529.             for ( /* void */ ; i < sc->source->len; i++, name.len++) {
  530.                 ch = sc->source->data[i];

  532.                 if (ch == '}' && bracket) {
  533.                     i++;
  534.                     bracket = 0;
  535.                     break;
  536.                 }

  538.                 if ((ch >= 'A' && ch <= 'Z')
  539.                     || (ch >= 'a' && ch <= 'z')
  540.                     || (ch >= '0' && ch <= '9')
  541.                     || ch == '_')
  542.                 {
  543.                     continue;
  544.                 }

  546.                 break;
  547.             }

  549.             if (bracket) {
  550.                 ngx_conf_log_error(NGX_LOG_EMERG, sc->cf, 0,
  551.                                    "the closing bracket in \"%V\" "
  552.                                    "variable is missing", &name);
  553.                 return NGX_ERROR;
  554.             }

  556.             if (name.len == 0) {
  557.                 goto invalid_variable;
  558.             }

  560.             sc->variables++;

  562.             if (ngx_http_script_add_var_code(sc, &name) != NGX_OK) {
  563.                 return NGX_ERROR;
  564.             }

  566.             continue;
  567.         }

  569.         if (sc->source->data[i] == '?' && sc->compile_args) {
  570.             sc->args = 1;
  571.             sc->compile_args = 0;

  573.             if (ngx_http_script_add_args_code(sc) != NGX_OK) {
  574.                 return NGX_ERROR;
  575.             }

  577.             i++;

  579.             continue;
  580.         }

  582.         name.data = &sc->source->data[i];

  584.         while (i < sc->source->len) {

  586.             if (sc->source->data[i] == '$') {
  587.                 break;
  588.             }

  590.             if (sc->source->data[i] == '?') {

  592.                 sc->args = 1;

  594.                 if (sc->compile_args) {
  595.                     break;
  596.                 }
  597.             }

  599.             i++;
  600.             name.len++;
  601.         }

  603.         sc->size += name.len;

  605.         if (ngx_http_script_add_copy_code(sc, &name, (i == sc->source->len))
  606.             != NGX_OK)
  607.         {
  608.             return NGX_ERROR;
  609.         }
  610.     }

  612.     return ngx_http_script_done(sc);

  614. invalid_variable:

  616.     ngx_conf_log_error(NGX_LOG_EMERG, sc->cf, 0, "invalid variable name");

  618.     return NGX_ERROR;
  619. }


  622. u_char *
  623. ‌ngx_http_script_run(ngx_http_request_t *r, ngx_str_t *value,
  624.     void *code_lengths, size_t len, void *code_values)
  625. {
  626.     size_t                        n;
  627.     ngx_uint_t                    i;
  628.     ngx_http_script_code_pt       code;
  629.     ngx_http_script_len_code_pt   lcode;
  630.     ngx_http_script_engine_t      e;
  631.     ngx_http_core_main_conf_t    *cmcf;

  633.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  635.     for (i = 0; i < cmcf->variables.nelts; i++) {
  636.         if (r->variables[i].no_cacheable) {
  637.             r->variables[i].valid = 0;
  638.             r->variables[i].not_found = 0;
  639.         }
  640.     }

  642.     ngx_memzero(&e, sizeof(ngx_http_script_engine_t));

  644.     e.ip = code_lengths;
  645.     e.request = r;
  646.     e.flushed = 1;

  648.     n = len;

  650.     while (*(uintptr_t *) e.ip) {
  651.         lcode = *(ngx_http_script_len_code_pt *) e.ip;
  652.         n += lcode(&e);
  653.     }


  656.     value->len = n;
  657.     value->data = ngx_pnalloc(r->pool, n);
  658.     if (value->data == NULL) {
  659.         return NULL;
  660.     }

  662.     e.ip = code_values;
  663.     e.pos = value->data;
  664.     e.end = value->data + n;

  666.     while (*(uintptr_t *) e.ip) {
  667.         code = *(ngx_http_script_code_pt *) e.ip;
  668.         code((ngx_http_script_engine_t *) &e);
  669.     }

  671.     if (e.status) {
  672.         return NULL;
  673.     }

  675.     value->len = e.pos + len - value->data;

  677.     return e.pos;
  678. }


  681. void
  682. ‌ngx_http_script_flush_no_cacheable_variables(ngx_http_request_t *r,
  683.     ngx_array_t *indices)
  684. {
  685.     ngx_uint_t  n, *index;

  687.     if (indices) {
  688.         index = indices->elts;
  689.         for (n = 0; n < indices->nelts; n++) {
  690.             if (r->variables[index[n]].no_cacheable) {
  691.                 r->variables[index[n]].valid = 0;
  692.                 r->variables[index[n]].not_found = 0;
  693.             }
  694.         }
  695.     }
  696. }


  699. static ngx_int_t
  700. ‌ngx_http_script_init_arrays(ngx_http_script_compile_t *sc)
  701. {
  702.     ngx_uint_t   n;

  704.     if (sc->flushes && *sc->flushes == NULL) {
  705.         n = sc->variables ? sc->variables : 1;
  706.         *sc->flushes = ngx_array_create(sc->cf->pool, n, sizeof(ngx_uint_t));
  707.         if (*sc->flushes == NULL) {
  708.             return NGX_ERROR;
  709.         }
  710.     }

  712.     if (*sc->lengths == NULL) {
  713.         n = sc->variables * (2 * sizeof(ngx_http_script_copy_code_t)
  714.                              + sizeof(ngx_http_script_var_code_t))
  715.             + sizeof(uintptr_t);

  717.         *sc->lengths = ngx_array_create(sc->cf->pool, n, 1);
  718.         if (*sc->lengths == NULL) {
  719.             return NGX_ERROR;
  720.         }
  721.     }

  723.     if (*sc->values == NULL) {
  724.         n = (sc->variables * (2 * sizeof(ngx_http_script_copy_code_t)
  725.                               + sizeof(ngx_http_script_var_code_t))
  726.                 + sizeof(uintptr_t)
  727.                 + sc->source->len
  728.                 + sizeof(uintptr_t) - 1)
  729.             & ~(sizeof(uintptr_t) - 1);

  731.         *sc->values = ngx_array_create(sc->cf->pool, n, 1);
  732.         if (*sc->values == NULL) {
  733.             return NGX_ERROR;
  734.         }
  735.     }

  737.     sc->variables = 0;

  739.     return NGX_OK;
  740. }


  743. static ngx_int_t
  744. ‌ngx_http_script_done(ngx_http_script_compile_t *sc)
  745. {
  746.     ngx_str_t    zero;
  747.     uintptr_t   *code;

  749.     if (sc->zero) {

  751.         zero.len = 1;
  752.         zero.data = (u_char *) "\0";

  754.         if (ngx_http_script_add_copy_code(sc, &zero, 0) != NGX_OK) {
  755.             return NGX_ERROR;
  756.         }
  757.     }

  759.     if (sc->conf_prefix || sc->root_prefix) {
  760.         if (ngx_http_script_add_full_name_code(sc) != NGX_OK) {
  761.             return NGX_ERROR;
  762.         }
  763.     }

  765.     if (sc->complete_lengths) {
  766.         code = ngx_http_script_add_code(*sc->lengths, sizeof(uintptr_t), NULL);
  767.         if (code == NULL) {
  768.             return NGX_ERROR;
  769.         }

  771.         *code = (uintptr_t) NULL;
  772.     }

  774.     if (sc->complete_values) {
  775.         code = ngx_http_script_add_code(*sc->values, sizeof(uintptr_t),
  776.                                         &sc->main);
  777.         if (code == NULL) {
  778.             return NGX_ERROR;
  779.         }

  781.         *code = (uintptr_t) NULL;
  782.     }

  784.     return NGX_OK;
  785. }


  788. void *
  789. ‌ngx_http_script_start_code(ngx_pool_t *pool, ngx_array_t **codes, size_t size)
  790. {
  791.     if (*codes == NULL) {
  792.         *codes = ngx_array_create(pool, 256, 1);
  793.         if (*codes == NULL) {
  794.             return NULL;
  795.         }
  796.     }

  798.     return ngx_array_push_n(*codes, size);
  799. }


  802. void *
  803. ‌ngx_http_script_add_code(ngx_array_t *codes, size_t size, void *code)
  804. {
  805.     u_char  *elts, **p;
  806.     void    *new;

  808.     elts = codes->elts;

  810.     new = ngx_array_push_n(codes, size);
  811.     if (new == NULL) {
  812.         return NULL;
  813.     }

  815.     if (code) {
  816.         if (elts != codes->elts) {
  817.             p = code;
  818.             *p += (u_char *) codes->elts - elts;
  819.         }
  820.     }

  822.     return new;
  823. }


  826. ngx_int_t
  827. ‌ngx_http_script_check_length(ngx_http_script_engine_t *e, size_t len)
  828. {
  829.     if (e->end == NULL) {
  830.         return NGX_OK;
  831.     }

  833.     if (e->end - e->pos < (ssize_t) len) {
  834.         ngx_log_error(NGX_LOG_ALERT, e->request->connection->log, 0,
  835.                       "no buffer space in script copy");
  836.         e->ip = ngx_http_script_exit;
  837.         e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  838.         return NGX_ERROR;
  839.     }

  841.     return NGX_OK;
  842. }


  845. static ngx_int_t
  846. ‌ngx_http_script_add_copy_code(ngx_http_script_compile_t *sc, ngx_str_t *value,
  847.     ngx_uint_t last)
  848. {
  849.     u_char                       *p;
  850.     size_t                        size, len, zero;
  851.     ngx_http_script_copy_code_t  *code;

  853.     zero = (sc->zero && last);
  854.     len = value->len + zero;

  856.     code = ngx_http_script_add_code(*sc->lengths,
  857.                                     sizeof(ngx_http_script_copy_code_t), NULL);
  858.     if (code == NULL) {
  859.         return NGX_ERROR;
  860.     }

  862.     code->code = (ngx_http_script_code_pt) (void *)
  863.                                                  ngx_http_script_copy_len_code;
  864.     code->len = len;

  866.     size = (sizeof(ngx_http_script_copy_code_t) + len + sizeof(uintptr_t) - 1)
  867.             & ~(sizeof(uintptr_t) - 1);

  869.     code = ngx_http_script_add_code(*sc->values, size, &sc->main);
  870.     if (code == NULL) {
  871.         return NGX_ERROR;
  872.     }

  874.     code->code = ngx_http_script_copy_code;
  875.     code->len = len;

  877.     p = ngx_cpymem((u_char *) code + sizeof(ngx_http_script_copy_code_t),
  878.                    value->data, value->len);

  880.     if (zero) {
  881.         *p = '\0';
  882.         sc->zero = 0;
  883.     }

  885.     return NGX_OK;
  886. }


  889. size_t
  890. ‌ngx_http_script_copy_len_code(ngx_http_script_engine_t *e)
  891. {
  892.     ngx_http_script_copy_code_t  *code;

  894.     code = (ngx_http_script_copy_code_t *) e->ip;

  896.     e->ip += sizeof(ngx_http_script_copy_code_t);

  898.     return code->len;
  899. }


  902. void
  903. ‌ngx_http_script_copy_code(ngx_http_script_engine_t *e)
  904. {
  905.     u_char                       *p;
  906.     ngx_http_script_copy_code_t  *code;

  908.     code = (ngx_http_script_copy_code_t *) e->ip;

  910.     p = e->pos;

  912.     if (!e->skip) {

  914.         if (ngx_http_script_check_length(e, code->len) != NGX_OK) {
  915.             return;
  916.         }

  918.         e->pos = ngx_copy(p, e->ip + sizeof(ngx_http_script_copy_code_t),
  919.                           code->len);
  920.     }

  922.     e->ip += sizeof(ngx_http_script_copy_code_t)
  923.           + ((code->len + sizeof(uintptr_t) - 1) & ~(sizeof(uintptr_t) - 1));

  925.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  926.                    "http script copy: \"%*s\"", e->pos - p, p);
  927. }


  930. static ngx_int_t
  931. ‌ngx_http_script_add_var_code(ngx_http_script_compile_t *sc, ngx_str_t *name)
  932. {
  933.     ngx_int_t                    index, *p;
  934.     ngx_http_script_var_code_t  *code;

  936.     index = ngx_http_get_variable_index(sc->cf, name);

  938.     if (index == NGX_ERROR) {
  939.         return NGX_ERROR;
  940.     }

  942.     if (sc->flushes) {
  943.         p = ngx_array_push(*sc->flushes);
  944.         if (p == NULL) {
  945.             return NGX_ERROR;
  946.         }

  948.         *p = index;
  949.     }

  951.     code = ngx_http_script_add_code(*sc->lengths,
  952.                                     sizeof(ngx_http_script_var_code_t), NULL);
  953.     if (code == NULL) {
  954.         return NGX_ERROR;
  955.     }

  957.     code->code = (ngx_http_script_code_pt) (void *)
  958.                                              ngx_http_script_copy_var_len_code;
  959.     code->index = (uintptr_t) index;

  961.     code = ngx_http_script_add_code(*sc->values,
  962.                                     sizeof(ngx_http_script_var_code_t),
  963.                                     &sc->main);
  964.     if (code == NULL) {
  965.         return NGX_ERROR;
  966.     }

  968.     code->code = ngx_http_script_copy_var_code;
  969.     code->index = (uintptr_t) index;

  971.     return NGX_OK;
  972. }


  975. size_t
  976. ‌ngx_http_script_copy_var_len_code(ngx_http_script_engine_t *e)
  977. {
  978.     ngx_http_variable_value_t   *value;
  979.     ngx_http_script_var_code_t  *code;

  981.     code = (ngx_http_script_var_code_t *) e->ip;

  983.     e->ip += sizeof(ngx_http_script_var_code_t);

  985.     if (e->flushed) {
  986.         value = ngx_http_get_indexed_variable(e->request, code->index);

  988.     } else {
  989.         value = ngx_http_get_flushed_variable(e->request, code->index);
  990.     }

  992.     if (value && !value->not_found) {
  993.         return value->len;
  994.     }

  996.     return 0;
  997. }


  1000. void
  1001. ‌ngx_http_script_copy_var_code(ngx_http_script_engine_t *e)
  1002. {
  1003.     u_char                      *p;
  1004.     ngx_http_variable_value_t   *value;
  1005.     ngx_http_script_var_code_t  *code;

  1007.     code = (ngx_http_script_var_code_t *) e->ip;

  1009.     e->ip += sizeof(ngx_http_script_var_code_t);

  1011.     if (!e->skip) {

  1013.         if (e->flushed) {
  1014.             value = ngx_http_get_indexed_variable(e->request, code->index);

  1016.         } else {
  1017.             value = ngx_http_get_flushed_variable(e->request, code->index);
  1018.         }

  1020.         if (value && !value->not_found) {

  1022.             if (ngx_http_script_check_length(e, value->len) != NGX_OK) {
  1023.                 return;
  1024.             }

  1026.             p = e->pos;
  1027.             e->pos = ngx_copy(p, value->data, value->len);

  1029.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP,
  1030.                            e->request->connection->log, 0,
  1031.                            "http script var: \"%*s\"", e->pos - p, p);
  1032.         }
  1033.     }
  1034. }


  1037. static ngx_int_t
  1038. ‌ngx_http_script_add_args_code(ngx_http_script_compile_t *sc)
  1039. {
  1040.     uintptr_t   *code;

  1042.     code = ngx_http_script_add_code(*sc->lengths, sizeof(uintptr_t), NULL);
  1043.     if (code == NULL) {
  1044.         return NGX_ERROR;
  1045.     }

  1047.     *code = (uintptr_t) ngx_http_script_mark_args_code;

  1049.     code = ngx_http_script_add_code(*sc->values, sizeof(uintptr_t), &sc->main);
  1050.     if (code == NULL) {
  1051.         return NGX_ERROR;
  1052.     }

  1054.     *code = (uintptr_t) ngx_http_script_start_args_code;

  1056.     return NGX_OK;
  1057. }


  1060. size_t
  1061. ‌ngx_http_script_mark_args_code(ngx_http_script_engine_t *e)
  1062. {
  1063.     e->is_args = 1;
  1064.     e->ip += sizeof(uintptr_t);

  1066.     return 1;
  1067. }


  1070. void
  1071. ‌ngx_http_script_start_args_code(ngx_http_script_engine_t *e)
  1072. {
  1073.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1074.                    "http script args");

  1076.     e->is_args = 1;
  1077.     e->args = e->pos;
  1078.     e->ip += sizeof(uintptr_t);
  1079. }


  1082. #if (NGX_PCRE)

  1084. void
  1085. ‌ngx_http_script_regex_start_code(ngx_http_script_engine_t *e)
  1086. {
  1087.     int                           *cap;
  1088.     u_char                        *p;
  1089.     size_t                         len;
  1090.     ngx_int_t                      rc;
  1091.     ngx_uint_t                     n;
  1092.     ngx_http_request_t            *r;
  1093.     ngx_http_script_engine_t       le;
  1094.     ngx_http_script_len_code_pt    lcode;
  1095.     ngx_http_script_regex_code_t  *code;

  1097.     code = (ngx_http_script_regex_code_t *) e->ip;

  1099.     r = e->request;

  1101.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1102.                    "http script regex: \"%V\"", &code->name);

  1104.     if (code->uri) {
  1105.         e->line = r->uri;
  1106.     } else {
  1107.         e->sp--;
  1108.         e->line.len = e->sp->len;
  1109.         e->line.data = e->sp->data;
  1110.     }

  1112.     rc = ngx_http_regex_exec(r, code->regex, &e->line);

  1114.     if (rc == NGX_DECLINED) {
  1115.         if (e->log || (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP)) {
  1116.             ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
  1117.                           "\"%V\" does not match \"%V\"",
  1118.                           &code->name, &e->line);
  1119.         }

  1121.         r->ncaptures = 0;

  1123.         if (code->test) {
  1124.             if (code->negative_test) {
  1125.                 e->sp->len = 1;
  1126.                 e->sp->data = (u_char *) "1";

  1128.             } else {
  1129.                 e->sp->len = 0;
  1130.                 e->sp->data = (u_char *) "";
  1131.             }

  1133.             e->sp++;

  1135.             e->ip += sizeof(ngx_http_script_regex_code_t);
  1136.             return;
  1137.         }

  1139.         e->ip += code->next;
  1140.         return;
  1141.     }

  1143.     if (rc == NGX_ERROR) {
  1144.         e->ip = ngx_http_script_exit;
  1145.         e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1146.         return;
  1147.     }

  1149.     if (e->log || (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP)) {
  1150.         ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
  1151.                       "\"%V\" matches \"%V\"", &code->name, &e->line);
  1152.     }

  1154.     if (code->test) {
  1155.         if (code->negative_test) {
  1156.             e->sp->len = 0;
  1157.             e->sp->data = (u_char *) "";

  1159.         } else {
  1160.             e->sp->len = 1;
  1161.             e->sp->data = (u_char *) "1";
  1162.         }

  1164.         e->sp++;

  1166.         e->ip += sizeof(ngx_http_script_regex_code_t);
  1167.         return;
  1168.     }

  1170.     if (code->status) {
  1171.         e->status = code->status;

  1173.         if (!code->redirect) {
  1174.             e->ip = ngx_http_script_exit;
  1175.             return;
  1176.         }
  1177.     }

  1179.     if (code->uri) {
  1180.         r->internal = 1;
  1181.         r->valid_unparsed_uri = 0;

  1183.         if (code->break_cycle) {
  1184.             r->valid_location = 0;
  1185.             r->uri_changed = 0;

  1187.         } else {
  1188.             r->uri_changed = 1;
  1189.         }
  1190.     }

  1192.     if (code->lengths == NULL) {
  1193.         e->buf.len = code->size;

  1195.         cap = r->captures;
  1196.         p = r->captures_data;

  1198.         for (n = 2; n < r->ncaptures; n += 2) {
  1199.             e->buf.len += cap[n + 1] - cap[n];

  1201.             if (code->uri) {
  1202.                 if (r->quoted_uri || r->plus_in_uri) {
  1203.                     e->buf.len += 2 * ngx_escape_uri(NULL, &p[cap[n]],
  1204.                                                      cap[n + 1] - cap[n],
  1205.                                                      NGX_ESCAPE_ARGS);
  1206.                 }
  1207.             }
  1208.         }

  1210.     } else {
  1211.         ngx_memzero(&le, sizeof(ngx_http_script_engine_t));

  1213.         le.ip = code->lengths->elts;
  1214.         le.line = e->line;
  1215.         le.request = r;
  1216.         le.quote = code->redirect;

  1218.         len = 0;

  1220.         while (*(uintptr_t *) le.ip) {
  1221.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1222.             len += lcode(&le);
  1223.         }

  1225.         e->buf.len = len;
  1226.     }

  1228.     if (code->add_args && r->args.len) {
  1229.         e->buf.len += r->args.len + 1;
  1230.     }

  1232.     e->buf.data = ngx_pnalloc(r->pool, e->buf.len);
  1233.     if (e->buf.data == NULL) {
  1234.         e->ip = ngx_http_script_exit;
  1235.         e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1236.         return;
  1237.     }

  1239.     e->is_args = 0;
  1240.     e->quote = code->redirect;

  1242.     e->pos = e->buf.data;
  1243.     e->end = e->buf.data + e->buf.len;

  1245.     e->ip += sizeof(ngx_http_script_regex_code_t);
  1246. }


  1249. void
  1250. ‌ngx_http_script_regex_end_code(ngx_http_script_engine_t *e)
  1251. {
  1252.     u_char                            *dst, *src;
  1253.     ngx_http_request_t                *r;
  1254.     ngx_http_script_regex_end_code_t  *code;

  1256.     code = (ngx_http_script_regex_end_code_t *) e->ip;

  1258.     r = e->request;

  1260.     e->is_args = 0;
  1261.     e->quote = 0;

  1263.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1264.                    "http script regex end");

  1266.     if (code->redirect) {

  1268.         dst = e->buf.data;
  1269.         src = e->buf.data;

  1271.         ngx_unescape_uri(&dst, &src, e->pos - e->buf.data,
  1272.                          NGX_UNESCAPE_REDIRECT);

  1274.         if (src < e->pos) {
  1275.             dst = ngx_movemem(dst, src, e->pos - src);
  1276.         }

  1278.         e->pos = dst;

  1280.         if (code->add_args && r->args.len) {

  1282.             if (ngx_http_script_check_length(e, r->args.len + 1) != NGX_OK) {
  1283.                 return;
  1284.             }

  1286.             *e->pos++ = (u_char) (code->args ? '&' : '?');
  1287.             e->pos = ngx_copy(e->pos, r->args.data, r->args.len);
  1288.         }

  1290.         e->buf.len = e->pos - e->buf.data;

  1292.         if (e->log || (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP)) {
  1293.             ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
  1294.                           "rewritten redirect: \"%V\"", &e->buf);
  1295.         }

  1297.         ngx_http_clear_location(r);

  1299.         r->headers_out.location = ngx_list_push(&r->headers_out.headers);
  1300.         if (r->headers_out.location == NULL) {
  1301.             e->ip = ngx_http_script_exit;
  1302.             e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1303.             return;
  1304.         }

  1306.         r->headers_out.location->hash = 1;
  1307.         r->headers_out.location->next = NULL;
  1308.         ngx_str_set(&r->headers_out.location->key, "Location");
  1309.         r->headers_out.location->value = e->buf;

  1311.         e->ip += sizeof(ngx_http_script_regex_end_code_t);
  1312.         return;
  1313.     }

  1315.     if (e->args) {
  1316.         e->buf.len = e->args - e->buf.data;

  1318.         if (code->add_args && r->args.len) {

  1320.             if (ngx_http_script_check_length(e, r->args.len + 1) != NGX_OK) {
  1321.                 return;
  1322.             }

  1324.             *e->pos++ = '&';
  1325.             e->pos = ngx_copy(e->pos, r->args.data, r->args.len);
  1326.         }

  1328.         r->args.len = e->pos - e->args;
  1329.         r->args.data = e->args;

  1331.         e->args = NULL;

  1333.     } else {
  1334.         e->buf.len = e->pos - e->buf.data;

  1336.         if (!code->add_args) {
  1337.             r->args.len = 0;
  1338.         }
  1339.     }

  1341.     if (e->log || (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP)) {
  1342.         ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
  1343.                       "rewritten data: \"%V\", args: \"%V\"",
  1344.                       &e->buf, &r->args);
  1345.     }

  1347.     if (code->uri) {
  1348.         r->uri = e->buf;

  1350.         if (r->uri.len == 0) {
  1351.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1352.                           "the rewritten URI has a zero length");
  1353.             e->ip = ngx_http_script_exit;
  1354.             e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1355.             return;
  1356.         }

  1358.         ngx_http_set_exten(r);
  1359.     }

  1361.     e->ip += sizeof(ngx_http_script_regex_end_code_t);
  1362. }


  1365. static ngx_int_t
  1366. ‌ngx_http_script_add_capture_code(ngx_http_script_compile_t *sc, ngx_uint_t n)
  1367. {
  1368.     ngx_http_script_copy_capture_code_t  *code;

  1370.     code = ngx_http_script_add_code(*sc->lengths,
  1371.                                     sizeof(ngx_http_script_copy_capture_code_t),
  1372.                                     NULL);
  1373.     if (code == NULL) {
  1374.         return NGX_ERROR;
  1375.     }

  1377.     code->code = (ngx_http_script_code_pt) (void *)
  1378.                                          ngx_http_script_copy_capture_len_code;
  1379.     code->n = 2 * n;


  1382.     code = ngx_http_script_add_code(*sc->values,
  1383.                                     sizeof(ngx_http_script_copy_capture_code_t),
  1384.                                     &sc->main);
  1385.     if (code == NULL) {
  1386.         return NGX_ERROR;
  1387.     }

  1389.     code->code = ngx_http_script_copy_capture_code;
  1390.     code->n = 2 * n;

  1392.     if (sc->ncaptures < n) {
  1393.         sc->ncaptures = n;
  1394.     }

  1396.     return NGX_OK;
  1397. }


  1400. size_t
  1401. ‌ngx_http_script_copy_capture_len_code(ngx_http_script_engine_t *e)
  1402. {
  1403.     int                                  *cap;
  1404.     u_char                               *p;
  1405.     size_t                                len;
  1406.     ngx_uint_t                            n;
  1407.     ngx_http_request_t                   *r;
  1408.     ngx_http_script_copy_capture_code_t  *code;

  1410.     r = e->request;

  1412.     code = (ngx_http_script_copy_capture_code_t *) e->ip;

  1414.     e->ip += sizeof(ngx_http_script_copy_capture_code_t);

  1416.     n = code->n;

  1418.     if (n < r->ncaptures) {

  1420.         cap = r->captures;
  1421.         len = cap[n + 1] - cap[n];

  1423.         if ((e->is_args || e->quote)
  1424.             && (e->request->quoted_uri || e->request->plus_in_uri))
  1425.         {
  1426.             p = r->captures_data + cap[n];

  1428.             return len + 2 * ngx_escape_uri(NULL, p, len, NGX_ESCAPE_ARGS);

  1430.         } else {
  1431.             return len;
  1432.         }
  1433.     }

  1435.     return 0;
  1436. }


  1439. void
  1440. ‌ngx_http_script_copy_capture_code(ngx_http_script_engine_t *e)
  1441. {
  1442.     int                                  *cap;
  1443.     u_char                               *p, *pos;
  1444.     size_t                                len;
  1445.     uintptr_t                             escape;
  1446.     ngx_uint_t                            n;
  1447.     ngx_http_request_t                   *r;
  1448.     ngx_http_script_copy_capture_code_t  *code;

  1450.     r = e->request;

  1452.     code = (ngx_http_script_copy_capture_code_t *) e->ip;

  1454.     e->ip += sizeof(ngx_http_script_copy_capture_code_t);

  1456.     n = code->n;

  1458.     pos = e->pos;

  1460.     if (n < r->ncaptures) {

  1462.         cap = r->captures;
  1463.         len = cap[n + 1] - cap[n];
  1464.         p = r->captures_data + cap[n];

  1466.         if ((e->is_args || e->quote)
  1467.             && (e->request->quoted_uri || e->request->plus_in_uri))
  1468.         {
  1469.             escape = 2 * ngx_escape_uri(NULL, p, len, NGX_ESCAPE_ARGS);

  1471.             if (ngx_http_script_check_length(e, len + escape) != NGX_OK) {
  1472.                 return;
  1473.             }

  1475.             e->pos = (u_char *) ngx_escape_uri(pos, p, len, NGX_ESCAPE_ARGS);

  1477.         } else {

  1479.             if (ngx_http_script_check_length(e, len) != NGX_OK) {
  1480.                 return;
  1481.             }

  1483.             e->pos = ngx_copy(pos, p, len);
  1484.         }
  1485.     }

  1487.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1488.                    "http script capture: \"%*s\"", e->pos - pos, pos);
  1489. }

  1491. #endif


  1494. static ngx_int_t
  1495. ‌ngx_http_script_add_full_name_code(ngx_http_script_compile_t *sc)
  1496. {
  1497.     ngx_http_script_full_name_code_t  *code;

  1499.     code = ngx_http_script_add_code(*sc->lengths,
  1500.                                     sizeof(ngx_http_script_full_name_code_t),
  1501.                                     NULL);
  1502.     if (code == NULL) {
  1503.         return NGX_ERROR;
  1504.     }

  1506.     code->code = (ngx_http_script_code_pt) (void *)
  1507.                                             ngx_http_script_full_name_len_code;
  1508.     code->conf_prefix = sc->conf_prefix;

  1510.     code = ngx_http_script_add_code(*sc->values,
  1511.                                     sizeof(ngx_http_script_full_name_code_t),
  1512.                                     &sc->main);
  1513.     if (code == NULL) {
  1514.         return NGX_ERROR;
  1515.     }

  1517.     code->code = ngx_http_script_full_name_code;
  1518.     code->conf_prefix = sc->conf_prefix;

  1520.     return NGX_OK;
  1521. }


  1524. static size_t
  1525. ‌ngx_http_script_full_name_len_code(ngx_http_script_engine_t *e)
  1526. {
  1527.     ngx_http_script_full_name_code_t  *code;

  1529.     code = (ngx_http_script_full_name_code_t *) e->ip;

  1531.     e->ip += sizeof(ngx_http_script_full_name_code_t);

  1533.     return code->conf_prefix ? ngx_cycle->conf_prefix.len:
  1534.                                ngx_cycle->prefix.len;
  1535. }


  1538. static void
  1539. ‌ngx_http_script_full_name_code(ngx_http_script_engine_t *e)
  1540. {
  1541.     ngx_http_script_full_name_code_t  *code;

  1543.     ngx_str_t  value, *prefix;

  1545.     code = (ngx_http_script_full_name_code_t *) e->ip;

  1547.     value.data = e->buf.data;
  1548.     value.len = e->pos - e->buf.data;

  1550.     prefix = code->conf_prefix ? (ngx_str_t *) &ngx_cycle->conf_prefix:
  1551.                                  (ngx_str_t *) &ngx_cycle->prefix;

  1553.     if (ngx_get_full_name(e->request->pool, prefix, &value) != NGX_OK) {
  1554.         e->ip = ngx_http_script_exit;
  1555.         e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1556.         return;
  1557.     }

  1559.     e->buf = value;
  1560.     e->pos = value.data + value.len;
  1561.     e->end = e->pos;

  1563.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1564.                    "http script fullname: \"%V\"", &value);

  1566.     e->ip += sizeof(ngx_http_script_full_name_code_t);
  1567. }


  1570. void
  1571. ‌ngx_http_script_return_code(ngx_http_script_engine_t *e)
  1572. {
  1573.     ngx_http_script_return_code_t  *code;

  1575.     code = (ngx_http_script_return_code_t *) e->ip;

  1577.     if (code->status < NGX_HTTP_BAD_REQUEST
  1578.         || code->text.value.len
  1579.         || code->text.lengths)
  1580.     {
  1581.         e->status = ngx_http_send_response(e->request, code->status, NULL,
  1582.                                            &code->text);
  1583.     } else {
  1584.         e->status = code->status;
  1585.     }

  1587.     e->ip = ngx_http_script_exit;
  1588. }


  1591. void
  1592. ‌ngx_http_script_break_code(ngx_http_script_engine_t *e)
  1593. {
  1594.     ngx_http_request_t  *r;

  1596.     r = e->request;

  1598.     if (r->uri_changed) {
  1599.         r->valid_location = 0;
  1600.         r->uri_changed = 0;
  1601.     }

  1603.     e->ip = ngx_http_script_exit;
  1604. }


  1607. void
  1608. ‌ngx_http_script_if_code(ngx_http_script_engine_t *e)
  1609. {
  1610.     ngx_http_script_if_code_t  *code;

  1612.     code = (ngx_http_script_if_code_t *) e->ip;

  1614.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1615.                    "http script if");

  1617.     e->sp--;

  1619.     if (e->sp->len && (e->sp->len != 1 || e->sp->data[0] != '0')) {
  1620.         if (code->loc_conf) {
  1621.             e->request->loc_conf = code->loc_conf;
  1622.             ngx_http_update_location_config(e->request);
  1623.         }

  1625.         e->ip += sizeof(ngx_http_script_if_code_t);
  1626.         return;
  1627.     }

  1629.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1630.                    "http script if: false");

  1632.     e->ip += code->next;
  1633. }


  1636. void
  1637. ‌ngx_http_script_equal_code(ngx_http_script_engine_t *e)
  1638. {
  1639.     ngx_http_variable_value_t  *val, *res;

  1641.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1642.                    "http script equal");

  1644.     e->sp--;
  1645.     val = e->sp;
  1646.     res = e->sp - 1;

  1648.     e->ip += sizeof(uintptr_t);

  1650.     if (val->len == res->len
  1651.         && ngx_strncmp(val->data, res->data, res->len) == 0)
  1652.     {
  1653.         *res = ngx_http_variable_true_value;
  1654.         return;
  1655.     }

  1657.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1658.                    "http script equal: no");

  1660.     *res = ngx_http_variable_null_value;
  1661. }


  1664. void
  1665. ‌ngx_http_script_not_equal_code(ngx_http_script_engine_t *e)
  1666. {
  1667.     ngx_http_variable_value_t  *val, *res;

  1669.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1670.                    "http script not equal");

  1672.     e->sp--;
  1673.     val = e->sp;
  1674.     res = e->sp - 1;

  1676.     e->ip += sizeof(uintptr_t);

  1678.     if (val->len == res->len
  1679.         && ngx_strncmp(val->data, res->data, res->len) == 0)
  1680.     {
  1681.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1682.                        "http script not equal: no");

  1684.         *res = ngx_http_variable_null_value;
  1685.         return;
  1686.     }

  1688.     *res = ngx_http_variable_true_value;
  1689. }


  1692. void
  1693. ‌ngx_http_script_file_code(ngx_http_script_engine_t *e)
  1694. {
  1695.     ngx_str_t                     path;
  1696.     ngx_http_request_t           *r;
  1697.     ngx_open_file_info_t          of;
  1698.     ngx_http_core_loc_conf_t     *clcf;
  1699.     ngx_http_variable_value_t    *value;
  1700.     ngx_http_script_file_code_t  *code;

  1702.     value = e->sp - 1;

  1704.     code = (ngx_http_script_file_code_t *) e->ip;
  1705.     e->ip += sizeof(ngx_http_script_file_code_t);

  1707.     path.len = value->len - 1;
  1708.     path.data = value->data;

  1710.     r = e->request;

  1712.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1713.                    "http script file op %p \"%V\"", (void *) code->op, &path);

  1715.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  1717.     ngx_memzero(&of, sizeof(ngx_open_file_info_t));

  1719.     of.read_ahead = clcf->read_ahead;
  1720.     of.directio = clcf->directio;
  1721.     of.valid = clcf->open_file_cache_valid;
  1722.     of.min_uses = clcf->open_file_cache_min_uses;
  1723.     of.test_only = 1;
  1724.     of.errors = clcf->open_file_cache_errors;
  1725.     of.events = clcf->open_file_cache_events;

  1727.     if (ngx_http_set_disable_symlinks(r, clcf, &path, &of) != NGX_OK) {
  1728.         e->ip = ngx_http_script_exit;
  1729.         e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1730.         return;
  1731.     }

  1733.     if (ngx_open_cached_file(clcf->open_file_cache, &path, &of, r->pool)
  1734.         != NGX_OK)
  1735.     {
  1736.         if (of.err == 0) {
  1737.             e->ip = ngx_http_script_exit;
  1738.             e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1739.             return;
  1740.         }

  1742.         if (of.err != NGX_ENOENT
  1743.             && of.err != NGX_ENOTDIR
  1744.             && of.err != NGX_ENAMETOOLONG)
  1745.         {
  1746.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, of.err,
  1747.                           "%s \"%s\" failed", of.failed, value->data);
  1748.         }

  1750.         switch (code->op) {

  1752.         case ngx_http_script_file_plain:
  1753.         case ngx_http_script_file_dir:
  1754.         case ngx_http_script_file_exists:
  1755.         case ngx_http_script_file_exec:
  1756.              goto false_value;

  1758.         case ngx_http_script_file_not_plain:
  1759.         case ngx_http_script_file_not_dir:
  1760.         case ngx_http_script_file_not_exists:
  1761.         case ngx_http_script_file_not_exec:
  1762.              goto true_value;
  1763.         }

  1765.         goto false_value;
  1766.     }

  1768.     switch (code->op) {
  1769.     case ngx_http_script_file_plain:
  1770.         if (of.is_file) {
  1771.              goto true_value;
  1772.         }
  1773.         goto false_value;

  1775.     case ngx_http_script_file_not_plain:
  1776.         if (of.is_file) {
  1777.             goto false_value;
  1778.         }
  1779.         goto true_value;

  1781.     case ngx_http_script_file_dir:
  1782.         if (of.is_dir) {
  1783.              goto true_value;
  1784.         }
  1785.         goto false_value;

  1787.     case ngx_http_script_file_not_dir:
  1788.         if (of.is_dir) {
  1789.             goto false_value;
  1790.         }
  1791.         goto true_value;

  1793.     case ngx_http_script_file_exists:
  1794.         if (of.is_file || of.is_dir || of.is_link) {
  1795.              goto true_value;
  1796.         }
  1797.         goto false_value;

  1799.     case ngx_http_script_file_not_exists:
  1800.         if (of.is_file || of.is_dir || of.is_link) {
  1801.             goto false_value;
  1802.         }
  1803.         goto true_value;

  1805.     case ngx_http_script_file_exec:
  1806.         if (of.is_exec) {
  1807.              goto true_value;
  1808.         }
  1809.         goto false_value;

  1811.     case ngx_http_script_file_not_exec:
  1812.         if (of.is_exec) {
  1813.             goto false_value;
  1814.         }
  1815.         goto true_value;
  1816.     }

  1818. false_value:

  1820.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1821.                    "http script file op false");

  1823.     *value = ngx_http_variable_null_value;
  1824.     return;

  1826. true_value:

  1828.     *value = ngx_http_variable_true_value;
  1829.     return;
  1830. }


  1833. void
  1834. ‌ngx_http_script_complex_value_code(ngx_http_script_engine_t *e)
  1835. {
  1836.     size_t                                 len;
  1837.     ngx_http_script_engine_t               le;
  1838.     ngx_http_script_len_code_pt            lcode;
  1839.     ngx_http_script_complex_value_code_t  *code;

  1841.     code = (ngx_http_script_complex_value_code_t *) e->ip;

  1843.     e->ip += sizeof(ngx_http_script_complex_value_code_t);

  1845.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1846.                    "http script complex value");

  1848.     ngx_memzero(&le, sizeof(ngx_http_script_engine_t));

  1850.     le.ip = code->lengths->elts;
  1851.     le.line = e->line;
  1852.     le.request = e->request;
  1853.     le.is_args = e->is_args;
  1854.     le.quote = e->quote;

  1856.     for (len = 0; *(uintptr_t *) le.ip; len += lcode(&le)) {
  1857.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1858.     }

  1860.     e->buf.len = len;
  1861.     e->buf.data = ngx_pnalloc(e->request->pool, len);
  1862.     if (e->buf.data == NULL) {
  1863.         e->ip = ngx_http_script_exit;
  1864.         e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1865.         return;
  1866.     }

  1868.     e->pos = e->buf.data;
  1869.     e->end = e->buf.data + len;

  1871.     e->sp->len = e->buf.len;
  1872.     e->sp->data = e->buf.data;
  1873.     e->sp++;
  1874. }


  1877. void
  1878. ‌ngx_http_script_complex_value_end_code(ngx_http_script_engine_t *e)
  1879. {
  1880.     ngx_http_variable_value_t  *val;

  1882.     val = e->sp - 1;

  1884.     e->ip += sizeof(ngx_http_script_complex_value_end_code_t);

  1886.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1887.                    "http script complex value end");

  1889.     if (val->data == e->buf.data) {
  1890.         val->len = e->pos - e->buf.data;
  1891.     }
  1892. }


  1895. void
  1896. ‌ngx_http_script_value_code(ngx_http_script_engine_t *e)
  1897. {
  1898.     ngx_http_script_value_code_t  *code;

  1900.     code = (ngx_http_script_value_code_t *) e->ip;

  1902.     e->ip += sizeof(ngx_http_script_value_code_t);

  1904.     e->sp->len = code->text_len;
  1905.     e->sp->data = (u_char *) code->text_data;

  1907.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1908.                    "http script value: \"%v\"", e->sp);

  1910.     e->sp++;
  1911. }


  1914. void
  1915. ‌ngx_http_script_set_var_code(ngx_http_script_engine_t *e)
  1916. {
  1917.     ngx_http_request_t          *r;
  1918.     ngx_http_script_var_code_t  *code;

  1920.     code = (ngx_http_script_var_code_t *) e->ip;

  1922.     e->ip += sizeof(ngx_http_script_var_code_t);

  1924.     r = e->request;

  1926.     e->sp--;

  1928.     r->variables[code->index].len = e->sp->len;
  1929.     r->variables[code->index].valid = 1;
  1930.     r->variables[code->index].no_cacheable = 0;
  1931.     r->variables[code->index].not_found = 0;
  1932.     r->variables[code->index].data = e->sp->data;

  1934. #if (NGX_DEBUG)
  1935.     {
  1936.     ngx_http_variable_t        *v;
  1937.     ngx_http_core_main_conf_t  *cmcf;

  1939.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  1941.     v = cmcf->variables.elts;

  1943.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1944.                    "http script set $%V", &v[code->index].name);
  1945.     }
  1946. #endif
  1947. }


  1950. void
  1951. ‌ngx_http_script_var_set_handler_code(ngx_http_script_engine_t *e)
  1952. {
  1953.     ngx_http_script_var_handler_code_t  *code;

  1955.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1956.                    "http script set var handler");

  1958.     code = (ngx_http_script_var_handler_code_t *) e->ip;

  1960.     e->ip += sizeof(ngx_http_script_var_handler_code_t);

  1962.     e->sp--;

  1964.     code->handler(e->request, e->sp, code->data);
  1965. }


  1968. void
  1969. ‌ngx_http_script_var_code(ngx_http_script_engine_t *e)
  1970. {
  1971.     ngx_http_variable_value_t   *value;
  1972.     ngx_http_script_var_code_t  *code;

  1974.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1975.                    "http script var");

  1977.     code = (ngx_http_script_var_code_t *) e->ip;

  1979.     e->ip += sizeof(ngx_http_script_var_code_t);

  1981.     value = ngx_http_get_flushed_variable(e->request, code->index);

  1983.     if (value && !value->not_found) {
  1984.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1985.                        "http script var: \"%v\"", value);

  1987.         *e->sp = *value;
  1988.         e->sp++;

  1990.         return;
  1991.     }

  1993.     *e->sp = ngx_http_variable_null_value;
  1994.     e->sp++;
  1995. }


  1998. void
  1999. ‌ngx_http_script_nop_code(ngx_http_script_engine_t *e)
  2000. {
  2001.     e->ip += sizeof(uintptr_t);
  2002. }

One Level Up Top Level