One Level Up Top Level

src/http/ngx_http_script.c - nginx-1.31.3 nginx/ @ 42f8df65b

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;

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

  101.     *value = e.buf;

  103.     return NGX_OK;
  104. }


  107. size_t
  108. ‌ngx_http_complex_value_size(ngx_http_request_t *r,
  109.     ngx_http_complex_value_t *val, size_t default_value)
  110. {
  111.     size_t     size;
  112.     ngx_str_t  value;

  114.     if (val == NULL) {
  115.         return default_value;
  116.     }

  118.     if (val->lengths == NULL) {
  119.         return val->u.size;
  120.     }

  122.     if (ngx_http_complex_value(r, val, &value) != NGX_OK) {
  123.         return default_value;
  124.     }

  126.     size = ngx_parse_size(&value);

  128.     if (size == (size_t) NGX_ERROR) {
  129.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  130.                       "invalid size \"%V\"", &value);
  131.         return default_value;
  132.     }

  134.     return size;
  135. }


  138. ngx_int_t
  139. ‌ngx_http_compile_complex_value(ngx_http_compile_complex_value_t *ccv)
  140. {
  141.     ngx_str_t                  *v;
  142.     ngx_uint_t                  i, n, nv, nc;
  143.     ngx_array_t                 flushes, lengths, values, *pf, *pl, *pv;
  144.     ngx_http_script_compile_t   sc;

  146.     v = ccv->value;

  148.     nv = 0;
  149.     nc = 0;

  151.     for (i = 0; i < v->len; i++) {
  152.         if (v->data[i] == '$') {
  153.             if (i + 1 < v->len
  154.                 && v->data[i + 1] >= '1' && v->data[i + 1] <= '9')
  155.             {
  156.                 nc++;

  158.             } else {
  159.                 nv++;
  160.             }
  161.         }
  162.     }

  164.     if ((v->len == 0 || v->data[0] != '$')
  165.         && (ccv->conf_prefix || ccv->root_prefix))
  166.     {
  167.         if (ngx_conf_full_name(ccv->cf->cycle, v, ccv->conf_prefix) != NGX_OK) {
  168.             return NGX_ERROR;
  169.         }

  171.         ccv->conf_prefix = 0;
  172.         ccv->root_prefix = 0;
  173.     }

  175.     ccv->complex_value->value = *v;
  176.     ccv->complex_value->flushes = NULL;
  177.     ccv->complex_value->lengths = NULL;
  178.     ccv->complex_value->values = NULL;

  180.     if (nv == 0 && nc == 0) {
  181.         return NGX_OK;
  182.     }

  184.     n = nv + 1;

  186.     if (ngx_array_init(&flushes, ccv->cf->pool, n, sizeof(ngx_uint_t))
  187.         != NGX_OK)
  188.     {
  189.         return NGX_ERROR;
  190.     }

  192.     n = nv * (2 * sizeof(ngx_http_script_copy_code_t)
  193.                   + sizeof(ngx_http_script_var_code_t))
  194.         + sizeof(uintptr_t);

  196.     if (ngx_array_init(&lengths, ccv->cf->pool, n, 1) != NGX_OK) {
  197.         return NGX_ERROR;
  198.     }

  200.     n = (nv * (2 * sizeof(ngx_http_script_copy_code_t)
  201.                    + sizeof(ngx_http_script_var_code_t))
  202.                 + sizeof(uintptr_t)
  203.                 + v->len
  204.                 + sizeof(uintptr_t) - 1)
  205.             & ~(sizeof(uintptr_t) - 1);

  207.     if (ngx_array_init(&values, ccv->cf->pool, n, 1) != NGX_OK) {
  208.         return NGX_ERROR;
  209.     }

  211.     pf = &flushes;
  212.     pl = &lengths;
  213.     pv = &values;

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

  217.     sc.cf = ccv->cf;
  218.     sc.source = v;
  219.     sc.flushes = &pf;
  220.     sc.lengths = &pl;
  221.     sc.values = &pv;
  222.     sc.complete_lengths = 1;
  223.     sc.complete_values = 1;
  224.     sc.zero = ccv->zero;
  225.     sc.conf_prefix = ccv->conf_prefix;
  226.     sc.root_prefix = ccv->root_prefix;

  228.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  229.         return NGX_ERROR;
  230.     }

  232.     if (flushes.nelts) {
  233.         ccv->complex_value->flushes = flushes.elts;
  234.         ccv->complex_value->flushes[flushes.nelts] = (ngx_uint_t) -1;
  235.     }

  237.     ccv->complex_value->lengths = lengths.elts;
  238.     ccv->complex_value->values = values.elts;

  240.     return NGX_OK;
  241. }


  244. char *
  245. ‌ngx_http_set_complex_value_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  246. {
  247.     char  *p = conf;

  249.     ngx_str_t                          *value;
  250.     ngx_http_complex_value_t          **cv;
  251.     ngx_http_compile_complex_value_t    ccv;

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

  255.     if (*cv != NGX_CONF_UNSET_PTR && *cv != NULL) {
  256.         return "is duplicate";
  257.     }

  259.     *cv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  260.     if (*cv == NULL) {
  261.         return NGX_CONF_ERROR;
  262.     }

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

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

  268.     ccv.cf = cf;
  269.     ccv.value = &value[1];
  270.     ccv.complex_value = *cv;

  272.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  273.         return NGX_CONF_ERROR;
  274.     }

  276.     return NGX_CONF_OK;
  277. }


  280. char *
  281. ‌ngx_http_set_complex_value_zero_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  282.     void *conf)
  283. {
  284.     char  *p = conf;

  286.     ngx_str_t                          *value;
  287.     ngx_http_complex_value_t          **cv;
  288.     ngx_http_compile_complex_value_t    ccv;

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

  292.     if (*cv != NGX_CONF_UNSET_PTR) {
  293.         return "is duplicate";
  294.     }

  296.     *cv = ngx_palloc(cf->pool, sizeof(ngx_http_complex_value_t));
  297.     if (*cv == NULL) {
  298.         return NGX_CONF_ERROR;
  299.     }

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

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

  305.     ccv.cf = cf;
  306.     ccv.value = &value[1];
  307.     ccv.complex_value = *cv;
  308.     ccv.zero = 1;

  310.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  311.         return NGX_CONF_ERROR;
  312.     }

  314.     return NGX_CONF_OK;
  315. }


  318. char *
  319. ‌ngx_http_set_complex_value_size_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  320.     void *conf)
  321. {
  322.     char  *p = conf;

  324.     char                      *rv;
  325.     ngx_http_complex_value_t  *cv;

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

  329.     if (rv != NGX_CONF_OK) {
  330.         return rv;
  331.     }

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

  335.     if (cv->lengths) {
  336.         return NGX_CONF_OK;
  337.     }

  339.     cv->u.size = ngx_parse_size(&cv->value);
  340.     if (cv->u.size == (size_t) NGX_ERROR) {
  341.         return "invalid value";
  342.     }

  344.     return NGX_CONF_OK;
  345. }


  348. ngx_int_t
  349. ‌ngx_http_test_predicates(ngx_http_request_t *r, ngx_array_t *predicates)
  350. {
  351.     ngx_str_t                  val;
  352.     ngx_uint_t                 i;
  353.     ngx_http_complex_value_t  *cv;

  355.     if (predicates == NULL) {
  356.         return NGX_OK;
  357.     }

  359.     cv = predicates->elts;

  361.     for (i = 0; i < predicates->nelts; i++) {
  362.         if (ngx_http_complex_value(r, &cv[i], &val) != NGX_OK) {
  363.             return NGX_ERROR;
  364.         }

  366.         if (val.len && (val.len != 1 || val.data[0] != '0')) {
  367.             return NGX_DECLINED;
  368.         }
  369.     }

  371.     return NGX_OK;
  372. }


  375. ngx_int_t
  376. ‌ngx_http_test_required_predicates(ngx_http_request_t *r,
  377.     ngx_array_t *predicates)
  378. {
  379.     ngx_str_t                  val;
  380.     ngx_uint_t                 i;
  381.     ngx_http_complex_value_t  *cv;

  383.     if (predicates == NULL) {
  384.         return NGX_OK;
  385.     }

  387.     cv = predicates->elts;

  389.     for (i = 0; i < predicates->nelts; i++) {
  390.         if (ngx_http_complex_value(r, &cv[i], &val) != NGX_OK) {
  391.             return NGX_ERROR;
  392.         }

  394.         if (val.len == 0 || (val.len == 1 && val.data[0] == '0')) {
  395.             return NGX_DECLINED;
  396.         }
  397.     }

  399.     return NGX_OK;
  400. }


  403. char *
  404. ‌ngx_http_set_predicate_slot(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  405. {
  406.     char  *p = conf;

  408.     ngx_str_t                          *value;
  409.     ngx_uint_t                          i;
  410.     ngx_array_t                       **a;
  411.     ngx_http_complex_value_t           *cv;
  412.     ngx_http_compile_complex_value_t    ccv;

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

  416.     if (*a == NGX_CONF_UNSET_PTR) {
  417.         *a = ngx_array_create(cf->pool, 1, sizeof(ngx_http_complex_value_t));
  418.         if (*a == NULL) {
  419.             return NGX_CONF_ERROR;
  420.         }
  421.     }

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

  425.     for (i = 1; i < cf->args->nelts; i++) {
  426.         cv = ngx_array_push(*a);
  427.         if (cv == NULL) {
  428.             return NGX_CONF_ERROR;
  429.         }

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

  433.         ccv.cf = cf;
  434.         ccv.value = &value[i];
  435.         ccv.complex_value = cv;

  437.         if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  438.             return NGX_CONF_ERROR;
  439.         }
  440.     }

  442.     return NGX_CONF_OK;
  443. }


  446. ngx_uint_t
  447. ‌ngx_http_script_variables_count(ngx_str_t *value)
  448. {
  449.     ngx_uint_t  i, n;

  451.     for (n = 0, i = 0; i < value->len; i++) {
  452.         if (value->data[i] == '$') {
  453.             n++;
  454.         }
  455.     }

  457.     return n;
  458. }


  461. ngx_int_t
  462. ‌ngx_http_script_compile(ngx_http_script_compile_t *sc)
  463. {
  464.     u_char       ch;
  465.     ngx_str_t    name;
  466.     ngx_uint_t   i, bracket;

  468.     if (ngx_http_script_init_arrays(sc) != NGX_OK) {
  469.         return NGX_ERROR;
  470.     }

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

  474.         name.len = 0;

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

  478.             if (++i == sc->source->len) {
  479.                 goto invalid_variable;
  480.             }

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

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

  488.                 if (sc->captures_mask & ((ngx_uint_t) 1 << n)) {
  489.                     sc->dup_capture = 1;
  490.                 }

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

  494.                 if (ngx_http_script_add_capture_code(sc, n) != NGX_OK) {
  495.                     return NGX_ERROR;
  496.                 }

  498.                 i++;

  500.                 continue;
  501. #else
  502.                 ngx_conf_log_error(NGX_LOG_EMERG, sc->cf, 0,
  503.                                    "using variable \"$%c\" requires "
  504.                                    "PCRE library", sc->source->data[i]);
  505.                 return NGX_ERROR;
  506. #endif
  507.             }

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

  512.                 if (++i == sc->source->len) {
  513.                     goto invalid_variable;
  514.                 }

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

  518.             } else {
  519.                 bracket = 0;
  520.                 name.data = &sc->source->data[i];
  521.             }

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

  526.                 if (ch == '}' && bracket) {
  527.                     i++;
  528.                     bracket = 0;
  529.                     break;
  530.                 }

  532.                 if ((ch >= 'A' && ch <= 'Z')
  533.                     || (ch >= 'a' && ch <= 'z')
  534.                     || (ch >= '0' && ch <= '9')
  535.                     || ch == '_')
  536.                 {
  537.                     continue;
  538.                 }

  540.                 break;
  541.             }

  543.             if (bracket) {
  544.                 ngx_conf_log_error(NGX_LOG_EMERG, sc->cf, 0,
  545.                                    "the closing bracket in \"%V\" "
  546.                                    "variable is missing", &name);
  547.                 return NGX_ERROR;
  548.             }

  550.             if (name.len == 0) {
  551.                 goto invalid_variable;
  552.             }

  554.             sc->variables++;

  556.             if (ngx_http_script_add_var_code(sc, &name) != NGX_OK) {
  557.                 return NGX_ERROR;
  558.             }

  560.             continue;
  561.         }

  563.         if (sc->source->data[i] == '?' && sc->compile_args) {
  564.             sc->args = 1;
  565.             sc->compile_args = 0;

  567.             if (ngx_http_script_add_args_code(sc) != NGX_OK) {
  568.                 return NGX_ERROR;
  569.             }

  571.             i++;

  573.             continue;
  574.         }

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

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

  580.             if (sc->source->data[i] == '$') {
  581.                 break;
  582.             }

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

  586.                 sc->args = 1;

  588.                 if (sc->compile_args) {
  589.                     break;
  590.                 }
  591.             }

  593.             i++;
  594.             name.len++;
  595.         }

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

  599.         if (ngx_http_script_add_copy_code(sc, &name, (i == sc->source->len))
  600.             != NGX_OK)
  601.         {
  602.             return NGX_ERROR;
  603.         }
  604.     }

  606.     return ngx_http_script_done(sc);

  608. invalid_variable:

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

  612.     return NGX_ERROR;
  613. }


  616. u_char *
  617. ‌ngx_http_script_run(ngx_http_request_t *r, ngx_str_t *value,
  618.     void *code_lengths, size_t len, void *code_values)
  619. {
  620.     ngx_uint_t                    i;
  621.     ngx_http_script_code_pt       code;
  622.     ngx_http_script_len_code_pt   lcode;
  623.     ngx_http_script_engine_t      e;
  624.     ngx_http_core_main_conf_t    *cmcf;

  626.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  628.     for (i = 0; i < cmcf->variables.nelts; i++) {
  629.         if (r->variables[i].no_cacheable) {
  630.             r->variables[i].valid = 0;
  631.             r->variables[i].not_found = 0;
  632.         }
  633.     }

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

  637.     e.ip = code_lengths;
  638.     e.request = r;
  639.     e.flushed = 1;

  641.     while (*(uintptr_t *) e.ip) {
  642.         lcode = *(ngx_http_script_len_code_pt *) e.ip;
  643.         len += lcode(&e);
  644.     }


  647.     value->len = len;
  648.     value->data = ngx_pnalloc(r->pool, len);
  649.     if (value->data == NULL) {
  650.         return NULL;
  651.     }

  653.     e.ip = code_values;
  654.     e.pos = value->data;

  656.     while (*(uintptr_t *) e.ip) {
  657.         code = *(ngx_http_script_code_pt *) e.ip;
  658.         code((ngx_http_script_engine_t *) &e);
  659.     }

  661.     return e.pos;
  662. }


  665. void
  666. ‌ngx_http_script_flush_no_cacheable_variables(ngx_http_request_t *r,
  667.     ngx_array_t *indices)
  668. {
  669.     ngx_uint_t  n, *index;

  671.     if (indices) {
  672.         index = indices->elts;
  673.         for (n = 0; n < indices->nelts; n++) {
  674.             if (r->variables[index[n]].no_cacheable) {
  675.                 r->variables[index[n]].valid = 0;
  676.                 r->variables[index[n]].not_found = 0;
  677.             }
  678.         }
  679.     }
  680. }


  683. static ngx_int_t
  684. ‌ngx_http_script_init_arrays(ngx_http_script_compile_t *sc)
  685. {
  686.     ngx_uint_t   n;

  688.     if (sc->flushes && *sc->flushes == NULL) {
  689.         n = sc->variables ? sc->variables : 1;
  690.         *sc->flushes = ngx_array_create(sc->cf->pool, n, sizeof(ngx_uint_t));
  691.         if (*sc->flushes == NULL) {
  692.             return NGX_ERROR;
  693.         }
  694.     }

  696.     if (*sc->lengths == NULL) {
  697.         n = sc->variables * (2 * sizeof(ngx_http_script_copy_code_t)
  698.                              + sizeof(ngx_http_script_var_code_t))
  699.             + sizeof(uintptr_t);

  701.         *sc->lengths = ngx_array_create(sc->cf->pool, n, 1);
  702.         if (*sc->lengths == NULL) {
  703.             return NGX_ERROR;
  704.         }
  705.     }

  707.     if (*sc->values == NULL) {
  708.         n = (sc->variables * (2 * sizeof(ngx_http_script_copy_code_t)
  709.                               + sizeof(ngx_http_script_var_code_t))
  710.                 + sizeof(uintptr_t)
  711.                 + sc->source->len
  712.                 + sizeof(uintptr_t) - 1)
  713.             & ~(sizeof(uintptr_t) - 1);

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

  721.     sc->variables = 0;

  723.     return NGX_OK;
  724. }


  727. static ngx_int_t
  728. ‌ngx_http_script_done(ngx_http_script_compile_t *sc)
  729. {
  730.     ngx_str_t    zero;
  731.     uintptr_t   *code;

  733.     if (sc->zero) {

  735.         zero.len = 1;
  736.         zero.data = (u_char *) "\0";

  738.         if (ngx_http_script_add_copy_code(sc, &zero, 0) != NGX_OK) {
  739.             return NGX_ERROR;
  740.         }
  741.     }

  743.     if (sc->conf_prefix || sc->root_prefix) {
  744.         if (ngx_http_script_add_full_name_code(sc) != NGX_OK) {
  745.             return NGX_ERROR;
  746.         }
  747.     }

  749.     if (sc->complete_lengths) {
  750.         code = ngx_http_script_add_code(*sc->lengths, sizeof(uintptr_t), NULL);
  751.         if (code == NULL) {
  752.             return NGX_ERROR;
  753.         }

  755.         *code = (uintptr_t) NULL;
  756.     }

  758.     if (sc->complete_values) {
  759.         code = ngx_http_script_add_code(*sc->values, sizeof(uintptr_t),
  760.                                         &sc->main);
  761.         if (code == NULL) {
  762.             return NGX_ERROR;
  763.         }

  765.         *code = (uintptr_t) NULL;
  766.     }

  768.     return NGX_OK;
  769. }


  772. void *
  773. ‌ngx_http_script_start_code(ngx_pool_t *pool, ngx_array_t **codes, size_t size)
  774. {
  775.     if (*codes == NULL) {
  776.         *codes = ngx_array_create(pool, 256, 1);
  777.         if (*codes == NULL) {
  778.             return NULL;
  779.         }
  780.     }

  782.     return ngx_array_push_n(*codes, size);
  783. }


  786. void *
  787. ‌ngx_http_script_add_code(ngx_array_t *codes, size_t size, void *code)
  788. {
  789.     u_char  *elts, **p;
  790.     void    *new;

  792.     elts = codes->elts;

  794.     new = ngx_array_push_n(codes, size);
  795.     if (new == NULL) {
  796.         return NULL;
  797.     }

  799.     if (code) {
  800.         if (elts != codes->elts) {
  801.             p = code;
  802.             *p += (u_char *) codes->elts - elts;
  803.         }
  804.     }

  806.     return new;
  807. }


  810. static ngx_int_t
  811. ‌ngx_http_script_add_copy_code(ngx_http_script_compile_t *sc, ngx_str_t *value,
  812.     ngx_uint_t last)
  813. {
  814.     u_char                       *p;
  815.     size_t                        size, len, zero;
  816.     ngx_http_script_copy_code_t  *code;

  818.     zero = (sc->zero && last);
  819.     len = value->len + zero;

  821.     code = ngx_http_script_add_code(*sc->lengths,
  822.                                     sizeof(ngx_http_script_copy_code_t), NULL);
  823.     if (code == NULL) {
  824.         return NGX_ERROR;
  825.     }

  827.     code->code = (ngx_http_script_code_pt) (void *)
  828.                                                  ngx_http_script_copy_len_code;
  829.     code->len = len;

  831.     size = (sizeof(ngx_http_script_copy_code_t) + len + sizeof(uintptr_t) - 1)
  832.             & ~(sizeof(uintptr_t) - 1);

  834.     code = ngx_http_script_add_code(*sc->values, size, &sc->main);
  835.     if (code == NULL) {
  836.         return NGX_ERROR;
  837.     }

  839.     code->code = ngx_http_script_copy_code;
  840.     code->len = len;

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

  845.     if (zero) {
  846.         *p = '\0';
  847.         sc->zero = 0;
  848.     }

  850.     return NGX_OK;
  851. }


  854. size_t
  855. ‌ngx_http_script_copy_len_code(ngx_http_script_engine_t *e)
  856. {
  857.     ngx_http_script_copy_code_t  *code;

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

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

  863.     return code->len;
  864. }


  867. void
  868. ‌ngx_http_script_copy_code(ngx_http_script_engine_t *e)
  869. {
  870.     u_char                       *p;
  871.     ngx_http_script_copy_code_t  *code;

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

  875.     p = e->pos;

  877.     if (!e->skip) {
  878.         e->pos = ngx_copy(p, e->ip + sizeof(ngx_http_script_copy_code_t),
  879.                           code->len);
  880.     }

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

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


  890. static ngx_int_t
  891. ‌ngx_http_script_add_var_code(ngx_http_script_compile_t *sc, ngx_str_t *name)
  892. {
  893.     ngx_int_t                    index, *p;
  894.     ngx_http_script_var_code_t  *code;

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

  898.     if (index == NGX_ERROR) {
  899.         return NGX_ERROR;
  900.     }

  902.     if (sc->flushes) {
  903.         p = ngx_array_push(*sc->flushes);
  904.         if (p == NULL) {
  905.             return NGX_ERROR;
  906.         }

  908.         *p = index;
  909.     }

  911.     code = ngx_http_script_add_code(*sc->lengths,
  912.                                     sizeof(ngx_http_script_var_code_t), NULL);
  913.     if (code == NULL) {
  914.         return NGX_ERROR;
  915.     }

  917.     code->code = (ngx_http_script_code_pt) (void *)
  918.                                              ngx_http_script_copy_var_len_code;
  919.     code->index = (uintptr_t) index;

  921.     code = ngx_http_script_add_code(*sc->values,
  922.                                     sizeof(ngx_http_script_var_code_t),
  923.                                     &sc->main);
  924.     if (code == NULL) {
  925.         return NGX_ERROR;
  926.     }

  928.     code->code = ngx_http_script_copy_var_code;
  929.     code->index = (uintptr_t) index;

  931.     return NGX_OK;
  932. }


  935. size_t
  936. ‌ngx_http_script_copy_var_len_code(ngx_http_script_engine_t *e)
  937. {
  938.     ngx_http_variable_value_t   *value;
  939.     ngx_http_script_var_code_t  *code;

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

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

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

  948.     } else {
  949.         value = ngx_http_get_flushed_variable(e->request, code->index);
  950.     }

  952.     if (value && !value->not_found) {
  953.         return value->len;
  954.     }

  956.     return 0;
  957. }


  960. void
  961. ‌ngx_http_script_copy_var_code(ngx_http_script_engine_t *e)
  962. {
  963.     u_char                      *p;
  964.     ngx_http_variable_value_t   *value;
  965.     ngx_http_script_var_code_t  *code;

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

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

  971.     if (!e->skip) {

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

  976.         } else {
  977.             value = ngx_http_get_flushed_variable(e->request, code->index);
  978.         }

  980.         if (value && !value->not_found) {
  981.             p = e->pos;
  982.             e->pos = ngx_copy(p, value->data, value->len);

  984.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP,
  985.                            e->request->connection->log, 0,
  986.                            "http script var: \"%*s\"", e->pos - p, p);
  987.         }
  988.     }
  989. }


  992. static ngx_int_t
  993. ‌ngx_http_script_add_args_code(ngx_http_script_compile_t *sc)
  994. {
  995.     uintptr_t   *code;

  997.     code = ngx_http_script_add_code(*sc->lengths, sizeof(uintptr_t), NULL);
  998.     if (code == NULL) {
  999.         return NGX_ERROR;
  1000.     }

  1002.     *code = (uintptr_t) ngx_http_script_mark_args_code;

  1004.     code = ngx_http_script_add_code(*sc->values, sizeof(uintptr_t), &sc->main);
  1005.     if (code == NULL) {
  1006.         return NGX_ERROR;
  1007.     }

  1009.     *code = (uintptr_t) ngx_http_script_start_args_code;

  1011.     return NGX_OK;
  1012. }


  1015. size_t
  1016. ‌ngx_http_script_mark_args_code(ngx_http_script_engine_t *e)
  1017. {
  1018.     e->is_args = 1;
  1019.     e->ip += sizeof(uintptr_t);

  1021.     return 1;
  1022. }


  1025. void
  1026. ‌ngx_http_script_start_args_code(ngx_http_script_engine_t *e)
  1027. {
  1028.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1029.                    "http script args");

  1031.     e->is_args = 1;
  1032.     e->args = e->pos;
  1033.     e->ip += sizeof(uintptr_t);
  1034. }


  1037. #if (NGX_PCRE)

  1039. void
  1040. ‌ngx_http_script_regex_start_code(ngx_http_script_engine_t *e)
  1041. {
  1042.     int                           *cap;
  1043.     u_char                        *p;
  1044.     size_t                         len;
  1045.     ngx_int_t                      rc;
  1046.     ngx_uint_t                     n;
  1047.     ngx_http_request_t            *r;
  1048.     ngx_http_script_engine_t       le;
  1049.     ngx_http_script_len_code_pt    lcode;
  1050.     ngx_http_script_regex_code_t  *code;

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

  1054.     r = e->request;

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

  1059.     if (code->uri) {
  1060.         e->line = r->uri;
  1061.     } else {
  1062.         e->sp--;
  1063.         e->line.len = e->sp->len;
  1064.         e->line.data = e->sp->data;
  1065.     }

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

  1069.     if (rc == NGX_DECLINED) {
  1070.         if (e->log || (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP)) {
  1071.             ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
  1072.                           "\"%V\" does not match \"%V\"",
  1073.                           &code->name, &e->line);
  1074.         }

  1076.         r->ncaptures = 0;

  1078.         if (code->test) {
  1079.             if (code->negative_test) {
  1080.                 e->sp->len = 1;
  1081.                 e->sp->data = (u_char *) "1";

  1083.             } else {
  1084.                 e->sp->len = 0;
  1085.                 e->sp->data = (u_char *) "";
  1086.             }

  1088.             e->sp++;

  1090.             e->ip += sizeof(ngx_http_script_regex_code_t);
  1091.             return;
  1092.         }

  1094.         e->ip += code->next;
  1095.         return;
  1096.     }

  1098.     if (rc == NGX_ERROR) {
  1099.         e->ip = ngx_http_script_exit;
  1100.         e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1101.         return;
  1102.     }

  1104.     if (e->log || (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP)) {
  1105.         ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
  1106.                       "\"%V\" matches \"%V\"", &code->name, &e->line);
  1107.     }

  1109.     if (code->test) {
  1110.         if (code->negative_test) {
  1111.             e->sp->len = 0;
  1112.             e->sp->data = (u_char *) "";

  1114.         } else {
  1115.             e->sp->len = 1;
  1116.             e->sp->data = (u_char *) "1";
  1117.         }

  1119.         e->sp++;

  1121.         e->ip += sizeof(ngx_http_script_regex_code_t);
  1122.         return;
  1123.     }

  1125.     if (code->status) {
  1126.         e->status = code->status;

  1128.         if (!code->redirect) {
  1129.             e->ip = ngx_http_script_exit;
  1130.             return;
  1131.         }
  1132.     }

  1134.     if (code->uri) {
  1135.         r->internal = 1;
  1136.         r->valid_unparsed_uri = 0;

  1138.         if (code->break_cycle) {
  1139.             r->valid_location = 0;
  1140.             r->uri_changed = 0;

  1142.         } else {
  1143.             r->uri_changed = 1;
  1144.         }
  1145.     }

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

  1150.         cap = r->captures;
  1151.         p = r->captures_data;

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

  1156.             if (code->uri) {
  1157.                 if (r->quoted_uri || r->plus_in_uri) {
  1158.                     e->buf.len += 2 * ngx_escape_uri(NULL, &p[cap[n]],
  1159.                                                      cap[n + 1] - cap[n],
  1160.                                                      NGX_ESCAPE_ARGS);
  1161.                 }
  1162.             }
  1163.         }

  1165.     } else {
  1166.         ngx_memzero(&le, sizeof(ngx_http_script_engine_t));

  1168.         le.ip = code->lengths->elts;
  1169.         le.line = e->line;
  1170.         le.request = r;
  1171.         le.quote = code->redirect;

  1173.         len = 0;

  1175.         while (*(uintptr_t *) le.ip) {
  1176.             lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1177.             len += lcode(&le);
  1178.         }

  1180.         e->buf.len = len;
  1181.     }

  1183.     if (code->add_args && r->args.len) {
  1184.         e->buf.len += r->args.len + 1;
  1185.     }

  1187.     e->buf.data = ngx_pnalloc(r->pool, e->buf.len);
  1188.     if (e->buf.data == NULL) {
  1189.         e->ip = ngx_http_script_exit;
  1190.         e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1191.         return;
  1192.     }

  1194.     e->is_args = 0;
  1195.     e->quote = code->redirect;

  1197.     e->pos = e->buf.data;

  1199.     e->ip += sizeof(ngx_http_script_regex_code_t);
  1200. }


  1203. void
  1204. ‌ngx_http_script_regex_end_code(ngx_http_script_engine_t *e)
  1205. {
  1206.     u_char                            *dst, *src;
  1207.     ngx_http_request_t                *r;
  1208.     ngx_http_script_regex_end_code_t  *code;

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

  1212.     r = e->request;

  1214.     e->is_args = 0;
  1215.     e->quote = 0;

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

  1220.     if (code->redirect) {

  1222.         dst = e->buf.data;
  1223.         src = e->buf.data;

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

  1228.         if (src < e->pos) {
  1229.             dst = ngx_movemem(dst, src, e->pos - src);
  1230.         }

  1232.         e->pos = dst;

  1234.         if (code->add_args && r->args.len) {
  1235.             *e->pos++ = (u_char) (code->args ? '&' : '?');
  1236.             e->pos = ngx_copy(e->pos, r->args.data, r->args.len);
  1237.         }

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

  1241.         if (e->log || (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP)) {
  1242.             ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
  1243.                           "rewritten redirect: \"%V\"", &e->buf);
  1244.         }

  1246.         ngx_http_clear_location(r);

  1248.         r->headers_out.location = ngx_list_push(&r->headers_out.headers);
  1249.         if (r->headers_out.location == NULL) {
  1250.             e->ip = ngx_http_script_exit;
  1251.             e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1252.             return;
  1253.         }

  1255.         r->headers_out.location->hash = 1;
  1256.         r->headers_out.location->next = NULL;
  1257.         ngx_str_set(&r->headers_out.location->key, "Location");
  1258.         r->headers_out.location->value = e->buf;

  1260.         e->ip += sizeof(ngx_http_script_regex_end_code_t);
  1261.         return;
  1262.     }

  1264.     if (e->args) {
  1265.         e->buf.len = e->args - e->buf.data;

  1267.         if (code->add_args && r->args.len) {
  1268.             *e->pos++ = '&';
  1269.             e->pos = ngx_copy(e->pos, r->args.data, r->args.len);
  1270.         }

  1272.         r->args.len = e->pos - e->args;
  1273.         r->args.data = e->args;

  1275.         e->args = NULL;

  1277.     } else {
  1278.         e->buf.len = e->pos - e->buf.data;

  1280.         if (!code->add_args) {
  1281.             r->args.len = 0;
  1282.         }
  1283.     }

  1285.     if (e->log || (r->connection->log->log_level & NGX_LOG_DEBUG_HTTP)) {
  1286.         ngx_log_error(NGX_LOG_NOTICE, r->connection->log, 0,
  1287.                       "rewritten data: \"%V\", args: \"%V\"",
  1288.                       &e->buf, &r->args);
  1289.     }

  1291.     if (code->uri) {
  1292.         r->uri = e->buf;

  1294.         if (r->uri.len == 0) {
  1295.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1296.                           "the rewritten URI has a zero length");
  1297.             e->ip = ngx_http_script_exit;
  1298.             e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1299.             return;
  1300.         }

  1302.         ngx_http_set_exten(r);
  1303.     }

  1305.     e->ip += sizeof(ngx_http_script_regex_end_code_t);
  1306. }


  1309. static ngx_int_t
  1310. ‌ngx_http_script_add_capture_code(ngx_http_script_compile_t *sc, ngx_uint_t n)
  1311. {
  1312.     ngx_http_script_copy_capture_code_t  *code;

  1314.     code = ngx_http_script_add_code(*sc->lengths,
  1315.                                     sizeof(ngx_http_script_copy_capture_code_t),
  1316.                                     NULL);
  1317.     if (code == NULL) {
  1318.         return NGX_ERROR;
  1319.     }

  1321.     code->code = (ngx_http_script_code_pt) (void *)
  1322.                                          ngx_http_script_copy_capture_len_code;
  1323.     code->n = 2 * n;


  1326.     code = ngx_http_script_add_code(*sc->values,
  1327.                                     sizeof(ngx_http_script_copy_capture_code_t),
  1328.                                     &sc->main);
  1329.     if (code == NULL) {
  1330.         return NGX_ERROR;
  1331.     }

  1333.     code->code = ngx_http_script_copy_capture_code;
  1334.     code->n = 2 * n;

  1336.     if (sc->ncaptures < n) {
  1337.         sc->ncaptures = n;
  1338.     }

  1340.     return NGX_OK;
  1341. }


  1344. size_t
  1345. ‌ngx_http_script_copy_capture_len_code(ngx_http_script_engine_t *e)
  1346. {
  1347.     int                                  *cap;
  1348.     u_char                               *p;
  1349.     ngx_uint_t                            n;
  1350.     ngx_http_request_t                   *r;
  1351.     ngx_http_script_copy_capture_code_t  *code;

  1353.     r = e->request;

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

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

  1359.     n = code->n;

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

  1363.         cap = r->captures;

  1365.         if ((e->is_args || e->quote)
  1366.             && (e->request->quoted_uri || e->request->plus_in_uri))
  1367.         {
  1368.             p = r->captures_data;

  1370.             return cap[n + 1] - cap[n]
  1371.                    + 2 * ngx_escape_uri(NULL, &p[cap[n]], cap[n + 1] - cap[n],
  1372.                                         NGX_ESCAPE_ARGS);
  1373.         } else {
  1374.             return cap[n + 1] - cap[n];
  1375.         }
  1376.     }

  1378.     return 0;
  1379. }


  1382. void
  1383. ‌ngx_http_script_copy_capture_code(ngx_http_script_engine_t *e)
  1384. {
  1385.     int                                  *cap;
  1386.     u_char                               *p, *pos;
  1387.     ngx_uint_t                            n;
  1388.     ngx_http_request_t                   *r;
  1389.     ngx_http_script_copy_capture_code_t  *code;

  1391.     r = e->request;

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

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

  1397.     n = code->n;

  1399.     pos = e->pos;

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

  1403.         cap = r->captures;
  1404.         p = r->captures_data;

  1406.         if ((e->is_args || e->quote)
  1407.             && (e->request->quoted_uri || e->request->plus_in_uri))
  1408.         {
  1409.             e->pos = (u_char *) ngx_escape_uri(pos, &p[cap[n]],
  1410.                                                cap[n + 1] - cap[n],
  1411.                                                NGX_ESCAPE_ARGS);
  1412.         } else {
  1413.             e->pos = ngx_copy(pos, &p[cap[n]], cap[n + 1] - cap[n]);
  1414.         }
  1415.     }

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

  1421. #endif


  1424. static ngx_int_t
  1425. ‌ngx_http_script_add_full_name_code(ngx_http_script_compile_t *sc)
  1426. {
  1427.     ngx_http_script_full_name_code_t  *code;

  1429.     code = ngx_http_script_add_code(*sc->lengths,
  1430.                                     sizeof(ngx_http_script_full_name_code_t),
  1431.                                     NULL);
  1432.     if (code == NULL) {
  1433.         return NGX_ERROR;
  1434.     }

  1436.     code->code = (ngx_http_script_code_pt) (void *)
  1437.                                             ngx_http_script_full_name_len_code;
  1438.     code->conf_prefix = sc->conf_prefix;

  1440.     code = ngx_http_script_add_code(*sc->values,
  1441.                                     sizeof(ngx_http_script_full_name_code_t),
  1442.                                     &sc->main);
  1443.     if (code == NULL) {
  1444.         return NGX_ERROR;
  1445.     }

  1447.     code->code = ngx_http_script_full_name_code;
  1448.     code->conf_prefix = sc->conf_prefix;

  1450.     return NGX_OK;
  1451. }


  1454. static size_t
  1455. ‌ngx_http_script_full_name_len_code(ngx_http_script_engine_t *e)
  1456. {
  1457.     ngx_http_script_full_name_code_t  *code;

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

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

  1463.     return code->conf_prefix ? ngx_cycle->conf_prefix.len:
  1464.                                ngx_cycle->prefix.len;
  1465. }


  1468. static void
  1469. ‌ngx_http_script_full_name_code(ngx_http_script_engine_t *e)
  1470. {
  1471.     ngx_http_script_full_name_code_t  *code;

  1473.     ngx_str_t  value, *prefix;

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

  1477.     value.data = e->buf.data;
  1478.     value.len = e->pos - e->buf.data;

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

  1483.     if (ngx_get_full_name(e->request->pool, prefix, &value) != NGX_OK) {
  1484.         e->ip = ngx_http_script_exit;
  1485.         e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1486.         return;
  1487.     }

  1489.     e->buf = value;

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

  1494.     e->ip += sizeof(ngx_http_script_full_name_code_t);
  1495. }


  1498. void
  1499. ‌ngx_http_script_return_code(ngx_http_script_engine_t *e)
  1500. {
  1501.     ngx_http_script_return_code_t  *code;

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

  1505.     if (code->status < NGX_HTTP_BAD_REQUEST
  1506.         || code->text.value.len
  1507.         || code->text.lengths)
  1508.     {
  1509.         e->status = ngx_http_send_response(e->request, code->status, NULL,
  1510.                                            &code->text);
  1511.     } else {
  1512.         e->status = code->status;
  1513.     }

  1515.     e->ip = ngx_http_script_exit;
  1516. }


  1519. void
  1520. ‌ngx_http_script_break_code(ngx_http_script_engine_t *e)
  1521. {
  1522.     ngx_http_request_t  *r;

  1524.     r = e->request;

  1526.     if (r->uri_changed) {
  1527.         r->valid_location = 0;
  1528.         r->uri_changed = 0;
  1529.     }

  1531.     e->ip = ngx_http_script_exit;
  1532. }


  1535. void
  1536. ‌ngx_http_script_if_code(ngx_http_script_engine_t *e)
  1537. {
  1538.     ngx_http_script_if_code_t  *code;

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

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

  1545.     e->sp--;

  1547.     if (e->sp->len && (e->sp->len != 1 || e->sp->data[0] != '0')) {
  1548.         if (code->loc_conf) {
  1549.             e->request->loc_conf = code->loc_conf;
  1550.             ngx_http_update_location_config(e->request);
  1551.         }

  1553.         e->ip += sizeof(ngx_http_script_if_code_t);
  1554.         return;
  1555.     }

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

  1560.     e->ip += code->next;
  1561. }


  1564. void
  1565. ‌ngx_http_script_equal_code(ngx_http_script_engine_t *e)
  1566. {
  1567.     ngx_http_variable_value_t  *val, *res;

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

  1572.     e->sp--;
  1573.     val = e->sp;
  1574.     res = e->sp - 1;

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

  1578.     if (val->len == res->len
  1579.         && ngx_strncmp(val->data, res->data, res->len) == 0)
  1580.     {
  1581.         *res = ngx_http_variable_true_value;
  1582.         return;
  1583.     }

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

  1588.     *res = ngx_http_variable_null_value;
  1589. }


  1592. void
  1593. ‌ngx_http_script_not_equal_code(ngx_http_script_engine_t *e)
  1594. {
  1595.     ngx_http_variable_value_t  *val, *res;

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

  1600.     e->sp--;
  1601.     val = e->sp;
  1602.     res = e->sp - 1;

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

  1606.     if (val->len == res->len
  1607.         && ngx_strncmp(val->data, res->data, res->len) == 0)
  1608.     {
  1609.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1610.                        "http script not equal: no");

  1612.         *res = ngx_http_variable_null_value;
  1613.         return;
  1614.     }

  1616.     *res = ngx_http_variable_true_value;
  1617. }


  1620. void
  1621. ‌ngx_http_script_file_code(ngx_http_script_engine_t *e)
  1622. {
  1623.     ngx_str_t                     path;
  1624.     ngx_http_request_t           *r;
  1625.     ngx_open_file_info_t          of;
  1626.     ngx_http_core_loc_conf_t     *clcf;
  1627.     ngx_http_variable_value_t    *value;
  1628.     ngx_http_script_file_code_t  *code;

  1630.     value = e->sp - 1;

  1632.     code = (ngx_http_script_file_code_t *) e->ip;
  1633.     e->ip += sizeof(ngx_http_script_file_code_t);

  1635.     path.len = value->len - 1;
  1636.     path.data = value->data;

  1638.     r = e->request;

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

  1643.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

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

  1647.     of.read_ahead = clcf->read_ahead;
  1648.     of.directio = clcf->directio;
  1649.     of.valid = clcf->open_file_cache_valid;
  1650.     of.min_uses = clcf->open_file_cache_min_uses;
  1651.     of.test_only = 1;
  1652.     of.errors = clcf->open_file_cache_errors;
  1653.     of.events = clcf->open_file_cache_events;

  1655.     if (ngx_http_set_disable_symlinks(r, clcf, &path, &of) != NGX_OK) {
  1656.         e->ip = ngx_http_script_exit;
  1657.         e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1658.         return;
  1659.     }

  1661.     if (ngx_open_cached_file(clcf->open_file_cache, &path, &of, r->pool)
  1662.         != NGX_OK)
  1663.     {
  1664.         if (of.err == 0) {
  1665.             e->ip = ngx_http_script_exit;
  1666.             e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1667.             return;
  1668.         }

  1670.         if (of.err != NGX_ENOENT
  1671.             && of.err != NGX_ENOTDIR
  1672.             && of.err != NGX_ENAMETOOLONG)
  1673.         {
  1674.             ngx_log_error(NGX_LOG_CRIT, r->connection->log, of.err,
  1675.                           "%s \"%s\" failed", of.failed, value->data);
  1676.         }

  1678.         switch (code->op) {

  1680.         case ngx_http_script_file_plain:
  1681.         case ngx_http_script_file_dir:
  1682.         case ngx_http_script_file_exists:
  1683.         case ngx_http_script_file_exec:
  1684.              goto false_value;

  1686.         case ngx_http_script_file_not_plain:
  1687.         case ngx_http_script_file_not_dir:
  1688.         case ngx_http_script_file_not_exists:
  1689.         case ngx_http_script_file_not_exec:
  1690.              goto true_value;
  1691.         }

  1693.         goto false_value;
  1694.     }

  1696.     switch (code->op) {
  1697.     case ngx_http_script_file_plain:
  1698.         if (of.is_file) {
  1699.              goto true_value;
  1700.         }
  1701.         goto false_value;

  1703.     case ngx_http_script_file_not_plain:
  1704.         if (of.is_file) {
  1705.             goto false_value;
  1706.         }
  1707.         goto true_value;

  1709.     case ngx_http_script_file_dir:
  1710.         if (of.is_dir) {
  1711.              goto true_value;
  1712.         }
  1713.         goto false_value;

  1715.     case ngx_http_script_file_not_dir:
  1716.         if (of.is_dir) {
  1717.             goto false_value;
  1718.         }
  1719.         goto true_value;

  1721.     case ngx_http_script_file_exists:
  1722.         if (of.is_file || of.is_dir || of.is_link) {
  1723.              goto true_value;
  1724.         }
  1725.         goto false_value;

  1727.     case ngx_http_script_file_not_exists:
  1728.         if (of.is_file || of.is_dir || of.is_link) {
  1729.             goto false_value;
  1730.         }
  1731.         goto true_value;

  1733.     case ngx_http_script_file_exec:
  1734.         if (of.is_exec) {
  1735.              goto true_value;
  1736.         }
  1737.         goto false_value;

  1739.     case ngx_http_script_file_not_exec:
  1740.         if (of.is_exec) {
  1741.             goto false_value;
  1742.         }
  1743.         goto true_value;
  1744.     }

  1746. false_value:

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

  1751.     *value = ngx_http_variable_null_value;
  1752.     return;

  1754. true_value:

  1756.     *value = ngx_http_variable_true_value;
  1757.     return;
  1758. }


  1761. void
  1762. ‌ngx_http_script_complex_value_code(ngx_http_script_engine_t *e)
  1763. {
  1764.     size_t                                 len;
  1765.     ngx_http_script_engine_t               le;
  1766.     ngx_http_script_len_code_pt            lcode;
  1767.     ngx_http_script_complex_value_code_t  *code;

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

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

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

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

  1778.     le.ip = code->lengths->elts;
  1779.     le.line = e->line;
  1780.     le.request = e->request;
  1781.     le.is_args = e->is_args;
  1782.     le.quote = e->quote;

  1784.     for (len = 0; *(uintptr_t *) le.ip; len += lcode(&le)) {
  1785.         lcode = *(ngx_http_script_len_code_pt *) le.ip;
  1786.     }

  1788.     e->buf.len = len;
  1789.     e->buf.data = ngx_pnalloc(e->request->pool, len);
  1790.     if (e->buf.data == NULL) {
  1791.         e->ip = ngx_http_script_exit;
  1792.         e->status = NGX_HTTP_INTERNAL_SERVER_ERROR;
  1793.         return;
  1794.     }

  1796.     e->pos = e->buf.data;

  1798.     e->sp->len = e->buf.len;
  1799.     e->sp->data = e->buf.data;
  1800.     e->sp++;
  1801. }


  1804. void
  1805. ‌ngx_http_script_value_code(ngx_http_script_engine_t *e)
  1806. {
  1807.     ngx_http_script_value_code_t  *code;

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

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

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

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

  1819.     e->sp++;
  1820. }


  1823. void
  1824. ‌ngx_http_script_set_var_code(ngx_http_script_engine_t *e)
  1825. {
  1826.     ngx_http_request_t          *r;
  1827.     ngx_http_script_var_code_t  *code;

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

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

  1833.     r = e->request;

  1835.     e->sp--;

  1837.     r->variables[code->index].len = e->sp->len;
  1838.     r->variables[code->index].valid = 1;
  1839.     r->variables[code->index].no_cacheable = 0;
  1840.     r->variables[code->index].not_found = 0;
  1841.     r->variables[code->index].data = e->sp->data;

  1843. #if (NGX_DEBUG)
  1844.     {
  1845.     ngx_http_variable_t        *v;
  1846.     ngx_http_core_main_conf_t  *cmcf;

  1848.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  1850.     v = cmcf->variables.elts;

  1852.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, e->request->connection->log, 0,
  1853.                    "http script set $%V", &v[code->index].name);
  1854.     }
  1855. #endif
  1856. }


  1859. void
  1860. ‌ngx_http_script_var_set_handler_code(ngx_http_script_engine_t *e)
  1861. {
  1862.     ngx_http_script_var_handler_code_t  *code;

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

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

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

  1871.     e->sp--;

  1873.     code->handler(e->request, e->sp, code->data);
  1874. }


  1877. void
  1878. ‌ngx_http_script_var_code(ngx_http_script_engine_t *e)
  1879. {
  1880.     ngx_http_variable_value_t   *value;
  1881.     ngx_http_script_var_code_t  *code;

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

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

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

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

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

  1896.         *e->sp = *value;
  1897.         e->sp++;

  1899.         return;
  1900.     }

  1902.     *e->sp = ngx_http_variable_null_value;
  1903.     e->sp++;
  1904. }


  1907. void
  1908. ‌ngx_http_script_nop_code(ngx_http_script_engine_t *e)
  1909. {
  1910.     e->ip += sizeof(uintptr_t);
  1911. }

One Level Up Top Level