One Level Up Top Level

src/http/modules/ngx_http_sub_filter_module.c - nginx-1.7.10

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_str_t                  match;
  15.     ngx_http_complex_value_t   value;

  17.     ngx_hash_t                 types;

  19.     ngx_flag_t                 once;
  20.     ngx_flag_t                 last_modified;

  22.     ngx_array_t               *types_keys;
  23. ‌} ngx_http_sub_loc_conf_t;


  26. typedef enum {
  27.     sub_start_state = 0,
  28.     sub_match_state,
  29. ‌} ngx_http_sub_state_e;


  32. typedef struct {
  33.     ngx_str_t                  match;
  34.     ngx_str_t                  saved;
  35.     ngx_str_t                  looked;

  37.     ngx_uint_t                 once;   /* unsigned  once:1 */

  39.     ngx_buf_t                 *buf;

  41.     u_char                    *pos;
  42.     u_char                    *copy_start;
  43.     u_char                    *copy_end;

  45.     ngx_chain_t               *in;
  46.     ngx_chain_t               *out;
  47.     ngx_chain_t              **last_out;
  48.     ngx_chain_t               *busy;
  49.     ngx_chain_t               *free;

  51.     ngx_str_t                  sub;

  53.     ngx_uint_t                 state;
  54. ‌} ngx_http_sub_ctx_t;


  57. static ngx_int_t ngx_http_sub_output(ngx_http_request_t *r,
  58.     ngx_http_sub_ctx_t *ctx);
  59. static ngx_int_t ngx_http_sub_parse(ngx_http_request_t *r,
  60.     ngx_http_sub_ctx_t *ctx);

  62. static char * ngx_http_sub_filter(ngx_conf_t *cf, ngx_command_t *cmd,
  63.     void *conf);
  64. static void *ngx_http_sub_create_conf(ngx_conf_t *cf);
  65. static char *ngx_http_sub_merge_conf(ngx_conf_t *cf,
  66.     void *parent, void *child);
  67. static ngx_int_t ngx_http_sub_filter_init(ngx_conf_t *cf);


  70. ‌static ngx_command_t  ngx_http_sub_filter_commands[] = {

  72.     { ngx_string("sub_filter"),
  73.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  74.       ngx_http_sub_filter,
  75.       NGX_HTTP_LOC_CONF_OFFSET,
  76.       0,
  77.       NULL },

  79.     { ngx_string("sub_filter_types"),
  80.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  81.       ngx_http_types_slot,
  82.       NGX_HTTP_LOC_CONF_OFFSET,
  83.       offsetof(ngx_http_sub_loc_conf_t, types_keys),
  84.       &ngx_http_html_default_types[0] },

  86.     { ngx_string("sub_filter_once"),
  87.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  88.       ngx_conf_set_flag_slot,
  89.       NGX_HTTP_LOC_CONF_OFFSET,
  90.       offsetof(ngx_http_sub_loc_conf_t, once),
  91.       NULL },

  93.     { ngx_string("sub_filter_last_modified"),
  94.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  95.       ngx_conf_set_flag_slot,
  96.       NGX_HTTP_LOC_CONF_OFFSET,
  97.       offsetof(ngx_http_sub_loc_conf_t, last_modified),
  98.       NULL },

  100.       ngx_null_command
  101. };


  104. ‌static ngx_http_module_t  ngx_http_sub_filter_module_ctx = {
  105.     NULL,                                  /* preconfiguration */
  106.     ngx_http_sub_filter_init,              /* postconfiguration */

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

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

  114.     ngx_http_sub_create_conf,              /* create location configuration */
  115.     ngx_http_sub_merge_conf                /* merge location configuration */
  116. };


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


  135. ‌static ngx_http_output_header_filter_pt  ngx_http_next_header_filter;
  136. ‌static ngx_http_output_body_filter_pt    ngx_http_next_body_filter;


  139. static ngx_int_t
  140. ‌ngx_http_sub_header_filter(ngx_http_request_t *r)
  141. {
  142.     ngx_http_sub_ctx_t        *ctx;
  143.     ngx_http_sub_loc_conf_t  *slcf;

  145.     slcf = ngx_http_get_module_loc_conf(r, ngx_http_sub_filter_module);

  147.     if (slcf->match.len == 0
  148.         || r->headers_out.content_length_n == 0
  149.         || ngx_http_test_content_type(r, &slcf->types) == NULL)
  150.     {
  151.         return ngx_http_next_header_filter(r);
  152.     }

  154.     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_sub_ctx_t));
  155.     if (ctx == NULL) {
  156.         return NGX_ERROR;
  157.     }

  159.     ctx->saved.data = ngx_pnalloc(r->pool, slcf->match.len);
  160.     if (ctx->saved.data == NULL) {
  161.         return NGX_ERROR;
  162.     }

  164.     ctx->looked.data = ngx_pnalloc(r->pool, slcf->match.len);
  165.     if (ctx->looked.data == NULL) {
  166.         return NGX_ERROR;
  167.     }

  169.     ngx_http_set_ctx(r, ctx, ngx_http_sub_filter_module);

  171.     ctx->match = slcf->match;
  172.     ctx->last_out = &ctx->out;

  174.     r->filter_need_in_memory = 1;

  176.     if (r == r->main) {
  177.         ngx_http_clear_content_length(r);

  179.         if (!slcf->last_modified) {
  180.             ngx_http_clear_last_modified(r);
  181.             ngx_http_clear_etag(r);

  183.         } else {
  184.             ngx_http_weak_etag(r);
  185.         }
  186.     }

  188.     return ngx_http_next_header_filter(r);
  189. }


  192. static ngx_int_t
  193. ‌ngx_http_sub_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
  194. {
  195.     ngx_int_t                  rc;
  196.     ngx_buf_t                 *b;
  197.     ngx_chain_t               *cl;
  198.     ngx_http_sub_ctx_t        *ctx;
  199.     ngx_http_sub_loc_conf_t   *slcf;

  201.     ctx = ngx_http_get_module_ctx(r, ngx_http_sub_filter_module);

  203.     if (ctx == NULL) {
  204.         return ngx_http_next_body_filter(r, in);
  205.     }

  207.     if ((in == NULL
  208.          && ctx->buf == NULL
  209.          && ctx->in == NULL
  210.          && ctx->busy == NULL))
  211.     {
  212.         return ngx_http_next_body_filter(r, in);
  213.     }

  215.     if (ctx->once && (ctx->buf == NULL || ctx->in == NULL)) {

  217.         if (ctx->busy) {
  218.             if (ngx_http_sub_output(r, ctx) == NGX_ERROR) {
  219.                 return NGX_ERROR;
  220.             }
  221.         }

  223.         return ngx_http_next_body_filter(r, in);
  224.     }

  226.     /* add the incoming chain to the chain ctx->in */

  228.     if (in) {
  229.         if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
  230.             return NGX_ERROR;
  231.         }
  232.     }

  234.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  235.                    "http sub filter \"%V\"", &r->uri);

  237.     while (ctx->in || ctx->buf) {

  239.         if (ctx->buf == NULL) {
  240.             ctx->buf = ctx->in->buf;
  241.             ctx->in = ctx->in->next;
  242.             ctx->pos = ctx->buf->pos;
  243.         }

  245.         if (ctx->state == sub_start_state) {
  246.             ctx->copy_start = ctx->pos;
  247.             ctx->copy_end = ctx->pos;
  248.         }

  250.         b = NULL;

  252.         while (ctx->pos < ctx->buf->last) {

  254.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  255.                            "saved: \"%V\" state: %d", &ctx->saved, ctx->state);

  257.             rc = ngx_http_sub_parse(r, ctx);

  259.             ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  260.                            "parse: %d, looked: \"%V\" %p-%p",
  261.                            rc, &ctx->looked, ctx->copy_start, ctx->copy_end);

  263.             if (rc == NGX_ERROR) {
  264.                 return rc;
  265.             }

  267.             if (ctx->saved.len) {

  269.                 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  270.                                "saved: \"%V\"", &ctx->saved);

  272.                 cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  273.                 if (cl == NULL) {
  274.                     return NGX_ERROR;
  275.                 }

  277.                 b = cl->buf;

  279.                 ngx_memzero(b, sizeof(ngx_buf_t));

  281.                 b->pos = ngx_pnalloc(r->pool, ctx->saved.len);
  282.                 if (b->pos == NULL) {
  283.                     return NGX_ERROR;
  284.                 }

  286.                 ngx_memcpy(b->pos, ctx->saved.data, ctx->saved.len);
  287.                 b->last = b->pos + ctx->saved.len;
  288.                 b->memory = 1;

  290.                 *ctx->last_out = cl;
  291.                 ctx->last_out = &cl->next;

  293.                 ctx->saved.len = 0;
  294.             }

  296.             if (ctx->copy_start != ctx->copy_end) {

  298.                 cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  299.                 if (cl == NULL) {
  300.                     return NGX_ERROR;
  301.                 }

  303.                 b = cl->buf;

  305.                 ngx_memcpy(b, ctx->buf, sizeof(ngx_buf_t));

  307.                 b->pos = ctx->copy_start;
  308.                 b->last = ctx->copy_end;
  309.                 b->shadow = NULL;
  310.                 b->last_buf = 0;
  311.                 b->last_in_chain = 0;
  312.                 b->recycled = 0;

  314.                 if (b->in_file) {
  315.                     b->file_last = b->file_pos + (b->last - ctx->buf->pos);
  316.                     b->file_pos += b->pos - ctx->buf->pos;
  317.                 }

  319.                 *ctx->last_out = cl;
  320.                 ctx->last_out = &cl->next;
  321.             }

  323.             if (ctx->state == sub_start_state) {
  324.                 ctx->copy_start = ctx->pos;
  325.                 ctx->copy_end = ctx->pos;

  327.             } else {
  328.                 ctx->copy_start = NULL;
  329.                 ctx->copy_end = NULL;
  330.             }

  332.             if (ctx->looked.len > (size_t) (ctx->pos - ctx->buf->pos)) {
  333.                 ctx->saved.len = ctx->looked.len - (ctx->pos - ctx->buf->pos);
  334.                 ngx_memcpy(ctx->saved.data, ctx->looked.data, ctx->saved.len);
  335.             }

  337.             if (rc == NGX_AGAIN) {
  338.                 continue;
  339.             }


  342.             /* rc == NGX_OK */

  344.             cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  345.             if (cl == NULL) {
  346.                 return NGX_ERROR;
  347.             }

  349.             b = cl->buf;

  351.             ngx_memzero(b, sizeof(ngx_buf_t));

  353.             slcf = ngx_http_get_module_loc_conf(r, ngx_http_sub_filter_module);

  355.             if (ctx->sub.data == NULL) {

  357.                 if (ngx_http_complex_value(r, &slcf->value, &ctx->sub)
  358.                     != NGX_OK)
  359.                 {
  360.                     return NGX_ERROR;
  361.                 }
  362.             }

  364.             if (ctx->sub.len) {
  365.                 b->memory = 1;
  366.                 b->pos = ctx->sub.data;
  367.                 b->last = ctx->sub.data + ctx->sub.len;

  369.             } else {
  370.                 b->sync = 1;
  371.             }

  373.             *ctx->last_out = cl;
  374.             ctx->last_out = &cl->next;

  376.             ctx->once = slcf->once;

  378.             continue;
  379.         }

  381.         if (ctx->looked.len
  382.             && (ctx->buf->last_buf || ctx->buf->last_in_chain))
  383.         {
  384.             cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  385.             if (cl == NULL) {
  386.                 return NGX_ERROR;
  387.             }

  389.             b = cl->buf;

  391.             ngx_memzero(b, sizeof(ngx_buf_t));

  393.             b->pos = ctx->looked.data;
  394.             b->last = b->pos + ctx->looked.len;
  395.             b->memory = 1;

  397.             *ctx->last_out = cl;
  398.             ctx->last_out = &cl->next;

  400.             ctx->looked.len = 0;
  401.         }

  403.         if (ctx->buf->last_buf || ctx->buf->flush || ctx->buf->sync
  404.             || ngx_buf_in_memory(ctx->buf))
  405.         {
  406.             if (b == NULL) {
  407.                 cl = ngx_chain_get_free_buf(r->pool, &ctx->free);
  408.                 if (cl == NULL) {
  409.                     return NGX_ERROR;
  410.                 }

  412.                 b = cl->buf;

  414.                 ngx_memzero(b, sizeof(ngx_buf_t));

  416.                 b->sync = 1;

  418.                 *ctx->last_out = cl;
  419.                 ctx->last_out = &cl->next;
  420.             }

  422.             b->last_buf = ctx->buf->last_buf;
  423.             b->last_in_chain = ctx->buf->last_in_chain;
  424.             b->flush = ctx->buf->flush;
  425.             b->shadow = ctx->buf;

  427.             b->recycled = ctx->buf->recycled;
  428.         }

  430.         ctx->buf = NULL;

  432.         ctx->saved.len = ctx->looked.len;
  433.         ngx_memcpy(ctx->saved.data, ctx->looked.data, ctx->looked.len);
  434.     }

  436.     if (ctx->out == NULL && ctx->busy == NULL) {
  437.         return NGX_OK;
  438.     }

  440.     return ngx_http_sub_output(r, ctx);
  441. }


  444. static ngx_int_t
  445. ‌ngx_http_sub_output(ngx_http_request_t *r, ngx_http_sub_ctx_t *ctx)
  446. {
  447.     ngx_int_t     rc;
  448.     ngx_buf_t    *b;
  449.     ngx_chain_t  *cl;

  451. #if 1
  452.     b = NULL;
  453.     for (cl = ctx->out; cl; cl = cl->next) {
  454.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  455.                        "sub out: %p %p", cl->buf, cl->buf->pos);
  456.         if (cl->buf == b) {
  457.             ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  458.                           "the same buf was used in sub");
  459.             ngx_debug_point();
  460.             return NGX_ERROR;
  461.         }
  462.         b = cl->buf;
  463.     }
  464. #endif

  466.     rc = ngx_http_next_body_filter(r, ctx->out);

  468.     if (ctx->busy == NULL) {
  469.         ctx->busy = ctx->out;

  471.     } else {
  472.         for (cl = ctx->busy; cl->next; cl = cl->next) { /* void */ }
  473.         cl->next = ctx->out;
  474.     }

  476.     ctx->out = NULL;
  477.     ctx->last_out = &ctx->out;

  479.     while (ctx->busy) {

  481.         cl = ctx->busy;
  482.         b = cl->buf;

  484.         if (ngx_buf_size(b) != 0) {
  485.             break;
  486.         }

  488.         if (b->shadow) {
  489.             b->shadow->pos = b->shadow->last;
  490.         }

  492.         ctx->busy = cl->next;

  494.         if (ngx_buf_in_memory(b) || b->in_file) {
  495.             /* add data bufs only to the free buf chain */

  497.             cl->next = ctx->free;
  498.             ctx->free = cl;
  499.         }
  500.     }

  502.     if (ctx->in || ctx->buf) {
  503.         r->buffered |= NGX_HTTP_SUB_BUFFERED;

  505.     } else {
  506.         r->buffered &= ~NGX_HTTP_SUB_BUFFERED;
  507.     }

  509.     return rc;
  510. }


  513. static ngx_int_t
  514. ‌ngx_http_sub_parse(ngx_http_request_t *r, ngx_http_sub_ctx_t *ctx)
  515. {
  516.     u_char                *p, *last, *copy_end, ch, match;
  517.     size_t                 looked, i;
  518.     ngx_http_sub_state_e   state;

  520.     if (ctx->once) {
  521.         ctx->copy_start = ctx->pos;
  522.         ctx->copy_end = ctx->buf->last;
  523.         ctx->pos = ctx->buf->last;
  524.         ctx->looked.len = 0;

  526.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "once");

  528.         return NGX_AGAIN;
  529.     }

  531.     state = ctx->state;
  532.     looked = ctx->looked.len;
  533.     last = ctx->buf->last;
  534.     copy_end = ctx->copy_end;

  536.     for (p = ctx->pos; p < last; p++) {

  538.         ch = *p;
  539.         ch = ngx_tolower(ch);

  541.         if (state == sub_start_state) {

  543.             /* the tight loop */

  545.             match = ctx->match.data[0];

  547.             for ( ;; ) {
  548.                 if (ch == match) {

  550.                     if (ctx->match.len == 1) {
  551.                         ctx->pos = p + 1;
  552.                         ctx->copy_end = p;

  554.                         return NGX_OK;
  555.                     }

  557.                     copy_end = p;
  558.                     ctx->looked.data[0] = *p;
  559.                     looked = 1;
  560.                     state = sub_match_state;

  562.                     goto match_started;
  563.                 }

  565.                 if (++p == last) {
  566.                     break;
  567.                 }

  569.                 ch = *p;
  570.                 ch = ngx_tolower(ch);
  571.             }

  573.             ctx->state = state;
  574.             ctx->pos = p;
  575.             ctx->looked.len = looked;
  576.             ctx->copy_end = p;

  578.             if (ctx->copy_start == NULL) {
  579.                 ctx->copy_start = ctx->buf->pos;
  580.             }

  582.             return NGX_AGAIN;

  584.         match_started:

  586.             continue;
  587.         }

  589.         /* state == sub_match_state */

  591.         if (ch == ctx->match.data[looked]) {
  592.             ctx->looked.data[looked] = *p;
  593.             looked++;

  595.             if (looked == ctx->match.len) {

  597.                 ctx->state = sub_start_state;
  598.                 ctx->pos = p + 1;
  599.                 ctx->looked.len = 0;
  600.                 ctx->saved.len = 0;
  601.                 ctx->copy_end = copy_end;

  603.                 if (ctx->copy_start == NULL && copy_end) {
  604.                     ctx->copy_start = ctx->buf->pos;
  605.                 }

  607.                 return NGX_OK;
  608.             }

  610.         } else {
  611.             /*
  612.              * check if there is another partial match in previously
  613.              * matched substring to catch cases like "aab" in "aaab"
  614.              */

  616.             ctx->looked.data[looked] = *p;
  617.             looked++;

  619.             for (i = 1; i < looked; i++) {
  620.                 if (ngx_strncasecmp(ctx->looked.data + i,
  621.                                     ctx->match.data, looked - i)
  622.                     == 0)
  623.                 {
  624.                     break;
  625.                 }
  626.             }

  628.             if (i < looked) {
  629.                 if (ctx->saved.len > i) {
  630.                     ctx->saved.len = i;
  631.                 }

  633.                 if ((size_t) (p + 1 - ctx->buf->pos) >= looked - i) {
  634.                     copy_end = p + 1 - (looked - i);
  635.                 }

  637.                 ngx_memmove(ctx->looked.data, ctx->looked.data + i, looked - i);
  638.                 looked = looked - i;

  640.             } else {
  641.                 copy_end = p;
  642.                 looked = 0;
  643.                 state = sub_start_state;
  644.             }

  646.             if (ctx->saved.len) {
  647.                 p++;
  648.                 goto out;
  649.             }
  650.         }
  651.     }

  653.     ctx->saved.len = 0;

  655. out:

  657.     ctx->state = state;
  658.     ctx->pos = p;
  659.     ctx->looked.len = looked;

  661.     ctx->copy_end = (state == sub_start_state) ? p : copy_end;

  663.     if (ctx->copy_start == NULL && ctx->copy_end) {
  664.         ctx->copy_start = ctx->buf->pos;
  665.     }

  667.     return NGX_AGAIN;
  668. }


  671. static char *
  672. ‌ngx_http_sub_filter(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  673. {
  674.     ngx_http_sub_loc_conf_t *slcf = conf;

  676.     ngx_str_t                         *value;
  677.     ngx_http_compile_complex_value_t   ccv;

  679.     if (slcf->match.data) {
  680.         return "is duplicate";
  681.     }

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

  685.     ngx_strlow(value[1].data, value[1].data, value[1].len);

  687.     slcf->match = value[1];

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

  691.     ccv.cf = cf;
  692.     ccv.value = &value[2];
  693.     ccv.complex_value = &slcf->value;

  695.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  696.         return NGX_CONF_ERROR;
  697.     }

  699.     return NGX_CONF_OK;
  700. }


  703. static void *
  704. ‌ngx_http_sub_create_conf(ngx_conf_t *cf)
  705. {
  706.     ngx_http_sub_loc_conf_t  *slcf;

  708.     slcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_sub_loc_conf_t));
  709.     if (slcf == NULL) {
  710.         return NULL;
  711.     }

  713.     /*
  714.      * set by ngx_pcalloc():
  715.      *
  716.      *     conf->match = { 0, NULL };
  717.      *     conf->types = { NULL };
  718.      *     conf->types_keys = NULL;
  719.      */

  721.     slcf->once = NGX_CONF_UNSET;
  722.     slcf->last_modified = NGX_CONF_UNSET;

  724.     return slcf;
  725. }


  728. static char *
  729. ‌ngx_http_sub_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  730. {
  731.     ngx_http_sub_loc_conf_t *prev = parent;
  732.     ngx_http_sub_loc_conf_t *conf = child;

  734.     ngx_conf_merge_value(conf->once, prev->once, 1);
  735.     ngx_conf_merge_str_value(conf->match, prev->match, "");
  736.     ngx_conf_merge_value(conf->last_modified, prev->last_modified, 0);

  738.     if (conf->value.value.data == NULL) {
  739.         conf->value = prev->value;
  740.     }

  742.     if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
  743.                              &prev->types_keys, &prev->types,
  744.                              ngx_http_html_default_types)
  745.         != NGX_OK)
  746.     {
  747.         return NGX_CONF_ERROR;
  748.     }

  750.     return NGX_CONF_OK;
  751. }


  754. static ngx_int_t
  755. ‌ngx_http_sub_filter_init(ngx_conf_t *cf)
  756. {
  757.     ngx_http_next_header_filter = ngx_http_top_header_filter;
  758.     ngx_http_top_header_filter = ngx_http_sub_header_filter;

  760.     ngx_http_next_body_filter = ngx_http_top_body_filter;
  761.     ngx_http_top_body_filter = ngx_http_sub_body_filter;

  763.     return NGX_OK;
  764. }

One Level Up Top Level