One Level Up Top Level

src/stream/ngx_stream_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_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.end = value->data + len;
  96.     e.buf = *value;

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

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

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

  110.     return NGX_OK;
  111. }


  114. size_t
  115. ‌ngx_stream_complex_value_size(ngx_stream_session_t *s,
  116.     ngx_stream_complex_value_t *val, size_t default_value)
  117. {
  118.     size_t     size;
  119.     ngx_str_t  value;

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

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

  129.     if (ngx_stream_complex_value(s, val, &value) != NGX_OK) {
  130.         return default_value;
  131.     }

  133.     size = ngx_parse_size(&value);

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

  141.     return size;
  142. }


  145. ngx_int_t
  146. ‌ngx_stream_compile_complex_value(ngx_stream_compile_complex_value_t *ccv)
  147. {
  148.     ngx_str_t                    *v;
  149.     ngx_uint_t                    i, n, nv, nc;
  150.     ngx_array_t                   flushes, lengths, values, *pf, *pl, *pv;
  151.     ngx_stream_script_compile_t   sc;

  153.     v = ccv->value;

  155.     nv = 0;
  156.     nc = 0;

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

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

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

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

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

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

  191.     n = nv + 1;

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

  199.     n = nv * (2 * sizeof(ngx_stream_script_copy_code_t)
  200.                   + sizeof(ngx_stream_script_var_code_t))
  201.         + sizeof(uintptr_t);

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

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

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

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

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

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

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

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

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

  247.     return NGX_OK;
  248. }


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

  257.     ngx_str_t                            *value;
  258.     ngx_stream_complex_value_t          **cv;
  259.     ngx_stream_compile_complex_value_t    ccv;

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

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

  267.     *cv = ngx_palloc(cf->pool, sizeof(ngx_stream_complex_value_t));
  268.     if (*cv == NULL) {
  269.         return NGX_CONF_ERROR;
  270.     }

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

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

  276.     ccv.cf = cf;
  277.     ccv.value = &value[1];
  278.     ccv.complex_value = *cv;

  280.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  281.         return NGX_CONF_ERROR;
  282.     }

  284.     return NGX_CONF_OK;
  285. }


  288. char *
  289. ‌ngx_stream_set_complex_value_zero_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  290.     void *conf)
  291. {
  292.     char  *p = conf;

  294.     ngx_str_t                            *value;
  295.     ngx_stream_complex_value_t          **cv;
  296.     ngx_stream_compile_complex_value_t    ccv;

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

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

  304.     *cv = ngx_palloc(cf->pool, sizeof(ngx_stream_complex_value_t));
  305.     if (*cv == NULL) {
  306.         return NGX_CONF_ERROR;
  307.     }

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

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

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

  318.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  319.         return NGX_CONF_ERROR;
  320.     }

  322.     return NGX_CONF_OK;
  323. }


  326. char *
  327. ‌ngx_stream_set_complex_value_size_slot(ngx_conf_t *cf, ngx_command_t *cmd,
  328.     void *conf)
  329. {
  330.     char  *p = conf;

  332.     char                        *rv;
  333.     ngx_stream_complex_value_t  *cv;

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

  337.     if (rv != NGX_CONF_OK) {
  338.         return rv;
  339.     }

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

  343.     if (cv->lengths) {
  344.         return NGX_CONF_OK;
  345.     }

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

  352.     return NGX_CONF_OK;
  353. }


  356. ngx_uint_t
  357. ‌ngx_stream_script_variables_count(ngx_str_t *value)
  358. {
  359.     ngx_uint_t  i, n;

  361.     for (n = 0, i = 0; i < value->len; i++) {
  362.         if (value->data[i] == '$') {
  363.             n++;
  364.         }
  365.     }

  367.     return n;
  368. }


  371. ngx_int_t
  372. ‌ngx_stream_script_compile(ngx_stream_script_compile_t *sc)
  373. {
  374.     u_char       ch;
  375.     ngx_str_t    name;
  376.     ngx_uint_t   i, bracket;

  378.     if (ngx_stream_script_init_arrays(sc) != NGX_OK) {
  379.         return NGX_ERROR;
  380.     }

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

  384.         name.len = 0;

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

  388.             if (++i == sc->source->len) {
  389.                 goto invalid_variable;
  390.             }

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

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

  398.                 if (ngx_stream_script_add_capture_code(sc, n) != NGX_OK) {
  399.                     return NGX_ERROR;
  400.                 }

  402.                 i++;

  404.                 continue;
  405. #else
  406.                 ngx_conf_log_error(NGX_LOG_EMERG, sc->cf, 0,
  407.                                    "using variable \"$%c\" requires "
  408.                                    "PCRE library", sc->source->data[i]);
  409.                 return NGX_ERROR;
  410. #endif
  411.             }

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

  416.                 if (++i == sc->source->len) {
  417.                     goto invalid_variable;
  418.                 }

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

  422.             } else {
  423.                 bracket = 0;
  424.                 name.data = &sc->source->data[i];
  425.             }

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

  430.                 if (ch == '}' && bracket) {
  431.                     i++;
  432.                     bracket = 0;
  433.                     break;
  434.                 }

  436.                 if ((ch >= 'A' && ch <= 'Z')
  437.                     || (ch >= 'a' && ch <= 'z')
  438.                     || (ch >= '0' && ch <= '9')
  439.                     || ch == '_')
  440.                 {
  441.                     continue;
  442.                 }

  444.                 break;
  445.             }

  447.             if (bracket) {
  448.                 ngx_conf_log_error(NGX_LOG_EMERG, sc->cf, 0,
  449.                                    "the closing bracket in \"%V\" "
  450.                                    "variable is missing", &name);
  451.                 return NGX_ERROR;
  452.             }

  454.             if (name.len == 0) {
  455.                 goto invalid_variable;
  456.             }

  458.             sc->variables++;

  460.             if (ngx_stream_script_add_var_code(sc, &name) != NGX_OK) {
  461.                 return NGX_ERROR;
  462.             }

  464.             continue;
  465.         }

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

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

  471.             if (sc->source->data[i] == '$') {
  472.                 break;
  473.             }

  475.             i++;
  476.             name.len++;
  477.         }

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

  481.         if (ngx_stream_script_add_copy_code(sc, &name, (i == sc->source->len))
  482.             != NGX_OK)
  483.         {
  484.             return NGX_ERROR;
  485.         }
  486.     }

  488.     return ngx_stream_script_done(sc);

  490. invalid_variable:

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

  494.     return NGX_ERROR;
  495. }


  498. u_char *
  499. ‌ngx_stream_script_run(ngx_stream_session_t *s, ngx_str_t *value,
  500.     void *code_lengths, size_t len, void *code_values)
  501. {
  502.     size_t                          n;
  503.     ngx_uint_t                      i;
  504.     ngx_stream_script_code_pt       code;
  505.     ngx_stream_script_engine_t      e;
  506.     ngx_stream_core_main_conf_t    *cmcf;
  507.     ngx_stream_script_len_code_pt   lcode;

  509.     cmcf = ngx_stream_get_module_main_conf(s, ngx_stream_core_module);

  511.     for (i = 0; i < cmcf->variables.nelts; i++) {
  512.         if (s->variables[i].no_cacheable) {
  513.             s->variables[i].valid = 0;
  514.             s->variables[i].not_found = 0;
  515.         }
  516.     }

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

  520.     e.ip = code_lengths;
  521.     e.session = s;
  522.     e.flushed = 1;

  524.     n = len;

  526.     while (*(uintptr_t *) e.ip) {
  527.         lcode = *(ngx_stream_script_len_code_pt *) e.ip;
  528.         n += lcode(&e);
  529.     }


  532.     value->len = n;
  533.     value->data = ngx_pnalloc(s->connection->pool, n);
  534.     if (value->data == NULL) {
  535.         return NULL;
  536.     }

  538.     e.ip = code_values;
  539.     e.pos = value->data;
  540.     e.end = value->data + n;

  542.     while (*(uintptr_t *) e.ip) {
  543.         code = *(ngx_stream_script_code_pt *) e.ip;
  544.         code((ngx_stream_script_engine_t *) &e);
  545.     }

  547.     if (e.status) {
  548.         return NULL;
  549.     }

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

  553.     return e.pos;
  554. }


  557. void
  558. ‌ngx_stream_script_flush_no_cacheable_variables(ngx_stream_session_t *s,
  559.     ngx_array_t *indices)
  560. {
  561.     ngx_uint_t  n, *index;

  563.     if (indices) {
  564.         index = indices->elts;
  565.         for (n = 0; n < indices->nelts; n++) {
  566.             if (s->variables[index[n]].no_cacheable) {
  567.                 s->variables[index[n]].valid = 0;
  568.                 s->variables[index[n]].not_found = 0;
  569.             }
  570.         }
  571.     }
  572. }


  575. static ngx_int_t
  576. ‌ngx_stream_script_init_arrays(ngx_stream_script_compile_t *sc)
  577. {
  578.     ngx_uint_t   n;

  580.     if (sc->flushes && *sc->flushes == NULL) {
  581.         n = sc->variables ? sc->variables : 1;
  582.         *sc->flushes = ngx_array_create(sc->cf->pool, n, sizeof(ngx_uint_t));
  583.         if (*sc->flushes == NULL) {
  584.             return NGX_ERROR;
  585.         }
  586.     }

  588.     if (*sc->lengths == NULL) {
  589.         n = sc->variables * (2 * sizeof(ngx_stream_script_copy_code_t)
  590.                              + sizeof(ngx_stream_script_var_code_t))
  591.             + sizeof(uintptr_t);

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

  599.     if (*sc->values == NULL) {
  600.         n = (sc->variables * (2 * sizeof(ngx_stream_script_copy_code_t)
  601.                               + sizeof(ngx_stream_script_var_code_t))
  602.                 + sizeof(uintptr_t)
  603.                 + sc->source->len
  604.                 + sizeof(uintptr_t) - 1)
  605.             & ~(sizeof(uintptr_t) - 1);

  607.         *sc->values = ngx_array_create(sc->cf->pool, n, 1);
  608.         if (*sc->values == NULL) {
  609.             return NGX_ERROR;
  610.         }
  611.     }

  613.     sc->variables = 0;

  615.     return NGX_OK;
  616. }


  619. static ngx_int_t
  620. ‌ngx_stream_script_done(ngx_stream_script_compile_t *sc)
  621. {
  622.     ngx_str_t    zero;
  623.     uintptr_t   *code;

  625.     if (sc->zero) {

  627.         zero.len = 1;
  628.         zero.data = (u_char *) "\0";

  630.         if (ngx_stream_script_add_copy_code(sc, &zero, 0) != NGX_OK) {
  631.             return NGX_ERROR;
  632.         }
  633.     }

  635.     if (sc->conf_prefix || sc->root_prefix) {
  636.         if (ngx_stream_script_add_full_name_code(sc) != NGX_OK) {
  637.             return NGX_ERROR;
  638.         }
  639.     }

  641.     if (sc->complete_lengths) {
  642.         code = ngx_stream_script_add_code(*sc->lengths, sizeof(uintptr_t),
  643.                                           NULL);
  644.         if (code == NULL) {
  645.             return NGX_ERROR;
  646.         }

  648.         *code = (uintptr_t) NULL;
  649.     }

  651.     if (sc->complete_values) {
  652.         code = ngx_stream_script_add_code(*sc->values, sizeof(uintptr_t),
  653.                                           &sc->main);
  654.         if (code == NULL) {
  655.             return NGX_ERROR;
  656.         }

  658.         *code = (uintptr_t) NULL;
  659.     }

  661.     return NGX_OK;
  662. }


  665. void *
  666. ‌ngx_stream_script_add_code(ngx_array_t *codes, size_t size, void *code)
  667. {
  668.     u_char  *elts, **p;
  669.     void    *new;

  671.     elts = codes->elts;

  673.     new = ngx_array_push_n(codes, size);
  674.     if (new == NULL) {
  675.         return NULL;
  676.     }

  678.     if (code) {
  679.         if (elts != codes->elts) {
  680.             p = code;
  681.             *p += (u_char *) codes->elts - elts;
  682.         }
  683.     }

  685.     return new;
  686. }


  689. ngx_int_t
  690. ‌ngx_stream_script_check_length(ngx_stream_script_engine_t *e, size_t len)
  691. {
  692.     if (e->end == NULL) {
  693.         return NGX_OK;
  694.     }

  696.     if (e->end - e->pos < (ssize_t) len) {
  697.         ngx_log_error(NGX_LOG_ALERT, e->session->connection->log, 0,
  698.                       "no buffer space in script copy");
  699.         e->ip = ngx_stream_script_exit;
  700.         e->status = NGX_STREAM_INTERNAL_SERVER_ERROR;
  701.         return NGX_ERROR;
  702.     }

  704.     return NGX_OK;
  705. }


  708. static ngx_int_t
  709. ‌ngx_stream_script_add_copy_code(ngx_stream_script_compile_t *sc,
  710.     ngx_str_t *value, ngx_uint_t last)
  711. {
  712.     u_char                         *p;
  713.     size_t                          size, len, zero;
  714.     ngx_stream_script_copy_code_t  *code;

  716.     zero = (sc->zero && last);
  717.     len = value->len + zero;

  719.     code = ngx_stream_script_add_code(*sc->lengths,
  720.                                       sizeof(ngx_stream_script_copy_code_t),
  721.                                       NULL);
  722.     if (code == NULL) {
  723.         return NGX_ERROR;
  724.     }

  726.     code->code = (ngx_stream_script_code_pt) (void *)
  727.                                                ngx_stream_script_copy_len_code;
  728.     code->len = len;

  730.     size = (sizeof(ngx_stream_script_copy_code_t) + len + sizeof(uintptr_t) - 1)
  731.             & ~(sizeof(uintptr_t) - 1);

  733.     code = ngx_stream_script_add_code(*sc->values, size, &sc->main);
  734.     if (code == NULL) {
  735.         return NGX_ERROR;
  736.     }

  738.     code->code = ngx_stream_script_copy_code;
  739.     code->len = len;

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

  744.     if (zero) {
  745.         *p = '\0';
  746.         sc->zero = 0;
  747.     }

  749.     return NGX_OK;
  750. }


  753. size_t
  754. ‌ngx_stream_script_copy_len_code(ngx_stream_script_engine_t *e)
  755. {
  756.     ngx_stream_script_copy_code_t  *code;

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

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

  762.     return code->len;
  763. }


  766. void
  767. ‌ngx_stream_script_copy_code(ngx_stream_script_engine_t *e)
  768. {
  769.     u_char                         *p;
  770.     ngx_stream_script_copy_code_t  *code;

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

  774.     p = e->pos;

  776.     if (!e->skip) {

  778.         if (ngx_stream_script_check_length(e, code->len) != NGX_OK) {
  779.             return;
  780.         }

  782.         e->pos = ngx_copy(p, e->ip + sizeof(ngx_stream_script_copy_code_t),
  783.                           code->len);
  784.     }

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

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


  794. static ngx_int_t
  795. ‌ngx_stream_script_add_var_code(ngx_stream_script_compile_t *sc, ngx_str_t *name)
  796. {
  797.     ngx_int_t                      index, *p;
  798.     ngx_stream_script_var_code_t  *code;

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

  802.     if (index == NGX_ERROR) {
  803.         return NGX_ERROR;
  804.     }

  806.     if (sc->flushes) {
  807.         p = ngx_array_push(*sc->flushes);
  808.         if (p == NULL) {
  809.             return NGX_ERROR;
  810.         }

  812.         *p = index;
  813.     }

  815.     code = ngx_stream_script_add_code(*sc->lengths,
  816.                                       sizeof(ngx_stream_script_var_code_t),
  817.                                       NULL);
  818.     if (code == NULL) {
  819.         return NGX_ERROR;
  820.     }

  822.     code->code = (ngx_stream_script_code_pt) (void *)
  823.                                            ngx_stream_script_copy_var_len_code;
  824.     code->index = (uintptr_t) index;

  826.     code = ngx_stream_script_add_code(*sc->values,
  827.                                       sizeof(ngx_stream_script_var_code_t),
  828.                                       &sc->main);
  829.     if (code == NULL) {
  830.         return NGX_ERROR;
  831.     }

  833.     code->code = ngx_stream_script_copy_var_code;
  834.     code->index = (uintptr_t) index;

  836.     return NGX_OK;
  837. }


  840. size_t
  841. ‌ngx_stream_script_copy_var_len_code(ngx_stream_script_engine_t *e)
  842. {
  843.     ngx_stream_variable_value_t   *value;
  844.     ngx_stream_script_var_code_t  *code;

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

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

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

  853.     } else {
  854.         value = ngx_stream_get_flushed_variable(e->session, code->index);
  855.     }

  857.     if (value && !value->not_found) {
  858.         return value->len;
  859.     }

  861.     return 0;
  862. }


  865. void
  866. ‌ngx_stream_script_copy_var_code(ngx_stream_script_engine_t *e)
  867. {
  868.     u_char                        *p;
  869.     ngx_stream_variable_value_t   *value;
  870.     ngx_stream_script_var_code_t  *code;

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

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

  876.     if (!e->skip) {

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

  881.         } else {
  882.             value = ngx_stream_get_flushed_variable(e->session, code->index);
  883.         }

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

  887.             if (ngx_stream_script_check_length(e, value->len) != NGX_OK) {
  888.                 return;
  889.             }

  891.             p = e->pos;
  892.             e->pos = ngx_copy(p, value->data, value->len);

  894.             ngx_log_debug2(NGX_LOG_DEBUG_STREAM,
  895.                            e->session->connection->log, 0,
  896.                            "stream script var: \"%*s\"", e->pos - p, p);
  897.         }
  898.     }
  899. }


  902. #if (NGX_PCRE)

  904. static ngx_int_t
  905. ‌ngx_stream_script_add_capture_code(ngx_stream_script_compile_t *sc,
  906.     ngx_uint_t n)
  907. {
  908.     ngx_stream_script_copy_capture_code_t  *code;

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

  917.     code->code = (ngx_stream_script_code_pt) (void *)
  918.                                        ngx_stream_script_copy_capture_len_code;
  919.     code->n = 2 * n;


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

  929.     code->code = ngx_stream_script_copy_capture_code;
  930.     code->n = 2 * n;

  932.     if (sc->ncaptures < n) {
  933.         sc->ncaptures = n;
  934.     }

  936.     return NGX_OK;
  937. }


  940. size_t
  941. ‌ngx_stream_script_copy_capture_len_code(ngx_stream_script_engine_t *e)
  942. {
  943.     int                                    *cap;
  944.     size_t                                  len;
  945.     ngx_uint_t                              n;
  946.     ngx_stream_session_t                   *s;
  947.     ngx_stream_script_copy_capture_code_t  *code;

  949.     s = e->session;

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

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

  955.     n = code->n;

  957.     if (n < s->ncaptures) {
  958.         cap = s->captures;
  959.         len = cap[n + 1] - cap[n];
  960.         return len;
  961.     }

  963.     return 0;
  964. }


  967. void
  968. ‌ngx_stream_script_copy_capture_code(ngx_stream_script_engine_t *e)
  969. {
  970.     int                                    *cap;
  971.     u_char                                 *p, *pos;
  972.     size_t                                  len;
  973.     ngx_uint_t                              n;
  974.     ngx_stream_session_t                   *s;
  975.     ngx_stream_script_copy_capture_code_t  *code;

  977.     s = e->session;

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

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

  983.     n = code->n;

  985.     pos = e->pos;

  987.     if (n < s->ncaptures) {
  988.         cap = s->captures;
  989.         len = cap[n + 1] - cap[n];
  990.         p = s->captures_data + cap[n];

  992.         if (ngx_stream_script_check_length(e, len) != NGX_OK) {
  993.             return;
  994.         }

  996.         e->pos = ngx_copy(pos, p, len);
  997.     }

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

  1003. #endif


  1006. static ngx_int_t
  1007. ‌ngx_stream_script_add_full_name_code(ngx_stream_script_compile_t *sc)
  1008. {
  1009.     ngx_stream_script_full_name_code_t  *code;

  1011.     code = ngx_stream_script_add_code(*sc->lengths,
  1012.                                     sizeof(ngx_stream_script_full_name_code_t),
  1013.                                     NULL);
  1014.     if (code == NULL) {
  1015.         return NGX_ERROR;
  1016.     }

  1018.     code->code = (ngx_stream_script_code_pt) (void *)
  1019.                                           ngx_stream_script_full_name_len_code;
  1020.     code->conf_prefix = sc->conf_prefix;

  1022.     code = ngx_stream_script_add_code(*sc->values,
  1023.                         sizeof(ngx_stream_script_full_name_code_t), &sc->main);
  1024.     if (code == NULL) {
  1025.         return NGX_ERROR;
  1026.     }

  1028.     code->code = ngx_stream_script_full_name_code;
  1029.     code->conf_prefix = sc->conf_prefix;

  1031.     return NGX_OK;
  1032. }


  1035. static size_t
  1036. ‌ngx_stream_script_full_name_len_code(ngx_stream_script_engine_t *e)
  1037. {
  1038.     ngx_stream_script_full_name_code_t  *code;

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

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

  1044.     return code->conf_prefix ? ngx_cycle->conf_prefix.len:
  1045.                                ngx_cycle->prefix.len;
  1046. }


  1049. static void
  1050. ‌ngx_stream_script_full_name_code(ngx_stream_script_engine_t *e)
  1051. {
  1052.     ngx_stream_script_full_name_code_t  *code;

  1054.     ngx_str_t  value, *prefix;

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

  1058.     value.data = e->buf.data;
  1059.     value.len = e->pos - e->buf.data;

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

  1064.     if (ngx_get_full_name(e->session->connection->pool, prefix, &value)
  1065.         != NGX_OK)
  1066.     {
  1067.         e->ip = ngx_stream_script_exit;
  1068.         e->status = NGX_STREAM_INTERNAL_SERVER_ERROR;
  1069.         return;
  1070.     }

  1072.     e->buf = value;
  1073.     e->pos = value.data + value.len;
  1074.     e->end = e->pos;

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

  1079.     e->ip += sizeof(ngx_stream_script_full_name_code_t);
  1080. }

One Level Up Top Level