One Level Up Top Level

src/http/modules/ngx_http_gzip_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>

  12. #include <zlib.h>


  15. typedef struct {
  16.     ngx_flag_t           enable;
  17.     ngx_flag_t           no_buffer;

  19.     ngx_hash_t           types;

  21.     ngx_bufs_t           bufs;

  23.     size_t               postpone_gzipping;
  24.     ngx_int_t            level;
  25.     size_t               wbits;
  26.     size_t               memlevel;
  27.     ssize_t              min_length;

  29.     ngx_array_t         *types_keys;
  30. ‌} ngx_http_gzip_conf_t;


  33. typedef struct {
  34.     ngx_chain_t         *in;
  35.     ngx_chain_t         *free;
  36.     ngx_chain_t         *busy;
  37.     ngx_chain_t         *out;
  38.     ngx_chain_t        **last_out;

  40.     ngx_chain_t         *copied;
  41.     ngx_chain_t         *copy_buf;

  43.     ngx_buf_t           *in_buf;
  44.     ngx_buf_t           *out_buf;
  45.     ngx_int_t            bufs;

  47.     void                *preallocated;
  48.     char                *free_mem;
  49.     ngx_uint_t           allocated;

  51.     int                  wbits;
  52.     int                  memlevel;

  54.     unsigned             flush:4;
  55.     unsigned             redo:1;
  56.     unsigned             done:1;
  57.     unsigned             nomem:1;
  58.     unsigned             gzheader:1;
  59.     unsigned             buffering:1;

  61.     size_t               zin;
  62.     size_t               zout;

  64.     uint32_t             crc32;
  65.     z_stream             zstream;
  66.     ngx_http_request_t  *request;
  67. ‌} ngx_http_gzip_ctx_t;


  70. #if (NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED)

  72. ‌struct gztrailer {
  73.     uint32_t  crc32;
  74.     uint32_t  zlen;
  75. };

  77. #else /* NGX_HAVE_BIG_ENDIAN || !NGX_HAVE_NONALIGNED */

  79. ‌struct gztrailer {
  80.     u_char  crc32[4];
  81.     u_char  zlen[4];
  82. };

  84. #endif


  87. static void ngx_http_gzip_filter_memory(ngx_http_request_t *r,
  88.     ngx_http_gzip_ctx_t *ctx);
  89. static ngx_int_t ngx_http_gzip_filter_buffer(ngx_http_gzip_ctx_t *ctx,
  90.     ngx_chain_t *in);
  91. static ngx_int_t ngx_http_gzip_filter_deflate_start(ngx_http_request_t *r,
  92.     ngx_http_gzip_ctx_t *ctx);
  93. static ngx_int_t ngx_http_gzip_filter_gzheader(ngx_http_request_t *r,
  94.     ngx_http_gzip_ctx_t *ctx);
  95. static ngx_int_t ngx_http_gzip_filter_add_data(ngx_http_request_t *r,
  96.     ngx_http_gzip_ctx_t *ctx);
  97. static ngx_int_t ngx_http_gzip_filter_get_buf(ngx_http_request_t *r,
  98.     ngx_http_gzip_ctx_t *ctx);
  99. static ngx_int_t ngx_http_gzip_filter_deflate(ngx_http_request_t *r,
  100.     ngx_http_gzip_ctx_t *ctx);
  101. static ngx_int_t ngx_http_gzip_filter_deflate_end(ngx_http_request_t *r,
  102.     ngx_http_gzip_ctx_t *ctx);

  104. static void *ngx_http_gzip_filter_alloc(void *opaque, u_int items,
  105.     u_int size);
  106. static void ngx_http_gzip_filter_free(void *opaque, void *address);
  107. static void ngx_http_gzip_filter_free_copy_buf(ngx_http_request_t *r,
  108.     ngx_http_gzip_ctx_t *ctx);

  110. static ngx_int_t ngx_http_gzip_add_variables(ngx_conf_t *cf);
  111. static ngx_int_t ngx_http_gzip_ratio_variable(ngx_http_request_t *r,
  112.     ngx_http_variable_value_t *v, uintptr_t data);

  114. static ngx_int_t ngx_http_gzip_filter_init(ngx_conf_t *cf);
  115. static void *ngx_http_gzip_create_conf(ngx_conf_t *cf);
  116. static char *ngx_http_gzip_merge_conf(ngx_conf_t *cf,
  117.     void *parent, void *child);
  118. static char *ngx_http_gzip_window(ngx_conf_t *cf, void *post, void *data);
  119. static char *ngx_http_gzip_hash(ngx_conf_t *cf, void *post, void *data);


  122. ‌static ngx_conf_num_bounds_t  ngx_http_gzip_comp_level_bounds = {
  123.     ngx_conf_check_num_bounds, 1, 9
  124. };

  126. ‌static ngx_conf_post_handler_pt  ngx_http_gzip_window_p = ngx_http_gzip_window;
  127. ‌static ngx_conf_post_handler_pt  ngx_http_gzip_hash_p = ngx_http_gzip_hash;


  130. ‌static ngx_command_t  ngx_http_gzip_filter_commands[] = {

  132.     { ngx_string("gzip"),
  133.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_HTTP_LIF_CONF
  134.                         |NGX_CONF_FLAG,
  135.       ngx_conf_set_flag_slot,
  136.       NGX_HTTP_LOC_CONF_OFFSET,
  137.       offsetof(ngx_http_gzip_conf_t, enable),
  138.       NULL },

  140.     { ngx_string("gzip_buffers"),
  141.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  142.       ngx_conf_set_bufs_slot,
  143.       NGX_HTTP_LOC_CONF_OFFSET,
  144.       offsetof(ngx_http_gzip_conf_t, bufs),
  145.       NULL },

  147.     { ngx_string("gzip_types"),
  148.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_1MORE,
  149.       ngx_http_types_slot,
  150.       NGX_HTTP_LOC_CONF_OFFSET,
  151.       offsetof(ngx_http_gzip_conf_t, types_keys),
  152.       &ngx_http_html_default_types[0] },

  154.     { ngx_string("gzip_comp_level"),
  155.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  156.       ngx_conf_set_num_slot,
  157.       NGX_HTTP_LOC_CONF_OFFSET,
  158.       offsetof(ngx_http_gzip_conf_t, level),
  159.       &ngx_http_gzip_comp_level_bounds },

  161.     { ngx_string("gzip_window"),
  162.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  163.       ngx_conf_set_size_slot,
  164.       NGX_HTTP_LOC_CONF_OFFSET,
  165.       offsetof(ngx_http_gzip_conf_t, wbits),
  166.       &ngx_http_gzip_window_p },

  168.     { ngx_string("gzip_hash"),
  169.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  170.       ngx_conf_set_size_slot,
  171.       NGX_HTTP_LOC_CONF_OFFSET,
  172.       offsetof(ngx_http_gzip_conf_t, memlevel),
  173.       &ngx_http_gzip_hash_p },

  175.     { ngx_string("postpone_gzipping"),
  176.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  177.       ngx_conf_set_size_slot,
  178.       NGX_HTTP_LOC_CONF_OFFSET,
  179.       offsetof(ngx_http_gzip_conf_t, postpone_gzipping),
  180.       NULL },

  182.     { ngx_string("gzip_no_buffer"),
  183.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  184.       ngx_conf_set_flag_slot,
  185.       NGX_HTTP_LOC_CONF_OFFSET,
  186.       offsetof(ngx_http_gzip_conf_t, no_buffer),
  187.       NULL },

  189.     { ngx_string("gzip_min_length"),
  190.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  191.       ngx_conf_set_size_slot,
  192.       NGX_HTTP_LOC_CONF_OFFSET,
  193.       offsetof(ngx_http_gzip_conf_t, min_length),
  194.       NULL },

  196.       ngx_null_command
  197. };


  200. ‌static ngx_http_module_t  ngx_http_gzip_filter_module_ctx = {
  201.     ngx_http_gzip_add_variables,           /* preconfiguration */
  202.     ngx_http_gzip_filter_init,             /* postconfiguration */

  204.     NULL,                                  /* create main configuration */
  205.     NULL,                                  /* init main configuration */

  207.     NULL,                                  /* create server configuration */
  208.     NULL,                                  /* merge server configuration */

  210.     ngx_http_gzip_create_conf,             /* create location configuration */
  211.     ngx_http_gzip_merge_conf               /* merge location configuration */
  212. };


  215. ‌ngx_module_t  ngx_http_gzip_filter_module = {
  216.     NGX_MODULE_V1,
  217.     &ngx_http_gzip_filter_module_ctx,      /* module context */
  218.     ngx_http_gzip_filter_commands,         /* module directives */
  219.     NGX_HTTP_MODULE,                       /* module type */
  220.     NULL,                                  /* init master */
  221.     NULL,                                  /* init module */
  222.     NULL,                                  /* init process */
  223.     NULL,                                  /* init thread */
  224.     NULL,                                  /* exit thread */
  225.     NULL,                                  /* exit process */
  226.     NULL,                                  /* exit master */
  227.     NGX_MODULE_V1_PADDING
  228. };


  231. ‌static ngx_str_t  ngx_http_gzip_ratio = ngx_string("gzip_ratio");

  233. ‌static ngx_http_output_header_filter_pt  ngx_http_next_header_filter;
  234. ‌static ngx_http_output_body_filter_pt    ngx_http_next_body_filter;


  237. static ngx_int_t
  238. ‌ngx_http_gzip_header_filter(ngx_http_request_t *r)
  239. {
  240.     ngx_table_elt_t       *h;
  241.     ngx_http_gzip_ctx_t   *ctx;
  242.     ngx_http_gzip_conf_t  *conf;

  244.     conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);

  246.     if (!conf->enable
  247.         || (r->headers_out.status != NGX_HTTP_OK
  248.             && r->headers_out.status != NGX_HTTP_FORBIDDEN
  249.             && r->headers_out.status != NGX_HTTP_NOT_FOUND)
  250.         || (r->headers_out.content_encoding
  251.             && r->headers_out.content_encoding->value.len)
  252.         || (r->headers_out.content_length_n != -1
  253.             && r->headers_out.content_length_n < conf->min_length)
  254.         || ngx_http_test_content_type(r, &conf->types) == NULL
  255.         || r->header_only)
  256.     {
  257.         return ngx_http_next_header_filter(r);
  258.     }

  260.     r->gzip_vary = 1;

  262. #if (NGX_HTTP_DEGRADATION)
  263.     {
  264.     ngx_http_core_loc_conf_t  *clcf;

  266.     clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);

  268.     if (clcf->gzip_disable_degradation && ngx_http_degraded(r)) {
  269.         return ngx_http_next_header_filter(r);
  270.     }
  271.     }
  272. #endif

  274.     if (!r->gzip_tested) {
  275.         if (ngx_http_gzip_ok(r) != NGX_OK) {
  276.             return ngx_http_next_header_filter(r);
  277.         }

  279.     } else if (!r->gzip_ok) {
  280.         return ngx_http_next_header_filter(r);
  281.     }

  283.     ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_gzip_ctx_t));
  284.     if (ctx == NULL) {
  285.         return NGX_ERROR;
  286.     }

  288.     ngx_http_set_ctx(r, ctx, ngx_http_gzip_filter_module);

  290.     ctx->request = r;
  291.     ctx->buffering = (conf->postpone_gzipping != 0);

  293.     ngx_http_gzip_filter_memory(r, ctx);

  295.     h = ngx_list_push(&r->headers_out.headers);
  296.     if (h == NULL) {
  297.         return NGX_ERROR;
  298.     }

  300.     h->hash = 1;
  301.     ngx_str_set(&h->key, "Content-Encoding");
  302.     ngx_str_set(&h->value, "gzip");
  303.     r->headers_out.content_encoding = h;

  305.     r->main_filter_need_in_memory = 1;

  307.     ngx_http_clear_content_length(r);
  308.     ngx_http_clear_accept_ranges(r);
  309.     ngx_http_weak_etag(r);

  311.     return ngx_http_next_header_filter(r);
  312. }


  315. static ngx_int_t
  316. ‌ngx_http_gzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
  317. {
  318.     int                   rc;
  319.     ngx_uint_t            flush;
  320.     ngx_chain_t          *cl;
  321.     ngx_http_gzip_ctx_t  *ctx;

  323.     ctx = ngx_http_get_module_ctx(r, ngx_http_gzip_filter_module);

  325.     if (ctx == NULL || ctx->done || r->header_only) {
  326.         return ngx_http_next_body_filter(r, in);
  327.     }

  329.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  330.                    "http gzip filter");

  332.     if (ctx->buffering) {

  334.         /*
  335.          * With default memory settings zlib starts to output gzipped data
  336.          * only after it has got about 90K, so it makes sense to allocate
  337.          * zlib memory (200-400K) only after we have enough data to compress.
  338.          * Although we copy buffers, nevertheless for not big responses
  339.          * this allows to allocate zlib memory, to compress and to output
  340.          * the response in one step using hot CPU cache.
  341.          */

  343.         if (in) {
  344.             switch (ngx_http_gzip_filter_buffer(ctx, in)) {

  346.             case NGX_OK:
  347.                 return NGX_OK;

  349.             case NGX_DONE:
  350.                 in = NULL;
  351.                 break;

  353.             default:  /* NGX_ERROR */
  354.                 goto failed;
  355.             }

  357.         } else {
  358.             ctx->buffering = 0;
  359.         }
  360.     }

  362.     if (ctx->preallocated == NULL) {
  363.         if (ngx_http_gzip_filter_deflate_start(r, ctx) != NGX_OK) {
  364.             goto failed;
  365.         }
  366.     }

  368.     if (in) {
  369.         if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
  370.             goto failed;
  371.         }

  373.         r->connection->buffered |= NGX_HTTP_GZIP_BUFFERED;
  374.     }

  376.     if (ctx->nomem) {

  378.         /* flush busy buffers */

  380.         if (ngx_http_next_body_filter(r, NULL) == NGX_ERROR) {
  381.             goto failed;
  382.         }

  384.         cl = NULL;

  386.         ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &cl,
  387.                                 (ngx_buf_tag_t) &ngx_http_gzip_filter_module);
  388.         ctx->nomem = 0;
  389.         flush = 0;

  391.     } else {
  392.         flush = ctx->busy ? 1 : 0;
  393.     }

  395.     for ( ;; ) {

  397.         /* cycle while we can write to a client */

  399.         for ( ;; ) {

  401.             /* cycle while there is data to feed zlib and ... */

  403.             rc = ngx_http_gzip_filter_add_data(r, ctx);

  405.             if (rc == NGX_DECLINED) {
  406.                 break;
  407.             }

  409.             if (rc == NGX_AGAIN) {
  410.                 continue;
  411.             }


  414.             /* ... there are buffers to write zlib output */

  416.             rc = ngx_http_gzip_filter_get_buf(r, ctx);

  418.             if (rc == NGX_DECLINED) {
  419.                 break;
  420.             }

  422.             if (rc == NGX_ERROR) {
  423.                 goto failed;
  424.             }


  427.             rc = ngx_http_gzip_filter_deflate(r, ctx);

  429.             if (rc == NGX_OK) {
  430.                 break;
  431.             }

  433.             if (rc == NGX_ERROR) {
  434.                 goto failed;
  435.             }

  437.             /* rc == NGX_AGAIN */
  438.         }

  440.         if (ctx->out == NULL && !flush) {
  441.             ngx_http_gzip_filter_free_copy_buf(r, ctx);

  443.             return ctx->busy ? NGX_AGAIN : NGX_OK;
  444.         }

  446.         if (!ctx->gzheader) {
  447.             if (ngx_http_gzip_filter_gzheader(r, ctx) != NGX_OK) {
  448.                 goto failed;
  449.             }
  450.         }

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

  454.         if (rc == NGX_ERROR) {
  455.             goto failed;
  456.         }

  458.         ngx_http_gzip_filter_free_copy_buf(r, ctx);

  460.         ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &ctx->out,
  461.                                 (ngx_buf_tag_t) &ngx_http_gzip_filter_module);
  462.         ctx->last_out = &ctx->out;

  464.         ctx->nomem = 0;
  465.         flush = 0;

  467.         if (ctx->done) {
  468.             return rc;
  469.         }
  470.     }

  472.     /* unreachable */

  474. failed:

  476.     ctx->done = 1;

  478.     if (ctx->preallocated) {
  479.         deflateEnd(&ctx->zstream);

  481.         ngx_pfree(r->pool, ctx->preallocated);
  482.     }

  484.     ngx_http_gzip_filter_free_copy_buf(r, ctx);

  486.     return NGX_ERROR;
  487. }


  490. static void
  491. ‌ngx_http_gzip_filter_memory(ngx_http_request_t *r, ngx_http_gzip_ctx_t *ctx)
  492. {
  493.     int                    wbits, memlevel;
  494.     ngx_http_gzip_conf_t  *conf;

  496.     conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);

  498.     wbits = conf->wbits;
  499.     memlevel = conf->memlevel;

  501.     if (r->headers_out.content_length_n > 0) {

  503.         /* the actual zlib window size is smaller by 262 bytes */

  505.         while (r->headers_out.content_length_n < ((1 << (wbits - 1)) - 262)) {
  506.             wbits--;
  507.             memlevel--;
  508.         }

  510.         if (memlevel < 1) {
  511.             memlevel = 1;
  512.         }
  513.     }

  515.     ctx->wbits = wbits;
  516.     ctx->memlevel = memlevel;

  518.     /*
  519.      * We preallocate a memory for zlib in one buffer (200K-400K), this
  520.      * decreases a number of malloc() and free() calls and also probably
  521.      * decreases a number of syscalls (sbrk()/mmap() and so on).
  522.      * Besides we free the memory as soon as a gzipping will complete
  523.      * and do not wait while a whole response will be sent to a client.
  524.      *
  525.      * 8K is for zlib deflate_state, it takes
  526.      *  *) 5816 bytes on i386 and sparc64 (32-bit mode)
  527.      *  *) 5920 bytes on amd64 and sparc64
  528.      */

  530.     ctx->allocated = 8192 + (1 << (wbits + 2)) + (1 << (memlevel + 9));
  531. }


  534. static ngx_int_t
  535. ‌ngx_http_gzip_filter_buffer(ngx_http_gzip_ctx_t *ctx, ngx_chain_t *in)
  536. {
  537.     size_t                 size, buffered;
  538.     ngx_buf_t             *b, *buf;
  539.     ngx_chain_t           *cl, **ll;
  540.     ngx_http_request_t    *r;
  541.     ngx_http_gzip_conf_t  *conf;

  543.     r = ctx->request;

  545.     r->connection->buffered |= NGX_HTTP_GZIP_BUFFERED;

  547.     buffered = 0;
  548.     ll = &ctx->in;

  550.     for (cl = ctx->in; cl; cl = cl->next) {
  551.         buffered += cl->buf->last - cl->buf->pos;
  552.         ll = &cl->next;
  553.     }

  555.     conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);

  557.     while (in) {
  558.         cl = ngx_alloc_chain_link(r->pool);
  559.         if (cl == NULL) {
  560.             return NGX_ERROR;
  561.         }

  563.         b = in->buf;

  565.         size = b->last - b->pos;
  566.         buffered += size;

  568.         if (b->flush || b->last_buf || buffered > conf->postpone_gzipping) {
  569.             ctx->buffering = 0;
  570.         }

  572.         if (ctx->buffering && size) {

  574.             buf = ngx_create_temp_buf(r->pool, size);
  575.             if (buf == NULL) {
  576.                 return NGX_ERROR;
  577.             }

  579.             buf->last = ngx_cpymem(buf->pos, b->pos, size);
  580.             b->pos = b->last;

  582.             buf->last_buf = b->last_buf;
  583.             buf->tag = (ngx_buf_tag_t) &ngx_http_gzip_filter_module;

  585.             cl->buf = buf;

  587.         } else {
  588.             cl->buf = b;
  589.         }

  591.         *ll = cl;
  592.         ll = &cl->next;
  593.         in = in->next;
  594.     }

  596.     *ll = NULL;

  598.     return ctx->buffering ? NGX_OK : NGX_DONE;
  599. }


  602. static ngx_int_t
  603. ‌ngx_http_gzip_filter_deflate_start(ngx_http_request_t *r,
  604.     ngx_http_gzip_ctx_t *ctx)
  605. {
  606.     int                    rc;
  607.     ngx_http_gzip_conf_t  *conf;

  609.     conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);

  611.     ctx->preallocated = ngx_palloc(r->pool, ctx->allocated);
  612.     if (ctx->preallocated == NULL) {
  613.         return NGX_ERROR;
  614.     }

  616.     ctx->free_mem = ctx->preallocated;

  618.     ctx->zstream.zalloc = ngx_http_gzip_filter_alloc;
  619.     ctx->zstream.zfree = ngx_http_gzip_filter_free;
  620.     ctx->zstream.opaque = ctx;

  622.     rc = deflateInit2(&ctx->zstream, (int) conf->level, Z_DEFLATED,
  623.                       - ctx->wbits, ctx->memlevel, Z_DEFAULT_STRATEGY);

  625.     if (rc != Z_OK) {
  626.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  627.                       "deflateInit2() failed: %d", rc);
  628.         return NGX_ERROR;
  629.     }

  631.     ctx->last_out = &ctx->out;
  632.     ctx->crc32 = crc32(0L, Z_NULL, 0);
  633.     ctx->flush = Z_NO_FLUSH;

  635.     return NGX_OK;
  636. }


  639. static ngx_int_t
  640. ‌ngx_http_gzip_filter_gzheader(ngx_http_request_t *r, ngx_http_gzip_ctx_t *ctx)
  641. {
  642.     ngx_buf_t      *b;
  643.     ngx_chain_t    *cl;
  644.     static u_char  gzheader[10] =
  645.                                { 0x1f, 0x8b, Z_DEFLATED, 0, 0, 0, 0, 0, 0, 3 };

  647.     b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
  648.     if (b == NULL) {
  649.         return NGX_ERROR;
  650.     }

  652.     b->memory = 1;
  653.     b->pos = gzheader;
  654.     b->last = b->pos + 10;

  656.     cl = ngx_alloc_chain_link(r->pool);
  657.     if (cl == NULL) {
  658.         return NGX_ERROR;
  659.     }

  661.     cl->buf = b;
  662.     cl->next = ctx->out;
  663.     ctx->out = cl;

  665.     ctx->gzheader = 1;

  667.     return NGX_OK;
  668. }


  671. static ngx_int_t
  672. ‌ngx_http_gzip_filter_add_data(ngx_http_request_t *r, ngx_http_gzip_ctx_t *ctx)
  673. {
  674.     if (ctx->zstream.avail_in || ctx->flush != Z_NO_FLUSH || ctx->redo) {
  675.         return NGX_OK;
  676.     }

  678.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  679.                    "gzip in: %p", ctx->in);

  681.     if (ctx->in == NULL) {
  682.         return NGX_DECLINED;
  683.     }

  685.     if (ctx->copy_buf) {

  687.         /*
  688.          * to avoid CPU cache trashing we do not free() just quit buf,
  689.          * but postpone free()ing after zlib compressing and data output
  690.          */

  692.         ctx->copy_buf->next = ctx->copied;
  693.         ctx->copied = ctx->copy_buf;
  694.         ctx->copy_buf = NULL;
  695.     }

  697.     ctx->in_buf = ctx->in->buf;

  699.     if (ctx->in_buf->tag == (ngx_buf_tag_t) &ngx_http_gzip_filter_module) {
  700.         ctx->copy_buf = ctx->in;
  701.     }

  703.     ctx->in = ctx->in->next;

  705.     ctx->zstream.next_in = ctx->in_buf->pos;
  706.     ctx->zstream.avail_in = ctx->in_buf->last - ctx->in_buf->pos;

  708.     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  709.                    "gzip in_buf:%p ni:%p ai:%ud",
  710.                    ctx->in_buf,
  711.                    ctx->zstream.next_in, ctx->zstream.avail_in);

  713.     if (ctx->in_buf->last_buf) {
  714.         ctx->flush = Z_FINISH;

  716.     } else if (ctx->in_buf->flush) {
  717.         ctx->flush = Z_SYNC_FLUSH;
  718.     }

  720.     if (ctx->zstream.avail_in) {

  722.         ctx->crc32 = crc32(ctx->crc32, ctx->zstream.next_in,
  723.                            ctx->zstream.avail_in);

  725.     } else if (ctx->flush == Z_NO_FLUSH) {
  726.         return NGX_AGAIN;
  727.     }

  729.     return NGX_OK;
  730. }


  733. static ngx_int_t
  734. ‌ngx_http_gzip_filter_get_buf(ngx_http_request_t *r, ngx_http_gzip_ctx_t *ctx)
  735. {
  736.     ngx_http_gzip_conf_t  *conf;

  738.     if (ctx->zstream.avail_out) {
  739.         return NGX_OK;
  740.     }

  742.     conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);

  744.     if (ctx->free) {
  745.         ctx->out_buf = ctx->free->buf;
  746.         ctx->free = ctx->free->next;

  748.     } else if (ctx->bufs < conf->bufs.num) {

  750.         ctx->out_buf = ngx_create_temp_buf(r->pool, conf->bufs.size);
  751.         if (ctx->out_buf == NULL) {
  752.             return NGX_ERROR;
  753.         }

  755.         ctx->out_buf->tag = (ngx_buf_tag_t) &ngx_http_gzip_filter_module;
  756.         ctx->out_buf->recycled = 1;
  757.         ctx->bufs++;

  759.     } else {
  760.         ctx->nomem = 1;
  761.         return NGX_DECLINED;
  762.     }

  764.     ctx->zstream.next_out = ctx->out_buf->pos;
  765.     ctx->zstream.avail_out = conf->bufs.size;

  767.     return NGX_OK;
  768. }


  771. static ngx_int_t
  772. ‌ngx_http_gzip_filter_deflate(ngx_http_request_t *r, ngx_http_gzip_ctx_t *ctx)
  773. {
  774.     int                    rc;
  775.     ngx_buf_t             *b;
  776.     ngx_chain_t           *cl;
  777.     ngx_http_gzip_conf_t  *conf;

  779.     ngx_log_debug6(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  780.                  "deflate in: ni:%p no:%p ai:%ud ao:%ud fl:%d redo:%d",
  781.                  ctx->zstream.next_in, ctx->zstream.next_out,
  782.                  ctx->zstream.avail_in, ctx->zstream.avail_out,
  783.                  ctx->flush, ctx->redo);

  785.     rc = deflate(&ctx->zstream, ctx->flush);

  787.     if (rc != Z_OK && rc != Z_STREAM_END && rc != Z_BUF_ERROR) {
  788.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  789.                       "deflate() failed: %d, %d", ctx->flush, rc);
  790.         return NGX_ERROR;
  791.     }

  793.     ngx_log_debug5(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  794.                    "deflate out: ni:%p no:%p ai:%ud ao:%ud rc:%d",
  795.                    ctx->zstream.next_in, ctx->zstream.next_out,
  796.                    ctx->zstream.avail_in, ctx->zstream.avail_out,
  797.                    rc);

  799.     ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  800.                    "gzip in_buf:%p pos:%p",
  801.                    ctx->in_buf, ctx->in_buf->pos);

  803.     if (ctx->zstream.next_in) {
  804.         ctx->in_buf->pos = ctx->zstream.next_in;

  806.         if (ctx->zstream.avail_in == 0) {
  807.             ctx->zstream.next_in = NULL;
  808.         }
  809.     }

  811.     ctx->out_buf->last = ctx->zstream.next_out;

  813.     if (ctx->zstream.avail_out == 0) {

  815.         /* zlib wants to output some more gzipped data */

  817.         cl = ngx_alloc_chain_link(r->pool);
  818.         if (cl == NULL) {
  819.             return NGX_ERROR;
  820.         }

  822.         cl->buf = ctx->out_buf;
  823.         cl->next = NULL;
  824.         *ctx->last_out = cl;
  825.         ctx->last_out = &cl->next;

  827.         ctx->redo = 1;

  829.         return NGX_AGAIN;
  830.     }

  832.     ctx->redo = 0;

  834.     if (ctx->flush == Z_SYNC_FLUSH) {

  836.         ctx->flush = Z_NO_FLUSH;

  838.         cl = ngx_alloc_chain_link(r->pool);
  839.         if (cl == NULL) {
  840.             return NGX_ERROR;
  841.         }

  843.         b = ctx->out_buf;

  845.         if (ngx_buf_size(b) == 0) {

  847.             b = ngx_calloc_buf(ctx->request->pool);
  848.             if (b == NULL) {
  849.                 return NGX_ERROR;
  850.             }

  852.         } else {
  853.             ctx->zstream.avail_out = 0;
  854.         }

  856.         b->flush = 1;

  858.         cl->buf = b;
  859.         cl->next = NULL;
  860.         *ctx->last_out = cl;
  861.         ctx->last_out = &cl->next;

  863.         r->connection->buffered &= ~NGX_HTTP_GZIP_BUFFERED;

  865.         return NGX_OK;
  866.     }

  868.     if (rc == Z_STREAM_END) {

  870.         if (ngx_http_gzip_filter_deflate_end(r, ctx) != NGX_OK) {
  871.             return NGX_ERROR;
  872.         }

  874.         return NGX_OK;
  875.     }

  877.     conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);

  879.     if (conf->no_buffer && ctx->in == NULL) {

  881.         cl = ngx_alloc_chain_link(r->pool);
  882.         if (cl == NULL) {
  883.             return NGX_ERROR;
  884.         }

  886.         cl->buf = ctx->out_buf;
  887.         cl->next = NULL;
  888.         *ctx->last_out = cl;
  889.         ctx->last_out = &cl->next;

  891.         return NGX_OK;
  892.     }

  894.     return NGX_AGAIN;
  895. }


  898. static ngx_int_t
  899. ‌ngx_http_gzip_filter_deflate_end(ngx_http_request_t *r,
  900.     ngx_http_gzip_ctx_t *ctx)
  901. {
  902.     int                rc;
  903.     ngx_buf_t         *b;
  904.     ngx_chain_t       *cl;
  905.     struct gztrailer  *trailer;

  907.     ctx->zin = ctx->zstream.total_in;
  908.     ctx->zout = 10 + ctx->zstream.total_out + 8;

  910.     rc = deflateEnd(&ctx->zstream);

  912.     if (rc != Z_OK) {
  913.         ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
  914.                       "deflateEnd() failed: %d", rc);
  915.         return NGX_ERROR;
  916.     }

  918.     ngx_pfree(r->pool, ctx->preallocated);

  920.     cl = ngx_alloc_chain_link(r->pool);
  921.     if (cl == NULL) {
  922.         return NGX_ERROR;
  923.     }

  925.     cl->buf = ctx->out_buf;
  926.     cl->next = NULL;
  927.     *ctx->last_out = cl;
  928.     ctx->last_out = &cl->next;

  930.     if (ctx->zstream.avail_out >= 8) {
  931.         trailer = (struct gztrailer *) ctx->out_buf->last;
  932.         ctx->out_buf->last += 8;
  933.         ctx->out_buf->last_buf = 1;

  935.     } else {
  936.         b = ngx_create_temp_buf(r->pool, 8);
  937.         if (b == NULL) {
  938.             return NGX_ERROR;
  939.         }

  941.         b->last_buf = 1;

  943.         cl = ngx_alloc_chain_link(r->pool);
  944.         if (cl == NULL) {
  945.             return NGX_ERROR;
  946.         }

  948.         cl->buf = b;
  949.         cl->next = NULL;
  950.         *ctx->last_out = cl;
  951.         ctx->last_out = &cl->next;
  952.         trailer = (struct gztrailer *) b->pos;
  953.         b->last += 8;
  954.     }

  956. #if (NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED)

  958.     trailer->crc32 = ctx->crc32;
  959.     trailer->zlen = ctx->zin;

  961. #else

  963.     trailer->crc32[0] = (u_char) (ctx->crc32 & 0xff);
  964.     trailer->crc32[1] = (u_char) ((ctx->crc32 >> 8) & 0xff);
  965.     trailer->crc32[2] = (u_char) ((ctx->crc32 >> 16) & 0xff);
  966.     trailer->crc32[3] = (u_char) ((ctx->crc32 >> 24) & 0xff);

  968.     trailer->zlen[0] = (u_char) (ctx->zin & 0xff);
  969.     trailer->zlen[1] = (u_char) ((ctx->zin >> 8) & 0xff);
  970.     trailer->zlen[2] = (u_char) ((ctx->zin >> 16) & 0xff);
  971.     trailer->zlen[3] = (u_char) ((ctx->zin >> 24) & 0xff);

  973. #endif

  975.     ctx->zstream.avail_in = 0;
  976.     ctx->zstream.avail_out = 0;

  978.     ctx->done = 1;

  980.     r->connection->buffered &= ~NGX_HTTP_GZIP_BUFFERED;

  982.     return NGX_OK;
  983. }


  986. static void *
  987. ‌ngx_http_gzip_filter_alloc(void *opaque, u_int items, u_int size)
  988. {
  989.     ngx_http_gzip_ctx_t *ctx = opaque;

  991.     void        *p;
  992.     ngx_uint_t   alloc;

  994.     alloc = items * size;

  996.     if (alloc % 512 != 0 && alloc < 8192) {

  998.         /*
  999.          * The zlib deflate_state allocation, it takes about 6K,
  1000.          * we allocate 8K.  Other allocations are divisible by 512.
  1001.          */

  1003.         alloc = 8192;
  1004.     }

  1006.     if (alloc <= ctx->allocated) {
  1007.         p = ctx->free_mem;
  1008.         ctx->free_mem += alloc;
  1009.         ctx->allocated -= alloc;

  1011.         ngx_log_debug4(NGX_LOG_DEBUG_HTTP, ctx->request->connection->log, 0,
  1012.                        "gzip alloc: n:%ud s:%ud a:%ud p:%p",
  1013.                        items, size, alloc, p);

  1015.         return p;
  1016.     }

  1018.     ngx_log_error(NGX_LOG_ALERT, ctx->request->connection->log, 0,
  1019.                   "gzip filter failed to use preallocated memory: %ud of %ud",
  1020.                   items * size, ctx->allocated);

  1022.     p = ngx_palloc(ctx->request->pool, items * size);

  1024.     return p;
  1025. }


  1028. static void
  1029. ‌ngx_http_gzip_filter_free(void *opaque, void *address)
  1030. {
  1031. #if 0
  1032.     ngx_http_gzip_ctx_t *ctx = opaque;

  1034.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->request->connection->log, 0,
  1035.                    "gzip free: %p", address);
  1036. #endif
  1037. }


  1040. static void
  1041. ‌ngx_http_gzip_filter_free_copy_buf(ngx_http_request_t *r,
  1042.     ngx_http_gzip_ctx_t *ctx)
  1043. {
  1044.     ngx_chain_t  *cl;

  1046.     for (cl = ctx->copied; cl; cl = cl->next) {
  1047.         ngx_pfree(r->pool, cl->buf->start);
  1048.     }

  1050.     ctx->copied = NULL;
  1051. }


  1054. static ngx_int_t
  1055. ‌ngx_http_gzip_add_variables(ngx_conf_t *cf)
  1056. {
  1057.     ngx_http_variable_t  *var;

  1059.     var = ngx_http_add_variable(cf, &ngx_http_gzip_ratio, NGX_HTTP_VAR_NOHASH);
  1060.     if (var == NULL) {
  1061.         return NGX_ERROR;
  1062.     }

  1064.     var->get_handler = ngx_http_gzip_ratio_variable;

  1066.     return NGX_OK;
  1067. }


  1070. static ngx_int_t
  1071. ‌ngx_http_gzip_ratio_variable(ngx_http_request_t *r,
  1072.     ngx_http_variable_value_t *v, uintptr_t data)
  1073. {
  1074.     ngx_uint_t            zint, zfrac;
  1075.     ngx_http_gzip_ctx_t  *ctx;

  1077.     v->valid = 1;
  1078.     v->no_cacheable = 0;
  1079.     v->not_found = 0;

  1081.     ctx = ngx_http_get_module_ctx(r, ngx_http_gzip_filter_module);

  1083.     if (ctx == NULL || ctx->zout == 0) {
  1084.         v->not_found = 1;
  1085.         return NGX_OK;
  1086.     }

  1088.     v->data = ngx_pnalloc(r->pool, NGX_INT32_LEN + 3);
  1089.     if (v->data == NULL) {
  1090.         return NGX_ERROR;
  1091.     }

  1093.     zint = (ngx_uint_t) (ctx->zin / ctx->zout);
  1094.     zfrac = (ngx_uint_t) ((ctx->zin * 100 / ctx->zout) % 100);

  1096.     if ((ctx->zin * 1000 / ctx->zout) % 10 > 4) {

  1098.         /* the rounding, e.g., 2.125 to 2.13 */

  1100.         zfrac++;

  1102.         if (zfrac > 99) {
  1103.             zint++;
  1104.             zfrac = 0;
  1105.         }
  1106.     }

  1108.     v->len = ngx_sprintf(v->data, "%ui.%02ui", zint, zfrac) - v->data;

  1110.     return NGX_OK;
  1111. }


  1114. static void *
  1115. ‌ngx_http_gzip_create_conf(ngx_conf_t *cf)
  1116. {
  1117.     ngx_http_gzip_conf_t  *conf;

  1119.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_gzip_conf_t));
  1120.     if (conf == NULL) {
  1121.         return NULL;
  1122.     }

  1124.     /*
  1125.      * set by ngx_pcalloc():
  1126.      *
  1127.      *     conf->bufs.num = 0;
  1128.      *     conf->types = { NULL };
  1129.      *     conf->types_keys = NULL;
  1130.      */

  1132.     conf->enable = NGX_CONF_UNSET;
  1133.     conf->no_buffer = NGX_CONF_UNSET;

  1135.     conf->postpone_gzipping = NGX_CONF_UNSET_SIZE;
  1136.     conf->level = NGX_CONF_UNSET;
  1137.     conf->wbits = NGX_CONF_UNSET_SIZE;
  1138.     conf->memlevel = NGX_CONF_UNSET_SIZE;
  1139.     conf->min_length = NGX_CONF_UNSET;

  1141.     return conf;
  1142. }


  1145. static char *
  1146. ‌ngx_http_gzip_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  1147. {
  1148.     ngx_http_gzip_conf_t *prev = parent;
  1149.     ngx_http_gzip_conf_t *conf = child;

  1151.     ngx_conf_merge_value(conf->enable, prev->enable, 0);
  1152.     ngx_conf_merge_value(conf->no_buffer, prev->no_buffer, 0);

  1154.     ngx_conf_merge_bufs_value(conf->bufs, prev->bufs,
  1155.                               (128 * 1024) / ngx_pagesize, ngx_pagesize);

  1157.     ngx_conf_merge_size_value(conf->postpone_gzipping, prev->postpone_gzipping,
  1158.                               0);
  1159.     ngx_conf_merge_value(conf->level, prev->level, 1);
  1160.     ngx_conf_merge_size_value(conf->wbits, prev->wbits, MAX_WBITS);
  1161.     ngx_conf_merge_size_value(conf->memlevel, prev->memlevel,
  1162.                               MAX_MEM_LEVEL - 1);
  1163.     ngx_conf_merge_value(conf->min_length, prev->min_length, 20);

  1165.     if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
  1166.                              &prev->types_keys, &prev->types,
  1167.                              ngx_http_html_default_types)
  1168.         != NGX_OK)
  1169.     {
  1170.         return NGX_CONF_ERROR;
  1171.     }

  1173.     return NGX_CONF_OK;
  1174. }


  1177. static ngx_int_t
  1178. ‌ngx_http_gzip_filter_init(ngx_conf_t *cf)
  1179. {
  1180.     ngx_http_next_header_filter = ngx_http_top_header_filter;
  1181.     ngx_http_top_header_filter = ngx_http_gzip_header_filter;

  1183.     ngx_http_next_body_filter = ngx_http_top_body_filter;
  1184.     ngx_http_top_body_filter = ngx_http_gzip_body_filter;

  1186.     return NGX_OK;
  1187. }


  1190. static char *
  1191. ‌ngx_http_gzip_window(ngx_conf_t *cf, void *post, void *data)
  1192. {
  1193.     size_t *np = data;

  1195.     size_t  wbits, wsize;

  1197.     wbits = 15;

  1199.     for (wsize = 32 * 1024; wsize > 256; wsize >>= 1) {

  1201.         if (wsize == *np) {
  1202.             *np = wbits;

  1204.             return NGX_CONF_OK;
  1205.         }

  1207.         wbits--;
  1208.     }

  1210.     return "must be 512, 1k, 2k, 4k, 8k, 16k, or 32k";
  1211. }


  1214. static char *
  1215. ‌ngx_http_gzip_hash(ngx_conf_t *cf, void *post, void *data)
  1216. {
  1217.     size_t *np = data;

  1219.     size_t  memlevel, hsize;

  1221.     memlevel = 9;

  1223.     for (hsize = 128 * 1024; hsize > 256; hsize >>= 1) {

  1225.         if (hsize == *np) {
  1226.             *np = memlevel;

  1228.             return NGX_CONF_OK;
  1229.         }

  1231.         memlevel--;
  1232.     }

  1234.     return "must be 512, 1k, 2k, 4k, 8k, 16k, 32k, 64k, or 128k";
  1235. }

One Level Up Top Level