One Level Up Top Level

src/http/modules/ngx_http_rewrite_module.c - nginx source code

Global variables defined

Data types defined

Functions 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. ‌typedef struct {
  14.     ngx_array_t  *codes;        /* uintptr_t */

  16.     ngx_uint_t    stack_size;

  18.     ngx_flag_t    log;
  19.     ngx_flag_t    uninitialized_variable_warn;
  20. ‌} ngx_http_rewrite_loc_conf_t;


  23. static void *ngx_http_rewrite_create_loc_conf(ngx_conf_t *cf);
  24. static char *ngx_http_rewrite_merge_loc_conf(ngx_conf_t *cf,
  25.     void *parent, void *child);
  26. static ngx_int_t ngx_http_rewrite_init(ngx_conf_t *cf);
  27. static char *ngx_http_rewrite(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
  28. static char *ngx_http_rewrite_return(ngx_conf_t *cf, ngx_command_t *cmd,
  29.     void *conf);
  30. static char *ngx_http_rewrite_break(ngx_conf_t *cf, ngx_command_t *cmd,
  31.     void *conf);
  32. static char *ngx_http_rewrite_if(ngx_conf_t *cf, ngx_command_t *cmd,
  33.     void *conf);
  34. static char * ngx_http_rewrite_if_condition(ngx_conf_t *cf,
  35.     ngx_http_rewrite_loc_conf_t *lcf);
  36. static char *ngx_http_rewrite_variable(ngx_conf_t *cf,
  37.     ngx_http_rewrite_loc_conf_t *lcf, ngx_str_t *value);
  38. static char *ngx_http_rewrite_set(ngx_conf_t *cf, ngx_command_t *cmd,
  39.     void *conf);
  40. static char * ngx_http_rewrite_value(ngx_conf_t *cf,
  41.     ngx_http_rewrite_loc_conf_t *lcf, ngx_str_t *value);


  44. ‌static ngx_command_t  ngx_http_rewrite_commands[] = {

  46.     { ngx_string("rewrite"),
  47.       NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  48.                        |NGX_CONF_TAKE23,
  49.       ngx_http_rewrite,
  50.       NGX_HTTP_LOC_CONF_OFFSET,
  51.       0,
  52.       NULL },

  54.     { ngx_string("return"),
  55.       NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  56.                        |NGX_CONF_TAKE12,
  57.       ngx_http_rewrite_return,
  58.       NGX_HTTP_LOC_CONF_OFFSET,
  59.       0,
  60.       NULL },

  62.     { ngx_string("break"),
  63.       NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  64.                        |NGX_CONF_NOARGS,
  65.       ngx_http_rewrite_break,
  66.       NGX_HTTP_LOC_CONF_OFFSET,
  67.       0,
  68.       NULL },

  70.     { ngx_string("if"),
  71.       NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_BLOCK|NGX_CONF_1MORE,
  72.       ngx_http_rewrite_if,
  73.       NGX_HTTP_LOC_CONF_OFFSET,
  74.       0,
  75.       NULL },

  77.     { ngx_string("set"),
  78.       NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  79.                        |NGX_CONF_TAKE2,
  80.       ngx_http_rewrite_set,
  81.       NGX_HTTP_LOC_CONF_OFFSET,
  82.       0,
  83.       NULL },

  85.     { ngx_string("rewrite_log"),
  86.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF|NGX_HTTP_LOC_CONF
  87.                         |NGX_HTTP_LIF_CONF|NGX_CONF_FLAG,
  88.       ngx_conf_set_flag_slot,
  89.       NGX_HTTP_LOC_CONF_OFFSET,
  90.       offsetof(ngx_http_rewrite_loc_conf_t, log),
  91.       NULL },

  93.     { ngx_string("uninitialized_variable_warn"),
  94.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_SIF_CONF|NGX_HTTP_LOC_CONF
  95.                         |NGX_HTTP_LIF_CONF|NGX_CONF_FLAG,
  96.       ngx_conf_set_flag_slot,
  97.       NGX_HTTP_LOC_CONF_OFFSET,
  98.       offsetof(ngx_http_rewrite_loc_conf_t, uninitialized_variable_warn),
  99.       NULL },

  101.       ngx_null_command
  102. };


  105. ‌static ngx_http_module_t  ngx_http_rewrite_module_ctx = {
  106.     NULL,                                  /* preconfiguration */
  107.     ngx_http_rewrite_init,                 /* postconfiguration */

  109.     NULL,                                  /* create main configuration */
  110.     NULL,                                  /* init main configuration */

  112.     NULL,                                  /* create server configuration */
  113.     NULL,                                  /* merge server configuration */

  115.     ngx_http_rewrite_create_loc_conf,      /* create location configuration */
  116.     ngx_http_rewrite_merge_loc_conf        /* merge location configuration */
  117. };


  120. ‌ngx_module_t  ngx_http_rewrite_module = {
  121.     NGX_MODULE_V1,
  122.     &ngx_http_rewrite_module_ctx,          /* module context */
  123.     ngx_http_rewrite_commands,             /* module directives */
  124.     NGX_HTTP_MODULE,                       /* module type */
  125.     NULL,                                  /* init master */
  126.     NULL,                                  /* init module */
  127.     NULL,                                  /* init process */
  128.     NULL,                                  /* init thread */
  129.     NULL,                                  /* exit thread */
  130.     NULL,                                  /* exit process */
  131.     NULL,                                  /* exit master */
  132.     NGX_MODULE_V1_PADDING
  133. };


  136. static ngx_int_t
  137. ‌ngx_http_rewrite_handler(ngx_http_request_t *r)
  138. {
  139.     ngx_int_t                     index;
  140.     ngx_http_script_code_pt       code;
  141.     ngx_http_script_engine_t     *e;
  142.     ngx_http_core_srv_conf_t     *cscf;
  143.     ngx_http_core_main_conf_t    *cmcf;
  144.     ngx_http_rewrite_loc_conf_t  *rlcf;

  146.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);
  147.     cscf = ngx_http_get_module_srv_conf(r, ngx_http_core_module);
  148.     index = cmcf->phase_engine.location_rewrite_index;

  150.     if (r->phase_handler == index && r->loc_conf == cscf->ctx->loc_conf) {
  151.         /* skipping location rewrite phase for server null location */
  152.         return NGX_DECLINED;
  153.     }

  155.     rlcf = ngx_http_get_module_loc_conf(r, ngx_http_rewrite_module);

  157.     if (rlcf->codes == NULL) {
  158.         return NGX_DECLINED;
  159.     }

  161.     e = ngx_pcalloc(r->pool, sizeof(ngx_http_script_engine_t));
  162.     if (e == NULL) {
  163.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  164.     }

  166.     e->sp = ngx_pcalloc(r->pool,
  167.                         rlcf->stack_size * sizeof(ngx_http_variable_value_t));
  168.     if (e->sp == NULL) {
  169.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  170.     }

  172.     e->ip = rlcf->codes->elts;
  173.     e->request = r;
  174.     e->quote = 1;
  175.     e->log = rlcf->log;
  176.     e->status = NGX_DECLINED;

  178.     while (*(uintptr_t *) e->ip) {
  179.         code = *(ngx_http_script_code_pt *) e->ip;
  180.         code(e);
  181.     }

  183.     return e->status;
  184. }


  187. static ngx_int_t
  188. ‌ngx_http_rewrite_var(ngx_http_request_t *r, ngx_http_variable_value_t *v,
  189.     uintptr_t data)
  190. {
  191.     ngx_http_variable_t          *var;
  192.     ngx_http_core_main_conf_t    *cmcf;
  193.     ngx_http_rewrite_loc_conf_t  *rlcf;

  195.     rlcf = ngx_http_get_module_loc_conf(r, ngx_http_rewrite_module);

  197.     if (rlcf->uninitialized_variable_warn == 0) {
  198.         *v = ngx_http_variable_null_value;
  199.         return NGX_OK;
  200.     }

  202.     cmcf = ngx_http_get_module_main_conf(r, ngx_http_core_module);

  204.     var = cmcf->variables.elts;

  206.     /*
  207.      * the ngx_http_rewrite_module sets variables directly in r->variables,
  208.      * and they should be handled by ngx_http_get_indexed_variable(),
  209.      * so the handler is called only if the variable is not initialized
  210.      */

  212.     ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
  213.                   "using uninitialized \"%V\" variable", &var[data].name);

  215.     *v = ngx_http_variable_null_value;

  217.     return NGX_OK;
  218. }


  221. static void *
  222. ‌ngx_http_rewrite_create_loc_conf(ngx_conf_t *cf)
  223. {
  224.     ngx_http_rewrite_loc_conf_t  *conf;

  226.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_rewrite_loc_conf_t));
  227.     if (conf == NULL) {
  228.         return NULL;
  229.     }

  231.     conf->stack_size = NGX_CONF_UNSET_UINT;
  232.     conf->log = NGX_CONF_UNSET;
  233.     conf->uninitialized_variable_warn = NGX_CONF_UNSET;

  235.     return conf;
  236. }


  239. static char *
  240. ‌ngx_http_rewrite_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
  241. {
  242.     ngx_http_rewrite_loc_conf_t *prev = parent;
  243.     ngx_http_rewrite_loc_conf_t *conf = child;

  245.     uintptr_t  *code;

  247.     ngx_conf_merge_value(conf->log, prev->log, 0);
  248.     ngx_conf_merge_value(conf->uninitialized_variable_warn,
  249.                          prev->uninitialized_variable_warn, 1);
  250.     ngx_conf_merge_uint_value(conf->stack_size, prev->stack_size, 10);

  252.     if (conf->codes == NULL) {
  253.         return NGX_CONF_OK;
  254.     }

  256.     if (conf->codes == prev->codes) {
  257.         return NGX_CONF_OK;
  258.     }

  260.     code = ngx_array_push_n(conf->codes, sizeof(uintptr_t));
  261.     if (code == NULL) {
  262.         return NGX_CONF_ERROR;
  263.     }

  265.     *code = (uintptr_t) NULL;

  267.     return NGX_CONF_OK;
  268. }


  271. static ngx_int_t
  272. ‌ngx_http_rewrite_init(ngx_conf_t *cf)
  273. {
  274.     ngx_http_handler_pt        *h;
  275.     ngx_http_core_main_conf_t  *cmcf;

  277.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  279.     h = ngx_array_push(&cmcf->phases[NGX_HTTP_SERVER_REWRITE_PHASE].handlers);
  280.     if (h == NULL) {
  281.         return NGX_ERROR;
  282.     }

  284.     *h = ngx_http_rewrite_handler;

  286.     h = ngx_array_push(&cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers);
  287.     if (h == NULL) {
  288.         return NGX_ERROR;
  289.     }

  291.     *h = ngx_http_rewrite_handler;

  293.     return NGX_OK;
  294. }


  297. static char *
  298. ‌ngx_http_rewrite(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  299. {
  300.     ngx_http_rewrite_loc_conf_t  *lcf = conf;

  302.     ngx_str_t                         *value;
  303.     ngx_uint_t                         last;
  304.     ngx_regex_compile_t                rc;
  305.     ngx_http_script_code_pt           *code;
  306.     ngx_http_script_compile_t          sc;
  307.     ngx_http_script_regex_code_t      *regex;
  308.     ngx_http_script_regex_end_code_t  *regex_end;
  309.     u_char                             errstr[NGX_MAX_CONF_ERRSTR];

  311.     regex = ngx_http_script_start_code(cf->pool, &lcf->codes,
  312.                                        sizeof(ngx_http_script_regex_code_t));
  313.     if (regex == NULL) {
  314.         return NGX_CONF_ERROR;
  315.     }

  317.     ngx_memzero(regex, sizeof(ngx_http_script_regex_code_t));

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

  321.     if (value[2].len == 0) {
  322.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "empty replacement");
  323.         return NGX_CONF_ERROR;
  324.     }

  326.     ngx_memzero(&rc, sizeof(ngx_regex_compile_t));

  328.     rc.pattern = value[1];
  329.     rc.err.len = NGX_MAX_CONF_ERRSTR;
  330.     rc.err.data = errstr;

  332.     /* TODO: NGX_REGEX_CASELESS */

  334.     regex->regex = ngx_http_regex_compile(cf, &rc);
  335.     if (regex->regex == NULL) {
  336.         return NGX_CONF_ERROR;
  337.     }

  339.     regex->code = ngx_http_script_regex_start_code;
  340.     regex->uri = 1;
  341.     regex->name = value[1];

  343.     if (value[2].data[value[2].len - 1] == '?') {

  345.         /* the last "?" drops the original arguments */
  346.         value[2].len--;

  348.     } else {
  349.         regex->add_args = 1;
  350.     }

  352.     last = 0;

  354.     if (ngx_strncmp(value[2].data, "http://", sizeof("http://") - 1) == 0
  355.         || ngx_strncmp(value[2].data, "https://", sizeof("https://") - 1) == 0
  356.         || ngx_strncmp(value[2].data, "$scheme", sizeof("$scheme") - 1) == 0)
  357.     {
  358.         regex->status = NGX_HTTP_MOVED_TEMPORARILY;
  359.         regex->redirect = 1;
  360.         last = 1;
  361.     }

  363.     if (cf->args->nelts == 4) {
  364.         if (ngx_strcmp(value[3].data, "last") == 0) {
  365.             last = 1;

  367.         } else if (ngx_strcmp(value[3].data, "break") == 0) {
  368.             regex->break_cycle = 1;
  369.             last = 1;

  371.         } else if (ngx_strcmp(value[3].data, "redirect") == 0) {
  372.             regex->status = NGX_HTTP_MOVED_TEMPORARILY;
  373.             regex->redirect = 1;
  374.             last = 1;

  376.         } else if (ngx_strcmp(value[3].data, "permanent") == 0) {
  377.             regex->status = NGX_HTTP_MOVED_PERMANENTLY;
  378.             regex->redirect = 1;
  379.             last = 1;

  381.         } else {
  382.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  383.                                "invalid parameter \"%V\"", &value[3]);
  384.             return NGX_CONF_ERROR;
  385.         }
  386.     }

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

  390.     sc.cf = cf;
  391.     sc.source = &value[2];
  392.     sc.lengths = &regex->lengths;
  393.     sc.values = &lcf->codes;
  394.     sc.variables = ngx_http_script_variables_count(&value[2]);
  395.     sc.main = regex;
  396.     sc.complete_lengths = 1;
  397.     sc.compile_args = !regex->redirect;

  399.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  400.         return NGX_CONF_ERROR;
  401.     }

  403.     regex = sc.main;

  405.     regex->size = sc.size;
  406.     regex->args = sc.args;

  408.     if (sc.variables == 0 && !sc.dup_capture) {
  409.         regex->lengths = NULL;
  410.     }

  412.     regex_end = ngx_http_script_add_code(lcf->codes,
  413.                                       sizeof(ngx_http_script_regex_end_code_t),
  414.                                       &regex);
  415.     if (regex_end == NULL) {
  416.         return NGX_CONF_ERROR;
  417.     }

  419.     regex_end->code = ngx_http_script_regex_end_code;
  420.     regex_end->uri = regex->uri;
  421.     regex_end->args = regex->args;
  422.     regex_end->add_args = regex->add_args;
  423.     regex_end->redirect = regex->redirect;

  425.     if (last) {
  426.         code = ngx_http_script_add_code(lcf->codes, sizeof(uintptr_t), &regex);
  427.         if (code == NULL) {
  428.             return NGX_CONF_ERROR;
  429.         }

  431.         *code = NULL;
  432.     }

  434.     regex->next = (u_char *) lcf->codes->elts + lcf->codes->nelts
  435.                                               - (u_char *) regex;

  437.     return NGX_CONF_OK;
  438. }


  441. static char *
  442. ‌ngx_http_rewrite_return(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  443. {
  444.     ngx_http_rewrite_loc_conf_t  *lcf = conf;

  446.     u_char                            *p;
  447.     ngx_str_t                         *value, *v;
  448.     ngx_http_script_return_code_t     *ret;
  449.     ngx_http_compile_complex_value_t   ccv;

  451.     ret = ngx_http_script_start_code(cf->pool, &lcf->codes,
  452.                                      sizeof(ngx_http_script_return_code_t));
  453.     if (ret == NULL) {
  454.         return NGX_CONF_ERROR;
  455.     }

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

  459.     ngx_memzero(ret, sizeof(ngx_http_script_return_code_t));

  461.     ret->code = ngx_http_script_return_code;

  463.     p = value[1].data;

  465.     ret->status = ngx_atoi(p, value[1].len);

  467.     if (ret->status == (uintptr_t) NGX_ERROR) {

  469.         if (cf->args->nelts == 2
  470.             && (ngx_strncmp(p, "http://", sizeof("http://") - 1) == 0
  471.                 || ngx_strncmp(p, "https://", sizeof("https://") - 1) == 0
  472.                 || ngx_strncmp(p, "$scheme", sizeof("$scheme") - 1) == 0))
  473.         {
  474.             ret->status = NGX_HTTP_MOVED_TEMPORARILY;
  475.             v = &value[1];

  477.         } else {
  478.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  479.                                "invalid return code \"%V\"", &value[1]);
  480.             return NGX_CONF_ERROR;
  481.         }

  483.     } else {

  485.         if (ret->status > 999) {
  486.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  487.                                "invalid return code \"%V\"", &value[1]);
  488.             return NGX_CONF_ERROR;
  489.         }

  491.         if (cf->args->nelts == 2) {
  492.             ngx_str_set(&ret->text.value, "");
  493.             return NGX_CONF_OK;
  494.         }

  496.         v = &value[2];
  497.     }

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

  501.     ccv.cf = cf;
  502.     ccv.value = v;
  503.     ccv.complex_value = &ret->text;

  505.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  506.         return NGX_CONF_ERROR;
  507.     }

  509.     return NGX_CONF_OK;
  510. }


  513. static char *
  514. ‌ngx_http_rewrite_break(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  515. {
  516.     ngx_http_rewrite_loc_conf_t *lcf = conf;

  518.     ngx_http_script_code_pt  *code;

  520.     code = ngx_http_script_start_code(cf->pool, &lcf->codes, sizeof(uintptr_t));
  521.     if (code == NULL) {
  522.         return NGX_CONF_ERROR;
  523.     }

  525.     *code = ngx_http_script_break_code;

  527.     return NGX_CONF_OK;
  528. }


  531. static char *
  532. ‌ngx_http_rewrite_if(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  533. {
  534.     ngx_http_rewrite_loc_conf_t  *lcf = conf;

  536.     void                         *mconf;
  537.     char                         *rv;
  538.     u_char                       *elts;
  539.     ngx_uint_t                    i;
  540.     ngx_conf_t                    save;
  541.     ngx_http_module_t            *module;
  542.     ngx_http_conf_ctx_t          *ctx, *pctx;
  543.     ngx_http_core_loc_conf_t     *clcf, *pclcf;
  544.     ngx_http_script_if_code_t    *if_code;
  545.     ngx_http_rewrite_loc_conf_t  *nlcf;

  547.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
  548.     if (ctx == NULL) {
  549.         return NGX_CONF_ERROR;
  550.     }

  552.     pctx = cf->ctx;
  553.     ctx->main_conf = pctx->main_conf;
  554.     ctx->srv_conf = pctx->srv_conf;

  556.     ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
  557.     if (ctx->loc_conf == NULL) {
  558.         return NGX_CONF_ERROR;
  559.     }

  561.     for (i = 0; cf->cycle->modules[i]; i++) {
  562.         if (cf->cycle->modules[i]->type != NGX_HTTP_MODULE) {
  563.             continue;
  564.         }

  566.         module = cf->cycle->modules[i]->ctx;

  568.         if (module->create_loc_conf) {

  570.             mconf = module->create_loc_conf(cf);
  571.             if (mconf == NULL) {
  572.                 return NGX_CONF_ERROR;
  573.             }

  575.             ctx->loc_conf[cf->cycle->modules[i]->ctx_index] = mconf;
  576.         }
  577.     }

  579.     pclcf = pctx->loc_conf[ngx_http_core_module.ctx_index];

  581.     clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
  582.     clcf->loc_conf = ctx->loc_conf;
  583.     clcf->name = pclcf->name;
  584.     clcf->noname = 1;

  586.     if (ngx_http_add_location(cf, &pclcf->locations, clcf) != NGX_OK) {
  587.         return NGX_CONF_ERROR;
  588.     }

  590.     if (ngx_http_rewrite_if_condition(cf, lcf) != NGX_CONF_OK) {
  591.         return NGX_CONF_ERROR;
  592.     }

  594.     if_code = ngx_array_push_n(lcf->codes, sizeof(ngx_http_script_if_code_t));
  595.     if (if_code == NULL) {
  596.         return NGX_CONF_ERROR;
  597.     }

  599.     if_code->code = ngx_http_script_if_code;

  601.     elts = lcf->codes->elts;


  604.     /* the inner directives must be compiled to the same code array */

  606.     nlcf = ctx->loc_conf[ngx_http_rewrite_module.ctx_index];
  607.     nlcf->codes = lcf->codes;


  610.     save = *cf;
  611.     cf->ctx = ctx;

  613.     if (cf->cmd_type == NGX_HTTP_SRV_CONF) {
  614.         if_code->loc_conf = NULL;
  615.         cf->cmd_type = NGX_HTTP_SIF_CONF;

  617.     } else {
  618.         if_code->loc_conf = ctx->loc_conf;
  619.         cf->cmd_type = NGX_HTTP_LIF_CONF;
  620.     }

  622.     rv = ngx_conf_parse(cf, NULL);

  624.     *cf = save;

  626.     if (rv != NGX_CONF_OK) {
  627.         return rv;
  628.     }


  631.     if (elts != lcf->codes->elts) {
  632.         if_code = (ngx_http_script_if_code_t *)
  633.                    ((u_char *) if_code + ((u_char *) lcf->codes->elts - elts));
  634.     }

  636.     if_code->next = (u_char *) lcf->codes->elts + lcf->codes->nelts
  637.                                                 - (u_char *) if_code;

  639.     /* the code array belong to parent block */

  641.     nlcf->codes = NULL;

  643.     return NGX_CONF_OK;
  644. }


  647. static char *
  648. ‌ngx_http_rewrite_if_condition(ngx_conf_t *cf, ngx_http_rewrite_loc_conf_t *lcf)
  649. {
  650.     u_char                        *p;
  651.     size_t                         len;
  652.     ngx_str_t                     *value;
  653.     ngx_uint_t                     cur, last;
  654.     ngx_regex_compile_t            rc;
  655.     ngx_http_script_code_pt       *code;
  656.     ngx_http_script_file_code_t   *fop;
  657.     ngx_http_script_regex_code_t  *regex;
  658.     u_char                         errstr[NGX_MAX_CONF_ERRSTR];

  660.     value = cf->args->elts;
  661.     last = cf->args->nelts - 1;

  663.     if (value[1].len < 1 || value[1].data[0] != '(') {
  664.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  665.                            "invalid condition \"%V\"", &value[1]);
  666.         return NGX_CONF_ERROR;
  667.     }

  669.     if (value[1].len == 1) {
  670.         cur = 2;

  672.     } else {
  673.         cur = 1;
  674.         value[1].len--;
  675.         value[1].data++;
  676.     }

  678.     if (value[last].len < 1 || value[last].data[value[last].len - 1] != ')') {
  679.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  680.                            "invalid condition \"%V\"", &value[last]);
  681.         return NGX_CONF_ERROR;
  682.     }

  684.     if (value[last].len == 1) {
  685.         last--;

  687.     } else {
  688.         value[last].len--;
  689.         value[last].data[value[last].len] = '\0';
  690.     }

  692.     len = value[cur].len;
  693.     p = value[cur].data;

  695.     if (len > 1 && p[0] == '$') {

  697.         if (cur != last && cur + 2 != last) {
  698.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  699.                                "invalid condition \"%V\"", &value[cur]);
  700.             return NGX_CONF_ERROR;
  701.         }

  703.         if (ngx_http_rewrite_variable(cf, lcf, &value[cur]) != NGX_CONF_OK) {
  704.             return NGX_CONF_ERROR;
  705.         }

  707.         if (cur == last) {
  708.             return NGX_CONF_OK;
  709.         }

  711.         cur++;

  713.         len = value[cur].len;
  714.         p = value[cur].data;

  716.         if (len == 1 && p[0] == '=') {

  718.             if (ngx_http_rewrite_value(cf, lcf, &value[last]) != NGX_CONF_OK) {
  719.                 return NGX_CONF_ERROR;
  720.             }

  722.             code = ngx_http_script_start_code(cf->pool, &lcf->codes,
  723.                                               sizeof(uintptr_t));
  724.             if (code == NULL) {
  725.                 return NGX_CONF_ERROR;
  726.             }

  728.             *code = ngx_http_script_equal_code;

  730.             return NGX_CONF_OK;
  731.         }

  733.         if (len == 2 && p[0] == '!' && p[1] == '=') {

  735.             if (ngx_http_rewrite_value(cf, lcf, &value[last]) != NGX_CONF_OK) {
  736.                 return NGX_CONF_ERROR;
  737.             }

  739.             code = ngx_http_script_start_code(cf->pool, &lcf->codes,
  740.                                               sizeof(uintptr_t));
  741.             if (code == NULL) {
  742.                 return NGX_CONF_ERROR;
  743.             }

  745.             *code = ngx_http_script_not_equal_code;
  746.             return NGX_CONF_OK;
  747.         }

  749.         if ((len == 1 && p[0] == '~')
  750.             || (len == 2 && p[0] == '~' && p[1] == '*')
  751.             || (len == 2 && p[0] == '!' && p[1] == '~')
  752.             || (len == 3 && p[0] == '!' && p[1] == '~' && p[2] == '*'))
  753.         {
  754.             regex = ngx_http_script_start_code(cf->pool, &lcf->codes,
  755.                                          sizeof(ngx_http_script_regex_code_t));
  756.             if (regex == NULL) {
  757.                 return NGX_CONF_ERROR;
  758.             }

  760.             ngx_memzero(regex, sizeof(ngx_http_script_regex_code_t));

  762.             ngx_memzero(&rc, sizeof(ngx_regex_compile_t));

  764.             rc.pattern = value[last];
  765.             rc.options = (p[len - 1] == '*') ? NGX_REGEX_CASELESS : 0;
  766.             rc.err.len = NGX_MAX_CONF_ERRSTR;
  767.             rc.err.data = errstr;

  769.             regex->regex = ngx_http_regex_compile(cf, &rc);
  770.             if (regex->regex == NULL) {
  771.                 return NGX_CONF_ERROR;
  772.             }

  774.             regex->code = ngx_http_script_regex_start_code;
  775.             regex->next = sizeof(ngx_http_script_regex_code_t);
  776.             regex->test = 1;
  777.             if (p[0] == '!') {
  778.                 regex->negative_test = 1;
  779.             }
  780.             regex->name = value[last];

  782.             return NGX_CONF_OK;
  783.         }

  785.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  786.                            "unexpected \"%V\" in condition", &value[cur]);
  787.         return NGX_CONF_ERROR;

  789.     } else if ((len == 2 && p[0] == '-')
  790.                || (len == 3 && p[0] == '!' && p[1] == '-'))
  791.     {
  792.         if (cur + 1 != last) {
  793.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  794.                                "invalid condition \"%V\"", &value[cur]);
  795.             return NGX_CONF_ERROR;
  796.         }

  798.         value[last].data[value[last].len] = '\0';
  799.         value[last].len++;

  801.         if (ngx_http_rewrite_value(cf, lcf, &value[last]) != NGX_CONF_OK) {
  802.             return NGX_CONF_ERROR;
  803.         }

  805.         fop = ngx_http_script_start_code(cf->pool, &lcf->codes,
  806.                                           sizeof(ngx_http_script_file_code_t));
  807.         if (fop == NULL) {
  808.             return NGX_CONF_ERROR;
  809.         }

  811.         fop->code = ngx_http_script_file_code;

  813.         if (p[1] == 'f') {
  814.             fop->op = ngx_http_script_file_plain;
  815.             return NGX_CONF_OK;
  816.         }

  818.         if (p[1] == 'd') {
  819.             fop->op = ngx_http_script_file_dir;
  820.             return NGX_CONF_OK;
  821.         }

  823.         if (p[1] == 'e') {
  824.             fop->op = ngx_http_script_file_exists;
  825.             return NGX_CONF_OK;
  826.         }

  828.         if (p[1] == 'x') {
  829.             fop->op = ngx_http_script_file_exec;
  830.             return NGX_CONF_OK;
  831.         }

  833.         if (p[0] == '!') {
  834.             if (p[2] == 'f') {
  835.                 fop->op = ngx_http_script_file_not_plain;
  836.                 return NGX_CONF_OK;
  837.             }

  839.             if (p[2] == 'd') {
  840.                 fop->op = ngx_http_script_file_not_dir;
  841.                 return NGX_CONF_OK;
  842.             }

  844.             if (p[2] == 'e') {
  845.                 fop->op = ngx_http_script_file_not_exists;
  846.                 return NGX_CONF_OK;
  847.             }

  849.             if (p[2] == 'x') {
  850.                 fop->op = ngx_http_script_file_not_exec;
  851.                 return NGX_CONF_OK;
  852.             }
  853.         }

  855.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  856.                            "invalid condition \"%V\"", &value[cur]);
  857.         return NGX_CONF_ERROR;
  858.     }

  860.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  861.                        "invalid condition \"%V\"", &value[cur]);

  863.     return NGX_CONF_ERROR;
  864. }


  867. static char *
  868. ‌ngx_http_rewrite_variable(ngx_conf_t *cf, ngx_http_rewrite_loc_conf_t *lcf,
  869.     ngx_str_t *value)
  870. {
  871.     ngx_int_t                    index;
  872.     ngx_http_script_var_code_t  *var_code;

  874.     value->len--;
  875.     value->data++;

  877.     index = ngx_http_get_variable_index(cf, value);

  879.     if (index == NGX_ERROR) {
  880.         return NGX_CONF_ERROR;
  881.     }

  883.     var_code = ngx_http_script_start_code(cf->pool, &lcf->codes,
  884.                                           sizeof(ngx_http_script_var_code_t));
  885.     if (var_code == NULL) {
  886.         return NGX_CONF_ERROR;
  887.     }

  889.     var_code->code = ngx_http_script_var_code;
  890.     var_code->index = index;

  892.     return NGX_CONF_OK;
  893. }


  896. static char *
  897. ‌ngx_http_rewrite_set(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  898. {
  899.     ngx_http_rewrite_loc_conf_t  *lcf = conf;

  901.     ngx_int_t                            index;
  902.     ngx_str_t                           *value;
  903.     ngx_http_variable_t                 *v;
  904.     ngx_http_script_var_code_t          *vcode;
  905.     ngx_http_script_var_handler_code_t  *vhcode;

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

  909.     if (value[1].data[0] != '$') {
  910.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  911.                            "invalid variable name \"%V\"", &value[1]);
  912.         return NGX_CONF_ERROR;
  913.     }

  915.     value[1].len--;
  916.     value[1].data++;

  918.     v = ngx_http_add_variable(cf, &value[1],
  919.                               NGX_HTTP_VAR_CHANGEABLE|NGX_HTTP_VAR_WEAK);
  920.     if (v == NULL) {
  921.         return NGX_CONF_ERROR;
  922.     }

  924.     index = ngx_http_get_variable_index(cf, &value[1]);
  925.     if (index == NGX_ERROR) {
  926.         return NGX_CONF_ERROR;
  927.     }

  929.     if (v->get_handler == NULL) {
  930.         v->get_handler = ngx_http_rewrite_var;
  931.         v->data = index;
  932.     }

  934.     if (ngx_http_rewrite_value(cf, lcf, &value[2]) != NGX_CONF_OK) {
  935.         return NGX_CONF_ERROR;
  936.     }

  938.     if (v->set_handler) {
  939.         vhcode = ngx_http_script_start_code(cf->pool, &lcf->codes,
  940.                                    sizeof(ngx_http_script_var_handler_code_t));
  941.         if (vhcode == NULL) {
  942.             return NGX_CONF_ERROR;
  943.         }

  945.         vhcode->code = ngx_http_script_var_set_handler_code;
  946.         vhcode->handler = v->set_handler;
  947.         vhcode->data = v->data;

  949.         return NGX_CONF_OK;
  950.     }

  952.     vcode = ngx_http_script_start_code(cf->pool, &lcf->codes,
  953.                                        sizeof(ngx_http_script_var_code_t));
  954.     if (vcode == NULL) {
  955.         return NGX_CONF_ERROR;
  956.     }

  958.     vcode->code = ngx_http_script_set_var_code;
  959.     vcode->index = (uintptr_t) index;

  961.     return NGX_CONF_OK;
  962. }


  965. static char *
  966. ‌ngx_http_rewrite_value(ngx_conf_t *cf, ngx_http_rewrite_loc_conf_t *lcf,
  967.     ngx_str_t *value)
  968. {
  969.     ngx_int_t                              n;
  970.     ngx_http_script_compile_t              sc;
  971.     ngx_http_script_value_code_t          *val;
  972.     ngx_http_script_complex_value_code_t  *complex;

  974.     n = ngx_http_script_variables_count(value);

  976.     if (n == 0) {
  977.         val = ngx_http_script_start_code(cf->pool, &lcf->codes,
  978.                                          sizeof(ngx_http_script_value_code_t));
  979.         if (val == NULL) {
  980.             return NGX_CONF_ERROR;
  981.         }

  983.         n = ngx_atoi(value->data, value->len);

  985.         if (n == NGX_ERROR) {
  986.             n = 0;
  987.         }

  989.         val->code = ngx_http_script_value_code;
  990.         val->value = (uintptr_t) n;
  991.         val->text_len = (uintptr_t) value->len;
  992.         val->text_data = (uintptr_t) value->data;

  994.         return NGX_CONF_OK;
  995.     }

  997.     complex = ngx_http_script_start_code(cf->pool, &lcf->codes,
  998.                                  sizeof(ngx_http_script_complex_value_code_t));
  999.     if (complex == NULL) {
  1000.         return NGX_CONF_ERROR;
  1001.     }

  1003.     complex->code = ngx_http_script_complex_value_code;
  1004.     complex->lengths = NULL;

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

  1008.     sc.cf = cf;
  1009.     sc.source = value;
  1010.     sc.lengths = &complex->lengths;
  1011.     sc.values = &lcf->codes;
  1012.     sc.variables = n;
  1013.     sc.complete_lengths = 1;

  1015.     if (ngx_http_script_compile(&sc) != NGX_OK) {
  1016.         return NGX_CONF_ERROR;
  1017.     }

  1019.     return NGX_CONF_OK;
  1020. }

One Level Up Top Level