One Level Up Top Level

src/stream/ngx_stream_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_stream.h>


  13. static ngx_int_t ngx_stream_script_init_arrays(
  14.     ngx_stream_script_compile_t *sc);
  15. static ngx_int_t ngx_stream_script_done(ngx_stream_script_compile_t *sc);
  16. static ngx_int_t ngx_stream_script_add_copy_code(
  17.     ngx_stream_script_compile_t *sc, ngx_str_t *value, ngx_uint_t last);
  18. static ngx_int_t ngx_stream_script_add_var_code(
  19.     ngx_stream_script_compile_t *sc, ngx_str_t *name);
  20. #if (NGX_PCRE)
  21. static ngx_int_t ngx_stream_script_add_capture_code(
  22.     ngx_stream_script_compile_t *sc, ngx_uint_t n);
  23. #endif
  24. static ngx_int_t ngx_stream_script_add_full_name_code(
  25.     ngx_stream_script_compile_t *sc);
  26. static size_t ngx_stream_script_full_name_len_code(
  27.     ngx_stream_script_engine_t *e);
  28. static void ngx_stream_script_full_name_code(ngx_stream_script_engine_t *e);


  31. ‌#define ngx_stream_script_exit  (u_char *) &ngx_stream_script_exit_code

  33. ‌static uintptr_t ngx_stream_script_exit_code = (uintptr_t) NULL;


  36. void
  37. ‌ngx_stream_script_flush_complex_value(ngx_stream_session_t *s,
  38.     ngx_stream_complex_value_t *val)
  39. {
  40.     ngx_uint_t *index;

  42.     index = val->flushes;

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

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

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


  58. ngx_int_t
  59. ‌ngx_stream_complex_value(ngx_stream_session_t *s,
  60.     ngx_stream_complex_value_t *val, ngx_str_t *value)
  61. {
  62.     size_t                         len;
  63.     ngx_stream_script_code_pt      code;
  64.     ngx_stream_script_engine_t     e;
  65.     ngx_stream_script_len_code_pt  lcode;

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

  72.     ngx_stream_script_flush_complex_value(s, val);

  74.     ngx_memzero(&e, sizeof(ngx_stream_script_engine_t));

  76.     e.ip = val->lengths;
  77.     e.session = s;
  78.     e.flushed = 1;

  80.     len = 0;

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

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

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

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

  102.     *value = e.buf;

  104.     return NGX_OK;
  105. }


  108. size_t
  109. ‌ngx_stream_complex_value_size(ngx_stream_session_t *s,
  110.     ngx_stream_complex_value_t *val, size_t default_value)
  111. {
  112.     size_t     size;
  113.     ngx_str_t  value;

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

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

  123.     if (ngx_stream_complex_value(s, val, &value) != NGX_OK) {
  124.         return default_value;
  125.     }

  127.     size = ngx_parse_size(&value);

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

  135.     return size;
  136. }


  139. ngx_int_t
  140. ‌ngx_stream_compile_complex_value(ngx_stream_compile_complex_value_t *ccv)
  141. {
  142.     ngx_str_t                    *v;
  143.     ngx_uint_t                    i, n, nv, nc;
  144.     ngx_array_t                   flushes, lengths, values, *pf, *pl, *pv;
  145.     ngx_stream_script_compile_t   sc;

  147.     v = ccv->value;

  149.     nv = 0;
  150.     nc = 0;

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

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

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

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

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

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

  185.     n = nv + 1;

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

  193.     n = nv * (2 * sizeof(ngx_stream_script_copy_code_t)
  194.                   + sizeof(ngx_stream_script_var_code_t))
  195.         + sizeof(uintptr_t);

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

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

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

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

  216.     ngx_memzero(&sc, sizeof(ngx_stream_script_compile_t));

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

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

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

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

  241.     return NGX_OK;
  242. }


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

  251.     ngx_str_t                            *value;
  252.     ngx_stream_complex_value_t          **cv;
  253.     ngx_stream_compile_complex_value_t    ccv;

  255.     cv = (ngx_stream_complex_value_t **) (p + cmd->offset);

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

  261.     *cv = ngx_palloc(cf->pool, sizeof(ngx_stream_complex_value_t));
  262.     if (*cv == NULL) {
  263.         return NGX_CONF_ERROR;
  264.     }

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

  268.     ngx_memzero(&ccv, sizeof(ngx_stream_compile_complex_value_t));

  270.     ccv.cf = cf;
  271.     ccv.value = &value[1];
  272.     ccv.complex_value = *cv;

  274.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  275.         return NGX_CONF_ERROR;
  276.     }

  278.     return NGX_CONF_OK;
  279. }


  282. char *
  283. ‌ngx_stream_set_complex_value_zero_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  284.     void *conf)
  285. {
  286.     char  *p = conf;

  288.     ngx_str_t                            *value;
  289.     ngx_stream_complex_value_t          **cv;
  290.     ngx_stream_compile_complex_value_t    ccv;

  292.     cv = (ngx_stream_complex_value_t **) (p + cmd->offset);

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

  298.     *cv = ngx_palloc(cf->pool, sizeof(ngx_stream_complex_value_t));
  299.     if (*cv == NULL) {
  300.         return NGX_CONF_ERROR;
  301.     }

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

  305.     ngx_memzero(&ccv, sizeof(ngx_stream_compile_complex_value_t));

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

  312.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  313.         return NGX_CONF_ERROR;
  314.     }

  316.     return NGX_CONF_OK;
  317. }


  320. char *
  321. ‌ngx_stream_set_complex_value_size_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  322.     void *conf)
  323. {
  324.     char  *p = conf;

  326.     char                        *rv;
  327.     ngx_stream_complex_value_t  *cv;

  329.     rv = ngx_stream_set_complex_value_slot(cf, cmd, conf);

  331.     if (rv != NGX_CONF_OK) {
  332.         return rv;
  333.     }

  335.     cv = *(ngx_stream_complex_value_t **) (p + cmd->offset);

  337.     if (cv->lengths) {
  338.         return NGX_CONF_OK;
  339.     }

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

  346.     return NGX_CONF_OK;
  347. }


  350. ngx_uint_t
  351. ‌ngx_stream_script_variables_count(ngx_str_t *value)
  352. {
  353.     ngx_uint_t  i, n;

  355.     for (n = 0, i = 0; i < value->len; i++) {
  356.         if (value->data[i] == '$') {
  357.             n++;
  358.         }
  359.     }

  361.     return n;
  362. }


  365. ngx_int_t
  366. ‌ngx_stream_script_compile(ngx_stream_script_compile_t *sc)
  367. {
  368.     u_char       ch;
  369.     ngx_str_t    name;
  370.     ngx_uint_t   i, bracket;

  372.     if (ngx_stream_script_init_arrays(sc) != NGX_OK) {
  373.         return NGX_ERROR;
  374.     }

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

  378.         name.len = 0;

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

  382.             if (++i == sc->source->len) {
  383.                 goto invalid_variable;
  384.             }

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

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

  392.                 if (ngx_stream_script_add_capture_code(sc, n) != NGX_OK) {
  393.                     return NGX_ERROR;
  394.                 }

  396.                 i++;

  398.                 continue;
  399. #else
  400.                 ngx_conf_log_error(NGX_LOG_EMERG, sc->cf, 0,
  401.                                    "using variable \"$%c\" requires "
  402.                                    "PCRE library", sc->source->data[i]);
  403.                 return NGX_ERROR;
  404. #endif
  405.             }

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

  410.                 if (++i == sc->source->len) {
  411.                     goto invalid_variable;
  412.                 }

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

  416.             } else {
  417.                 bracket = 0;
  418.                 name.data = &sc->source->data[i];
  419.             }

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

  424.                 if (ch == '}' && bracket) {
  425.                     i++;
  426.                     bracket = 0;
  427.                     break;
  428.                 }

  430.                 if ((ch >= 'A' && ch <= 'Z')
  431.                     || (ch >= 'a' && ch <= 'z')
  432.                     || (ch >= '0' && ch <= '9')
  433.                     || ch == '_')
  434.                 {
  435.                     continue;
  436.                 }

  438.                 break;
  439.             }

  441.             if (bracket) {
  442.                 ngx_conf_log_error(NGX_LOG_EMERG, sc->cf, 0,
  443.                                    "the closing bracket in \"%V\" "
  444.                                    "variable is missing", &name);
  445.                 return NGX_ERROR;
  446.             }

  448.             if (name.len == 0) {
  449.                 goto invalid_variable;
  450.             }

  452.             sc->variables++;

  454.             if (ngx_stream_script_add_var_code(sc, &name) != NGX_OK) {
  455.                 return NGX_ERROR;
  456.             }

  458.             continue;
  459.         }

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

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

  465.             if (sc->source->data[i] == '$') {
  466.                 break;
  467.             }

  469.             i++;
  470.             name.len++;
  471.         }

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

  475.         if (ngx_stream_script_add_copy_code(sc, &name, (i == sc->source->len))
  476.             != NGX_OK)
  477.         {
  478.             return NGX_ERROR;
  479.         }
  480.     }

  482.     return ngx_stream_script_done(sc);

  484. invalid_variable:

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

  488.     return NGX_ERROR;
  489. }


  492. u_char *
  493. ‌ngx_stream_script_run(ngx_stream_session_t *s, ngx_str_t *value,
  494.     void *code_lengths, size_t len, void *code_values)
  495. {
  496.     ngx_uint_t                      i;
  497.     ngx_stream_script_code_pt       code;
  498.     ngx_stream_script_engine_t      e;
  499.     ngx_stream_core_main_conf_t    *cmcf;
  500.     ngx_stream_script_len_code_pt   lcode;

  502.     cmcf = ngx_stream_get_module_main_conf(s, ngx_stream_core_module);

  504.     for (i = 0; i < cmcf->variables.nelts; i++) {
  505.         if (s->variables[i].no_cacheable) {
  506.             s->variables[i].valid = 0;
  507.             s->variables[i].not_found = 0;
  508.         }
  509.     }

  511.     ngx_memzero(&e, sizeof(ngx_stream_script_engine_t));

  513.     e.ip = code_lengths;
  514.     e.session = s;
  515.     e.flushed = 1;

  517.     while (*(uintptr_t *) e.ip) {
  518.         lcode = *(ngx_stream_script_len_code_pt *) e.ip;
  519.         len += lcode(&e);
  520.     }


  523.     value->len = len;
  524.     value->data = ngx_pnalloc(s->connection->pool, len);
  525.     if (value->data == NULL) {
  526.         return NULL;
  527.     }

  529.     e.ip = code_values;
  530.     e.pos = value->data;

  532.     while (*(uintptr_t *) e.ip) {
  533.         code = *(ngx_stream_script_code_pt *) e.ip;
  534.         code((ngx_stream_script_engine_t *) &e);
  535.     }

  537.     return e.pos;
  538. }


  541. void
  542. ‌ngx_stream_script_flush_no_cacheable_variables(ngx_stream_session_t *s,
  543.     ngx_array_t *indices)
  544. {
  545.     ngx_uint_t  n, *index;

  547.     if (indices) {
  548.         index = indices->elts;
  549.         for (n = 0; n < indices->nelts; n++) {
  550.             if (s->variables[index[n]].no_cacheable) {
  551.                 s->variables[index[n]].valid = 0;
  552.                 s->variables[index[n]].not_found = 0;
  553.             }
  554.         }
  555.     }
  556. }


  559. static ngx_int_t
  560. ‌ngx_stream_script_init_arrays(ngx_stream_script_compile_t *sc)
  561. {
  562.     ngx_uint_t   n;

  564.     if (sc->flushes && *sc->flushes == NULL) {
  565.         n = sc->variables ? sc->variables : 1;
  566.         *sc->flushes = ngx_array_create(sc->cf->pool, n, sizeof(ngx_uint_t));
  567.         if (*sc->flushes == NULL) {
  568.             return NGX_ERROR;
  569.         }
  570.     }

  572.     if (*sc->lengths == NULL) {
  573.         n = sc->variables * (2 * sizeof(ngx_stream_script_copy_code_t)
  574.                              + sizeof(ngx_stream_script_var_code_t))
  575.             + sizeof(uintptr_t);

  577.         *sc->lengths = ngx_array_create(sc->cf->pool, n, 1);
  578.         if (*sc->lengths == NULL) {
  579.             return NGX_ERROR;
  580.         }
  581.     }

  583.     if (*sc->values == NULL) {
  584.         n = (sc->variables * (2 * sizeof(ngx_stream_script_copy_code_t)
  585.                               + sizeof(ngx_stream_script_var_code_t))
  586.                 + sizeof(uintptr_t)
  587.                 + sc->source->len
  588.                 + sizeof(uintptr_t) - 1)
  589.             & ~(sizeof(uintptr_t) - 1);

  591.         *sc->values = ngx_array_create(sc->cf->pool, n, 1);
  592.         if (*sc->values == NULL) {
  593.             return NGX_ERROR;
  594.         }
  595.     }

  597.     sc->variables = 0;

  599.     return NGX_OK;
  600. }


  603. static ngx_int_t
  604. ‌ngx_stream_script_done(ngx_stream_script_compile_t *sc)
  605. {
  606.     ngx_str_t    zero;
  607.     uintptr_t   *code;

  609.     if (sc->zero) {

  611.         zero.len = 1;
  612.         zero.data = (u_char *) "\0";

  614.         if (ngx_stream_script_add_copy_code(sc, &zero, 0) != NGX_OK) {
  615.             return NGX_ERROR;
  616.         }
  617.     }

  619.     if (sc->conf_prefix || sc->root_prefix) {
  620.         if (ngx_stream_script_add_full_name_code(sc) != NGX_OK) {
  621.             return NGX_ERROR;
  622.         }
  623.     }

  625.     if (sc->complete_lengths) {
  626.         code = ngx_stream_script_add_code(*sc->lengths, sizeof(uintptr_t),
  627.                                           NULL);
  628.         if (code == NULL) {
  629.             return NGX_ERROR;
  630.         }

  632.         *code = (uintptr_t) NULL;
  633.     }

  635.     if (sc->complete_values) {
  636.         code = ngx_stream_script_add_code(*sc->values, sizeof(uintptr_t),
  637.                                           &sc->main);
  638.         if (code == NULL) {
  639.             return NGX_ERROR;
  640.         }

  642.         *code = (uintptr_t) NULL;
  643.     }

  645.     return NGX_OK;
  646. }


  649. void *
  650. ‌ngx_stream_script_add_code(ngx_array_t *codes, size_t size, void *code)
  651. {
  652.     u_char  *elts, **p;
  653.     void    *new;

  655.     elts = codes->elts;

  657.     new = ngx_array_push_n(codes, size);
  658.     if (new == NULL) {
  659.         return NULL;
  660.     }

  662.     if (code) {
  663.         if (elts != codes->elts) {
  664.             p = code;
  665.             *p += (u_char *) codes->elts - elts;
  666.         }
  667.     }

  669.     return new;
  670. }


  673. static ngx_int_t
  674. ‌ngx_stream_script_add_copy_code(ngx_stream_script_compile_t *sc,
  675.     ngx_str_t *value, ngx_uint_t last)
  676. {
  677.     u_char                         *p;
  678.     size_t                          size, len, zero;
  679.     ngx_stream_script_copy_code_t  *code;

  681.     zero = (sc->zero && last);
  682.     len = value->len + zero;

  684.     code = ngx_stream_script_add_code(*sc->lengths,
  685.                                       sizeof(ngx_stream_script_copy_code_t),
  686.                                       NULL);
  687.     if (code == NULL) {
  688.         return NGX_ERROR;
  689.     }

  691.     code->code = (ngx_stream_script_code_pt) (void *)
  692.                                                ngx_stream_script_copy_len_code;
  693.     code->len = len;

  695.     size = (sizeof(ngx_stream_script_copy_code_t) + len + sizeof(uintptr_t) - 1)
  696.             & ~(sizeof(uintptr_t) - 1);

  698.     code = ngx_stream_script_add_code(*sc->values, size, &sc->main);
  699.     if (code == NULL) {
  700.         return NGX_ERROR;
  701.     }

  703.     code->code = ngx_stream_script_copy_code;
  704.     code->len = len;

  706.     p = ngx_cpymem((u_char *) code + sizeof(ngx_stream_script_copy_code_t),
  707.                    value->data, value->len);

  709.     if (zero) {
  710.         *p = '\0';
  711.         sc->zero = 0;
  712.     }

  714.     return NGX_OK;
  715. }


  718. size_t
  719. ‌ngx_stream_script_copy_len_code(ngx_stream_script_engine_t *e)
  720. {
  721.     ngx_stream_script_copy_code_t  *code;

  723.     code = (ngx_stream_script_copy_code_t *) e->ip;

  725.     e->ip += sizeof(ngx_stream_script_copy_code_t);

  727.     return code->len;
  728. }


  731. void
  732. ‌ngx_stream_script_copy_code(ngx_stream_script_engine_t *e)
  733. {
  734.     u_char                         *p;
  735.     ngx_stream_script_copy_code_t  *code;

  737.     code = (ngx_stream_script_copy_code_t *) e->ip;

  739.     p = e->pos;

  741.     if (!e->skip) {
  742.         e->pos = ngx_copy(p, e->ip + sizeof(ngx_stream_script_copy_code_t),
  743.                           code->len);
  744.     }

  746.     e->ip += sizeof(ngx_stream_script_copy_code_t)
  747.           + ((code->len + sizeof(uintptr_t) - 1) & ~(sizeof(uintptr_t) - 1));

  749.     ngx_log_debug2(NGX_LOG_DEBUG_STREAM, e->session->connection->log, 0,
  750.                    "stream script copy: \"%*s\"", e->pos - p, p);
  751. }


  754. static ngx_int_t
  755. ‌ngx_stream_script_add_var_code(ngx_stream_script_compile_t *sc, ngx_str_t *name)
  756. {
  757.     ngx_int_t                      index, *p;
  758.     ngx_stream_script_var_code_t  *code;

  760.     index = ngx_stream_get_variable_index(sc->cf, name);

  762.     if (index == NGX_ERROR) {
  763.         return NGX_ERROR;
  764.     }

  766.     if (sc->flushes) {
  767.         p = ngx_array_push(*sc->flushes);
  768.         if (p == NULL) {
  769.             return NGX_ERROR;
  770.         }

  772.         *p = index;
  773.     }

  775.     code = ngx_stream_script_add_code(*sc->lengths,
  776.                                       sizeof(ngx_stream_script_var_code_t),
  777.                                       NULL);
  778.     if (code == NULL) {
  779.         return NGX_ERROR;
  780.     }

  782.     code->code = (ngx_stream_script_code_pt) (void *)
  783.                                            ngx_stream_script_copy_var_len_code;
  784.     code->index = (uintptr_t) index;

  786.     code = ngx_stream_script_add_code(*sc->values,
  787.                                       sizeof(ngx_stream_script_var_code_t),
  788.                                       &sc->main);
  789.     if (code == NULL) {
  790.         return NGX_ERROR;
  791.     }

  793.     code->code = ngx_stream_script_copy_var_code;
  794.     code->index = (uintptr_t) index;

  796.     return NGX_OK;
  797. }


  800. size_t
  801. ‌ngx_stream_script_copy_var_len_code(ngx_stream_script_engine_t *e)
  802. {
  803.     ngx_stream_variable_value_t   *value;
  804.     ngx_stream_script_var_code_t  *code;

  806.     code = (ngx_stream_script_var_code_t *) e->ip;

  808.     e->ip += sizeof(ngx_stream_script_var_code_t);

  810.     if (e->flushed) {
  811.         value = ngx_stream_get_indexed_variable(e->session, code->index);

  813.     } else {
  814.         value = ngx_stream_get_flushed_variable(e->session, code->index);
  815.     }

  817.     if (value && !value->not_found) {
  818.         return value->len;
  819.     }

  821.     return 0;
  822. }


  825. void
  826. ‌ngx_stream_script_copy_var_code(ngx_stream_script_engine_t *e)
  827. {
  828.     u_char                        *p;
  829.     ngx_stream_variable_value_t   *value;
  830.     ngx_stream_script_var_code_t  *code;

  832.     code = (ngx_stream_script_var_code_t *) e->ip;

  834.     e->ip += sizeof(ngx_stream_script_var_code_t);

  836.     if (!e->skip) {

  838.         if (e->flushed) {
  839.             value = ngx_stream_get_indexed_variable(e->session, code->index);

  841.         } else {
  842.             value = ngx_stream_get_flushed_variable(e->session, code->index);
  843.         }

  845.         if (value && !value->not_found) {
  846.             p = e->pos;
  847.             e->pos = ngx_copy(p, value->data, value->len);

  849.             ngx_log_debug2(NGX_LOG_DEBUG_STREAM,
  850.                            e->session->connection->log, 0,
  851.                            "stream script var: \"%*s\"", e->pos - p, p);
  852.         }
  853.     }
  854. }


  857. #if (NGX_PCRE)

  859. static ngx_int_t
  860. ‌ngx_stream_script_add_capture_code(ngx_stream_script_compile_t *sc,
  861.     ngx_uint_t n)
  862. {
  863.     ngx_stream_script_copy_capture_code_t  *code;

  865.     code = ngx_stream_script_add_code(*sc->lengths,
  866.                                   sizeof(ngx_stream_script_copy_capture_code_t),
  867.                                   NULL);
  868.     if (code == NULL) {
  869.         return NGX_ERROR;
  870.     }

  872.     code->code = (ngx_stream_script_code_pt) (void *)
  873.                                        ngx_stream_script_copy_capture_len_code;
  874.     code->n = 2 * n;


  877.     code = ngx_stream_script_add_code(*sc->values,
  878.                                   sizeof(ngx_stream_script_copy_capture_code_t),
  879.                                   &sc->main);
  880.     if (code == NULL) {
  881.         return NGX_ERROR;
  882.     }

  884.     code->code = ngx_stream_script_copy_capture_code;
  885.     code->n = 2 * n;

  887.     if (sc->ncaptures < n) {
  888.         sc->ncaptures = n;
  889.     }

  891.     return NGX_OK;
  892. }


  895. size_t
  896. ‌ngx_stream_script_copy_capture_len_code(ngx_stream_script_engine_t *e)
  897. {
  898.     int                                    *cap;
  899.     ngx_uint_t                              n;
  900.     ngx_stream_session_t                   *s;
  901.     ngx_stream_script_copy_capture_code_t  *code;

  903.     s = e->session;

  905.     code = (ngx_stream_script_copy_capture_code_t *) e->ip;

  907.     e->ip += sizeof(ngx_stream_script_copy_capture_code_t);

  909.     n = code->n;

  911.     if (n < s->ncaptures) {
  912.         cap = s->captures;
  913.         return cap[n + 1] - cap[n];
  914.     }

  916.     return 0;
  917. }


  920. void
  921. ‌ngx_stream_script_copy_capture_code(ngx_stream_script_engine_t *e)
  922. {
  923.     int                                    *cap;
  924.     u_char                                 *p, *pos;
  925.     ngx_uint_t                              n;
  926.     ngx_stream_session_t                   *s;
  927.     ngx_stream_script_copy_capture_code_t  *code;

  929.     s = e->session;

  931.     code = (ngx_stream_script_copy_capture_code_t *) e->ip;

  933.     e->ip += sizeof(ngx_stream_script_copy_capture_code_t);

  935.     n = code->n;

  937.     pos = e->pos;

  939.     if (n < s->ncaptures) {
  940.         cap = s->captures;
  941.         p = s->captures_data;
  942.         e->pos = ngx_copy(pos, &p[cap[n]], cap[n + 1] - cap[n]);
  943.     }

  945.     ngx_log_debug2(NGX_LOG_DEBUG_STREAM, e->session->connection->log, 0,
  946.                    "stream script capture: \"%*s\"", e->pos - pos, pos);
  947. }

  949. #endif


  952. static ngx_int_t
  953. ‌ngx_stream_script_add_full_name_code(ngx_stream_script_compile_t *sc)
  954. {
  955.     ngx_stream_script_full_name_code_t  *code;

  957.     code = ngx_stream_script_add_code(*sc->lengths,
  958.                                     sizeof(ngx_stream_script_full_name_code_t),
  959.                                     NULL);
  960.     if (code == NULL) {
  961.         return NGX_ERROR;
  962.     }

  964.     code->code = (ngx_stream_script_code_pt) (void *)
  965.                                           ngx_stream_script_full_name_len_code;
  966.     code->conf_prefix = sc->conf_prefix;

  968.     code = ngx_stream_script_add_code(*sc->values,
  969.                         sizeof(ngx_stream_script_full_name_code_t), &sc->main);
  970.     if (code == NULL) {
  971.         return NGX_ERROR;
  972.     }

  974.     code->code = ngx_stream_script_full_name_code;
  975.     code->conf_prefix = sc->conf_prefix;

  977.     return NGX_OK;
  978. }


  981. static size_t
  982. ‌ngx_stream_script_full_name_len_code(ngx_stream_script_engine_t *e)
  983. {
  984.     ngx_stream_script_full_name_code_t  *code;

  986.     code = (ngx_stream_script_full_name_code_t *) e->ip;

  988.     e->ip += sizeof(ngx_stream_script_full_name_code_t);

  990.     return code->conf_prefix ? ngx_cycle->conf_prefix.len:
  991.                                ngx_cycle->prefix.len;
  992. }


  995. static void
  996. ‌ngx_stream_script_full_name_code(ngx_stream_script_engine_t *e)
  997. {
  998.     ngx_stream_script_full_name_code_t  *code;

  1000.     ngx_str_t  value, *prefix;

  1002.     code = (ngx_stream_script_full_name_code_t *) e->ip;

  1004.     value.data = e->buf.data;
  1005.     value.len = e->pos - e->buf.data;

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

  1010.     if (ngx_get_full_name(e->session->connection->pool, prefix, &value)
  1011.         != NGX_OK)
  1012.     {
  1013.         e->ip = ngx_stream_script_exit;
  1014.         return;
  1015.     }

  1017.     e->buf = value;

  1019.     ngx_log_debug1(NGX_LOG_DEBUG_STREAM, e->session->connection->log, 0,
  1020.                    "stream script fullname: \"%V\"", &value);

  1022.     e->ip += sizeof(ngx_stream_script_full_name_code_t);
  1023. }

One Level Up Top Level