![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ngx_http_gzip_filter_module.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http / modules|
Return to ngx_http_gzip_filter_module.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / http / modules |
1.1 misho 1:
2: /*
3: * Copyright (C) Igor Sysoev
4: * Copyright (C) Nginx, Inc.
5: */
6:
7:
8: #include <ngx_config.h>
9: #include <ngx_core.h>
10: #include <ngx_http.h>
11:
12: #include <zlib.h>
13:
14:
15: typedef struct {
16: ngx_flag_t enable;
17: ngx_flag_t no_buffer;
18:
19: ngx_hash_t types;
20:
21: ngx_bufs_t bufs;
22:
23: size_t postpone_gzipping;
24: ngx_int_t level;
25: size_t wbits;
26: size_t memlevel;
27: ssize_t min_length;
28:
29: ngx_array_t *types_keys;
30: } ngx_http_gzip_conf_t;
31:
32:
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;
39:
40: ngx_chain_t *copied;
41: ngx_chain_t *copy_buf;
42:
43: ngx_buf_t *in_buf;
44: ngx_buf_t *out_buf;
45: ngx_int_t bufs;
46:
47: void *preallocated;
48: char *free_mem;
49: ngx_uint_t allocated;
50:
51: int wbits;
52: int memlevel;
53:
54: unsigned flush:4;
55: unsigned redo:1;
56: unsigned done:1;
57: unsigned nomem:1;
58: unsigned gzheader:1;
59: unsigned buffering:1;
60:
61: size_t zin;
62: size_t zout;
63:
64: uint32_t crc32;
65: z_stream zstream;
66: ngx_http_request_t *request;
67: } ngx_http_gzip_ctx_t;
68:
69:
70: #if (NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED)
71:
72: struct gztrailer {
73: uint32_t crc32;
74: uint32_t zlen;
75: };
76:
77: #else /* NGX_HAVE_BIG_ENDIAN || !NGX_HAVE_NONALIGNED */
78:
79: struct gztrailer {
80: u_char crc32[4];
81: u_char zlen[4];
82: };
83:
84: #endif
85:
86:
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);
103:
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);
109:
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);
113:
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);
120:
121:
122: static ngx_conf_num_bounds_t ngx_http_gzip_comp_level_bounds = {
123: ngx_conf_check_num_bounds, 1, 9
124: };
125:
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;
128:
129:
130: static ngx_command_t ngx_http_gzip_filter_commands[] = {
131:
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 },
139:
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 },
146:
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] },
153:
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 },
160:
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 },
167:
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 },
174:
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 },
181:
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 },
188:
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 },
195:
196: ngx_null_command
197: };
198:
199:
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 */
203:
204: NULL, /* create main configuration */
205: NULL, /* init main configuration */
206:
207: NULL, /* create server configuration */
208: NULL, /* merge server configuration */
209:
210: ngx_http_gzip_create_conf, /* create location configuration */
211: ngx_http_gzip_merge_conf /* merge location configuration */
212: };
213:
214:
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: };
229:
230:
231: static ngx_str_t ngx_http_gzip_ratio = ngx_string("gzip_ratio");
232:
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;
235:
236:
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;
243:
244: conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);
245:
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: }
259:
260: r->gzip_vary = 1;
261:
262: #if (NGX_HTTP_DEGRADATION)
263: {
264: ngx_http_core_loc_conf_t *clcf;
265:
266: clcf = ngx_http_get_module_loc_conf(r, ngx_http_core_module);
267:
268: if (clcf->gzip_disable_degradation && ngx_http_degraded(r)) {
269: return ngx_http_next_header_filter(r);
270: }
271: }
272: #endif
273:
274: if (!r->gzip_tested) {
275: if (ngx_http_gzip_ok(r) != NGX_OK) {
276: return ngx_http_next_header_filter(r);
277: }
278:
279: } else if (!r->gzip_ok) {
280: return ngx_http_next_header_filter(r);
281: }
282:
283: ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_gzip_ctx_t));
284: if (ctx == NULL) {
285: return NGX_ERROR;
286: }
287:
288: ngx_http_set_ctx(r, ctx, ngx_http_gzip_filter_module);
289:
290: ctx->request = r;
291: ctx->buffering = (conf->postpone_gzipping != 0);
292:
293: ngx_http_gzip_filter_memory(r, ctx);
294:
295: h = ngx_list_push(&r->headers_out.headers);
296: if (h == NULL) {
297: return NGX_ERROR;
298: }
299:
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;
304:
305: r->main_filter_need_in_memory = 1;
306:
307: ngx_http_clear_content_length(r);
308: ngx_http_clear_accept_ranges(r);
309: ngx_http_clear_etag(r);
310:
311: return ngx_http_next_header_filter(r);
312: }
313:
314:
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_chain_t *cl;
320: ngx_http_gzip_ctx_t *ctx;
321:
322: ctx = ngx_http_get_module_ctx(r, ngx_http_gzip_filter_module);
323:
324: if (ctx == NULL || ctx->done || r->header_only) {
325: return ngx_http_next_body_filter(r, in);
326: }
327:
328: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
329: "http gzip filter");
330:
331: if (ctx->buffering) {
332:
333: /*
334: * With default memory settings zlib starts to output gzipped data
335: * only after it has got about 90K, so it makes sense to allocate
336: * zlib memory (200-400K) only after we have enough data to compress.
337: * Although we copy buffers, nevertheless for not big responses
338: * this allows to allocate zlib memory, to compress and to output
339: * the response in one step using hot CPU cache.
340: */
341:
342: if (in) {
343: switch (ngx_http_gzip_filter_buffer(ctx, in)) {
344:
345: case NGX_OK:
346: return NGX_OK;
347:
348: case NGX_DONE:
349: in = NULL;
350: break;
351:
352: default: /* NGX_ERROR */
353: goto failed;
354: }
355:
356: } else {
357: ctx->buffering = 0;
358: }
359: }
360:
361: if (ctx->preallocated == NULL) {
362: if (ngx_http_gzip_filter_deflate_start(r, ctx) != NGX_OK) {
363: goto failed;
364: }
365: }
366:
367: if (in) {
368: if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
369: goto failed;
370: }
371: }
372:
373: if (ctx->nomem) {
374:
375: /* flush busy buffers */
376:
377: if (ngx_http_next_body_filter(r, NULL) == NGX_ERROR) {
378: goto failed;
379: }
380:
381: cl = NULL;
382:
383: ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &cl,
384: (ngx_buf_tag_t) &ngx_http_gzip_filter_module);
385: ctx->nomem = 0;
386: }
387:
388: for ( ;; ) {
389:
390: /* cycle while we can write to a client */
391:
392: for ( ;; ) {
393:
394: /* cycle while there is data to feed zlib and ... */
395:
396: rc = ngx_http_gzip_filter_add_data(r, ctx);
397:
398: if (rc == NGX_DECLINED) {
399: break;
400: }
401:
402: if (rc == NGX_AGAIN) {
403: continue;
404: }
405:
406:
407: /* ... there are buffers to write zlib output */
408:
409: rc = ngx_http_gzip_filter_get_buf(r, ctx);
410:
411: if (rc == NGX_DECLINED) {
412: break;
413: }
414:
415: if (rc == NGX_ERROR) {
416: goto failed;
417: }
418:
419:
420: rc = ngx_http_gzip_filter_deflate(r, ctx);
421:
422: if (rc == NGX_OK) {
423: break;
424: }
425:
426: if (rc == NGX_ERROR) {
427: goto failed;
428: }
429:
430: /* rc == NGX_AGAIN */
431: }
432:
433: if (ctx->out == NULL) {
434: ngx_http_gzip_filter_free_copy_buf(r, ctx);
435:
436: return ctx->busy ? NGX_AGAIN : NGX_OK;
437: }
438:
439: if (!ctx->gzheader) {
440: if (ngx_http_gzip_filter_gzheader(r, ctx) != NGX_OK) {
441: goto failed;
442: }
443: }
444:
445: rc = ngx_http_next_body_filter(r, ctx->out);
446:
447: if (rc == NGX_ERROR) {
448: goto failed;
449: }
450:
451: ngx_http_gzip_filter_free_copy_buf(r, ctx);
452:
453: ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &ctx->out,
454: (ngx_buf_tag_t) &ngx_http_gzip_filter_module);
455: ctx->last_out = &ctx->out;
456:
457: ctx->nomem = 0;
458:
459: if (ctx->done) {
460: return rc;
461: }
462: }
463:
464: /* unreachable */
465:
466: failed:
467:
468: ctx->done = 1;
469:
470: if (ctx->preallocated) {
471: deflateEnd(&ctx->zstream);
472:
473: ngx_pfree(r->pool, ctx->preallocated);
474: }
475:
476: ngx_http_gzip_filter_free_copy_buf(r, ctx);
477:
478: return NGX_ERROR;
479: }
480:
481:
482: static void
483: ngx_http_gzip_filter_memory(ngx_http_request_t *r, ngx_http_gzip_ctx_t *ctx)
484: {
485: int wbits, memlevel;
486: ngx_http_gzip_conf_t *conf;
487:
488: conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);
489:
490: wbits = conf->wbits;
491: memlevel = conf->memlevel;
492:
493: if (r->headers_out.content_length_n > 0) {
494:
495: /* the actual zlib window size is smaller by 262 bytes */
496:
497: while (r->headers_out.content_length_n < ((1 << (wbits - 1)) - 262)) {
498: wbits--;
499: memlevel--;
500: }
501:
502: if (memlevel < 1) {
503: memlevel = 1;
504: }
505: }
506:
507: ctx->wbits = wbits;
508: ctx->memlevel = memlevel;
509:
510: /*
511: * We preallocate a memory for zlib in one buffer (200K-400K), this
512: * decreases a number of malloc() and free() calls and also probably
513: * decreases a number of syscalls (sbrk()/mmap() and so on).
514: * Besides we free the memory as soon as a gzipping will complete
515: * and do not wait while a whole response will be sent to a client.
516: *
517: * 8K is for zlib deflate_state, it takes
518: * *) 5816 bytes on i386 and sparc64 (32-bit mode)
519: * *) 5920 bytes on amd64 and sparc64
520: */
521:
522: ctx->allocated = 8192 + (1 << (wbits + 2)) + (1 << (memlevel + 9));
523: }
524:
525:
526: static ngx_int_t
527: ngx_http_gzip_filter_buffer(ngx_http_gzip_ctx_t *ctx, ngx_chain_t *in)
528: {
529: size_t size, buffered;
530: ngx_buf_t *b, *buf;
531: ngx_chain_t *cl, **ll;
532: ngx_http_request_t *r;
533: ngx_http_gzip_conf_t *conf;
534:
535: r = ctx->request;
536:
537: r->connection->buffered |= NGX_HTTP_GZIP_BUFFERED;
538:
539: buffered = 0;
540: ll = &ctx->in;
541:
542: for (cl = ctx->in; cl; cl = cl->next) {
543: buffered += cl->buf->last - cl->buf->pos;
544: ll = &cl->next;
545: }
546:
547: conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);
548:
549: while (in) {
550: cl = ngx_alloc_chain_link(r->pool);
551: if (cl == NULL) {
552: return NGX_ERROR;
553: }
554:
555: b = in->buf;
556:
557: size = b->last - b->pos;
558: buffered += size;
559:
560: if (b->flush || b->last_buf || buffered > conf->postpone_gzipping) {
561: ctx->buffering = 0;
562: }
563:
564: if (ctx->buffering && size) {
565:
566: buf = ngx_create_temp_buf(r->pool, size);
567: if (buf == NULL) {
568: return NGX_ERROR;
569: }
570:
571: buf->last = ngx_cpymem(buf->pos, b->pos, size);
572: b->pos = b->last;
573:
574: buf->last_buf = b->last_buf;
575: buf->tag = (ngx_buf_tag_t) &ngx_http_gzip_filter_module;
576:
577: cl->buf = buf;
578:
579: } else {
580: cl->buf = b;
581: }
582:
583: *ll = cl;
584: ll = &cl->next;
585: in = in->next;
586: }
587:
588: *ll = NULL;
589:
590: return ctx->buffering ? NGX_OK : NGX_DONE;
591: }
592:
593:
594: static ngx_int_t
595: ngx_http_gzip_filter_deflate_start(ngx_http_request_t *r,
596: ngx_http_gzip_ctx_t *ctx)
597: {
598: int rc;
599: ngx_http_gzip_conf_t *conf;
600:
601: conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);
602:
603: ctx->preallocated = ngx_palloc(r->pool, ctx->allocated);
604: if (ctx->preallocated == NULL) {
605: return NGX_ERROR;
606: }
607:
608: ctx->free_mem = ctx->preallocated;
609:
610: ctx->zstream.zalloc = ngx_http_gzip_filter_alloc;
611: ctx->zstream.zfree = ngx_http_gzip_filter_free;
612: ctx->zstream.opaque = ctx;
613:
614: rc = deflateInit2(&ctx->zstream, (int) conf->level, Z_DEFLATED,
615: - ctx->wbits, ctx->memlevel, Z_DEFAULT_STRATEGY);
616:
617: if (rc != Z_OK) {
618: ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
619: "deflateInit2() failed: %d", rc);
620: return NGX_ERROR;
621: }
622:
623: r->connection->buffered |= NGX_HTTP_GZIP_BUFFERED;
624:
625: ctx->last_out = &ctx->out;
626: ctx->crc32 = crc32(0L, Z_NULL, 0);
627: ctx->flush = Z_NO_FLUSH;
628:
629: return NGX_OK;
630: }
631:
632:
633: static ngx_int_t
634: ngx_http_gzip_filter_gzheader(ngx_http_request_t *r, ngx_http_gzip_ctx_t *ctx)
635: {
636: ngx_buf_t *b;
637: ngx_chain_t *cl;
638: static u_char gzheader[10] =
639: { 0x1f, 0x8b, Z_DEFLATED, 0, 0, 0, 0, 0, 0, 3 };
640:
641: b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
642: if (b == NULL) {
643: return NGX_ERROR;
644: }
645:
646: b->memory = 1;
647: b->pos = gzheader;
648: b->last = b->pos + 10;
649:
650: cl = ngx_alloc_chain_link(r->pool);
651: if (cl == NULL) {
652: return NGX_ERROR;
653: }
654:
655: cl->buf = b;
656: cl->next = ctx->out;
657: ctx->out = cl;
658:
659: ctx->gzheader = 1;
660:
661: return NGX_OK;
662: }
663:
664:
665: static ngx_int_t
666: ngx_http_gzip_filter_add_data(ngx_http_request_t *r, ngx_http_gzip_ctx_t *ctx)
667: {
668: if (ctx->zstream.avail_in || ctx->flush != Z_NO_FLUSH || ctx->redo) {
669: return NGX_OK;
670: }
671:
672: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
673: "gzip in: %p", ctx->in);
674:
675: if (ctx->in == NULL) {
676: return NGX_DECLINED;
677: }
678:
679: if (ctx->copy_buf) {
680:
681: /*
682: * to avoid CPU cache trashing we do not free() just quit buf,
683: * but postpone free()ing after zlib compressing and data output
684: */
685:
686: ctx->copy_buf->next = ctx->copied;
687: ctx->copied = ctx->copy_buf;
688: ctx->copy_buf = NULL;
689: }
690:
691: ctx->in_buf = ctx->in->buf;
692:
693: if (ctx->in_buf->tag == (ngx_buf_tag_t) &ngx_http_gzip_filter_module) {
694: ctx->copy_buf = ctx->in;
695: }
696:
697: ctx->in = ctx->in->next;
698:
699: ctx->zstream.next_in = ctx->in_buf->pos;
700: ctx->zstream.avail_in = ctx->in_buf->last - ctx->in_buf->pos;
701:
702: ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
703: "gzip in_buf:%p ni:%p ai:%ud",
704: ctx->in_buf,
705: ctx->zstream.next_in, ctx->zstream.avail_in);
706:
707: if (ctx->in_buf->last_buf) {
708: ctx->flush = Z_FINISH;
709:
710: } else if (ctx->in_buf->flush) {
711: ctx->flush = Z_SYNC_FLUSH;
712: }
713:
714: if (ctx->zstream.avail_in) {
715:
716: ctx->crc32 = crc32(ctx->crc32, ctx->zstream.next_in,
717: ctx->zstream.avail_in);
718:
719: } else if (ctx->flush == Z_NO_FLUSH) {
720: return NGX_AGAIN;
721: }
722:
723: return NGX_OK;
724: }
725:
726:
727: static ngx_int_t
728: ngx_http_gzip_filter_get_buf(ngx_http_request_t *r, ngx_http_gzip_ctx_t *ctx)
729: {
730: ngx_http_gzip_conf_t *conf;
731:
732: if (ctx->zstream.avail_out) {
733: return NGX_OK;
734: }
735:
736: conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);
737:
738: if (ctx->free) {
739: ctx->out_buf = ctx->free->buf;
740: ctx->free = ctx->free->next;
741:
742: } else if (ctx->bufs < conf->bufs.num) {
743:
744: ctx->out_buf = ngx_create_temp_buf(r->pool, conf->bufs.size);
745: if (ctx->out_buf == NULL) {
746: return NGX_ERROR;
747: }
748:
749: ctx->out_buf->tag = (ngx_buf_tag_t) &ngx_http_gzip_filter_module;
750: ctx->out_buf->recycled = 1;
751: ctx->bufs++;
752:
753: } else {
754: ctx->nomem = 1;
755: return NGX_DECLINED;
756: }
757:
758: ctx->zstream.next_out = ctx->out_buf->pos;
759: ctx->zstream.avail_out = conf->bufs.size;
760:
761: return NGX_OK;
762: }
763:
764:
765: static ngx_int_t
766: ngx_http_gzip_filter_deflate(ngx_http_request_t *r, ngx_http_gzip_ctx_t *ctx)
767: {
768: int rc;
769: ngx_buf_t *b;
770: ngx_chain_t *cl;
771: ngx_http_gzip_conf_t *conf;
772:
773: ngx_log_debug6(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
774: "deflate in: ni:%p no:%p ai:%ud ao:%ud fl:%d redo:%d",
775: ctx->zstream.next_in, ctx->zstream.next_out,
776: ctx->zstream.avail_in, ctx->zstream.avail_out,
777: ctx->flush, ctx->redo);
778:
779: rc = deflate(&ctx->zstream, ctx->flush);
780:
781: if (rc != Z_OK && rc != Z_STREAM_END && rc != Z_BUF_ERROR) {
782: ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
783: "deflate() failed: %d, %d", ctx->flush, rc);
784: return NGX_ERROR;
785: }
786:
787: ngx_log_debug5(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
788: "deflate out: ni:%p no:%p ai:%ud ao:%ud rc:%d",
789: ctx->zstream.next_in, ctx->zstream.next_out,
790: ctx->zstream.avail_in, ctx->zstream.avail_out,
791: rc);
792:
793: ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
794: "gzip in_buf:%p pos:%p",
795: ctx->in_buf, ctx->in_buf->pos);
796:
797: if (ctx->zstream.next_in) {
798: ctx->in_buf->pos = ctx->zstream.next_in;
799:
800: if (ctx->zstream.avail_in == 0) {
801: ctx->zstream.next_in = NULL;
802: }
803: }
804:
805: ctx->out_buf->last = ctx->zstream.next_out;
806:
807: if (ctx->zstream.avail_out == 0) {
808:
809: /* zlib wants to output some more gzipped data */
810:
811: cl = ngx_alloc_chain_link(r->pool);
812: if (cl == NULL) {
813: return NGX_ERROR;
814: }
815:
816: cl->buf = ctx->out_buf;
817: cl->next = NULL;
818: *ctx->last_out = cl;
819: ctx->last_out = &cl->next;
820:
821: ctx->redo = 1;
822:
823: return NGX_AGAIN;
824: }
825:
826: ctx->redo = 0;
827:
828: if (ctx->flush == Z_SYNC_FLUSH) {
829:
830: ctx->flush = Z_NO_FLUSH;
831:
832: cl = ngx_alloc_chain_link(r->pool);
833: if (cl == NULL) {
834: return NGX_ERROR;
835: }
836:
837: b = ctx->out_buf;
838:
839: if (ngx_buf_size(b) == 0) {
840:
841: b = ngx_calloc_buf(ctx->request->pool);
842: if (b == NULL) {
843: return NGX_ERROR;
844: }
845:
846: } else {
847: ctx->zstream.avail_out = 0;
848: }
849:
850: b->flush = 1;
851:
852: cl->buf = b;
853: cl->next = NULL;
854: *ctx->last_out = cl;
855: ctx->last_out = &cl->next;
856:
857: return NGX_OK;
858: }
859:
860: if (rc == Z_STREAM_END) {
861:
862: if (ngx_http_gzip_filter_deflate_end(r, ctx) != NGX_OK) {
863: return NGX_ERROR;
864: }
865:
866: return NGX_OK;
867: }
868:
869: conf = ngx_http_get_module_loc_conf(r, ngx_http_gzip_filter_module);
870:
871: if (conf->no_buffer && ctx->in == NULL) {
872:
873: cl = ngx_alloc_chain_link(r->pool);
874: if (cl == NULL) {
875: return NGX_ERROR;
876: }
877:
878: cl->buf = ctx->out_buf;
879: cl->next = NULL;
880: *ctx->last_out = cl;
881: ctx->last_out = &cl->next;
882:
883: return NGX_OK;
884: }
885:
886: return NGX_AGAIN;
887: }
888:
889:
890: static ngx_int_t
891: ngx_http_gzip_filter_deflate_end(ngx_http_request_t *r,
892: ngx_http_gzip_ctx_t *ctx)
893: {
894: int rc;
895: ngx_buf_t *b;
896: ngx_chain_t *cl;
897: struct gztrailer *trailer;
898:
899: ctx->zin = ctx->zstream.total_in;
900: ctx->zout = 10 + ctx->zstream.total_out + 8;
901:
902: rc = deflateEnd(&ctx->zstream);
903:
904: if (rc != Z_OK) {
905: ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
906: "deflateEnd() failed: %d", rc);
907: return NGX_ERROR;
908: }
909:
910: ngx_pfree(r->pool, ctx->preallocated);
911:
912: cl = ngx_alloc_chain_link(r->pool);
913: if (cl == NULL) {
914: return NGX_ERROR;
915: }
916:
917: cl->buf = ctx->out_buf;
918: cl->next = NULL;
919: *ctx->last_out = cl;
920: ctx->last_out = &cl->next;
921:
922: if (ctx->zstream.avail_out >= 8) {
923: trailer = (struct gztrailer *) ctx->out_buf->last;
924: ctx->out_buf->last += 8;
925: ctx->out_buf->last_buf = 1;
926:
927: } else {
928: b = ngx_create_temp_buf(r->pool, 8);
929: if (b == NULL) {
930: return NGX_ERROR;
931: }
932:
933: b->last_buf = 1;
934:
935: cl = ngx_alloc_chain_link(r->pool);
936: if (cl == NULL) {
937: return NGX_ERROR;
938: }
939:
940: cl->buf = b;
941: cl->next = NULL;
942: *ctx->last_out = cl;
943: ctx->last_out = &cl->next;
944: trailer = (struct gztrailer *) b->pos;
945: b->last += 8;
946: }
947:
948: #if (NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED)
949:
950: trailer->crc32 = ctx->crc32;
951: trailer->zlen = ctx->zin;
952:
953: #else
954:
955: trailer->crc32[0] = (u_char) (ctx->crc32 & 0xff);
956: trailer->crc32[1] = (u_char) ((ctx->crc32 >> 8) & 0xff);
957: trailer->crc32[2] = (u_char) ((ctx->crc32 >> 16) & 0xff);
958: trailer->crc32[3] = (u_char) ((ctx->crc32 >> 24) & 0xff);
959:
960: trailer->zlen[0] = (u_char) (ctx->zin & 0xff);
961: trailer->zlen[1] = (u_char) ((ctx->zin >> 8) & 0xff);
962: trailer->zlen[2] = (u_char) ((ctx->zin >> 16) & 0xff);
963: trailer->zlen[3] = (u_char) ((ctx->zin >> 24) & 0xff);
964:
965: #endif
966:
967: ctx->zstream.avail_in = 0;
968: ctx->zstream.avail_out = 0;
969:
970: ctx->done = 1;
971:
972: r->connection->buffered &= ~NGX_HTTP_GZIP_BUFFERED;
973:
974: return NGX_OK;
975: }
976:
977:
978: static void *
979: ngx_http_gzip_filter_alloc(void *opaque, u_int items, u_int size)
980: {
981: ngx_http_gzip_ctx_t *ctx = opaque;
982:
983: void *p;
984: ngx_uint_t alloc;
985:
986: alloc = items * size;
987:
988: if (alloc % 512 != 0 && alloc < 8192) {
989:
990: /*
991: * The zlib deflate_state allocation, it takes about 6K,
992: * we allocate 8K. Other allocations are divisible by 512.
993: */
994:
995: alloc = 8192;
996: }
997:
998: if (alloc <= ctx->allocated) {
999: p = ctx->free_mem;
1000: ctx->free_mem += alloc;
1001: ctx->allocated -= alloc;
1002:
1003: ngx_log_debug4(NGX_LOG_DEBUG_HTTP, ctx->request->connection->log, 0,
1004: "gzip alloc: n:%ud s:%ud a:%ud p:%p",
1005: items, size, alloc, p);
1006:
1007: return p;
1008: }
1009:
1010: ngx_log_error(NGX_LOG_ALERT, ctx->request->connection->log, 0,
1011: "gzip filter failed to use preallocated memory: %ud of %ud",
1012: items * size, ctx->allocated);
1013:
1014: p = ngx_palloc(ctx->request->pool, items * size);
1015:
1016: return p;
1017: }
1018:
1019:
1020: static void
1021: ngx_http_gzip_filter_free(void *opaque, void *address)
1022: {
1023: #if 0
1024: ngx_http_gzip_ctx_t *ctx = opaque;
1025:
1026: ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->request->connection->log, 0,
1027: "gzip free: %p", address);
1028: #endif
1029: }
1030:
1031:
1032: static void
1033: ngx_http_gzip_filter_free_copy_buf(ngx_http_request_t *r,
1034: ngx_http_gzip_ctx_t *ctx)
1035: {
1036: ngx_chain_t *cl;
1037:
1038: for (cl = ctx->copied; cl; cl = cl->next) {
1039: ngx_pfree(r->pool, cl->buf->start);
1040: }
1041:
1042: ctx->copied = NULL;
1043: }
1044:
1045:
1046: static ngx_int_t
1047: ngx_http_gzip_add_variables(ngx_conf_t *cf)
1048: {
1049: ngx_http_variable_t *var;
1050:
1051: var = ngx_http_add_variable(cf, &ngx_http_gzip_ratio, NGX_HTTP_VAR_NOHASH);
1052: if (var == NULL) {
1053: return NGX_ERROR;
1054: }
1055:
1056: var->get_handler = ngx_http_gzip_ratio_variable;
1057:
1058: return NGX_OK;
1059: }
1060:
1061:
1062: static ngx_int_t
1063: ngx_http_gzip_ratio_variable(ngx_http_request_t *r,
1064: ngx_http_variable_value_t *v, uintptr_t data)
1065: {
1066: ngx_uint_t zint, zfrac;
1067: ngx_http_gzip_ctx_t *ctx;
1068:
1069: v->valid = 1;
1070: v->no_cacheable = 0;
1071: v->not_found = 0;
1072:
1073: ctx = ngx_http_get_module_ctx(r, ngx_http_gzip_filter_module);
1074:
1075: if (ctx == NULL || ctx->zout == 0) {
1076: v->not_found = 1;
1077: return NGX_OK;
1078: }
1079:
1080: v->data = ngx_pnalloc(r->pool, NGX_INT32_LEN + 3);
1081: if (v->data == NULL) {
1082: return NGX_ERROR;
1083: }
1084:
1085: zint = (ngx_uint_t) (ctx->zin / ctx->zout);
1086: zfrac = (ngx_uint_t) ((ctx->zin * 100 / ctx->zout) % 100);
1087:
1088: if ((ctx->zin * 1000 / ctx->zout) % 10 > 4) {
1089:
1090: /* the rounding, e.g., 2.125 to 2.13 */
1091:
1092: zfrac++;
1093:
1094: if (zfrac > 99) {
1095: zint++;
1096: zfrac = 0;
1097: }
1098: }
1099:
1100: v->len = ngx_sprintf(v->data, "%ui.%02ui", zint, zfrac) - v->data;
1101:
1102: return NGX_OK;
1103: }
1104:
1105:
1106: static void *
1107: ngx_http_gzip_create_conf(ngx_conf_t *cf)
1108: {
1109: ngx_http_gzip_conf_t *conf;
1110:
1111: conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_gzip_conf_t));
1112: if (conf == NULL) {
1113: return NULL;
1114: }
1115:
1116: /*
1117: * set by ngx_pcalloc():
1118: *
1119: * conf->bufs.num = 0;
1120: * conf->types = { NULL };
1121: * conf->types_keys = NULL;
1122: */
1123:
1124: conf->enable = NGX_CONF_UNSET;
1125: conf->no_buffer = NGX_CONF_UNSET;
1126:
1127: conf->postpone_gzipping = NGX_CONF_UNSET_SIZE;
1128: conf->level = NGX_CONF_UNSET;
1129: conf->wbits = NGX_CONF_UNSET_SIZE;
1130: conf->memlevel = NGX_CONF_UNSET_SIZE;
1131: conf->min_length = NGX_CONF_UNSET;
1132:
1133: return conf;
1134: }
1135:
1136:
1137: static char *
1138: ngx_http_gzip_merge_conf(ngx_conf_t *cf, void *parent, void *child)
1139: {
1140: ngx_http_gzip_conf_t *prev = parent;
1141: ngx_http_gzip_conf_t *conf = child;
1142:
1143: ngx_conf_merge_value(conf->enable, prev->enable, 0);
1144: ngx_conf_merge_value(conf->no_buffer, prev->no_buffer, 0);
1145:
1146: ngx_conf_merge_bufs_value(conf->bufs, prev->bufs,
1147: (128 * 1024) / ngx_pagesize, ngx_pagesize);
1148:
1149: ngx_conf_merge_size_value(conf->postpone_gzipping, prev->postpone_gzipping,
1150: 0);
1151: ngx_conf_merge_value(conf->level, prev->level, 1);
1152: ngx_conf_merge_size_value(conf->wbits, prev->wbits, MAX_WBITS);
1153: ngx_conf_merge_size_value(conf->memlevel, prev->memlevel,
1154: MAX_MEM_LEVEL - 1);
1155: ngx_conf_merge_value(conf->min_length, prev->min_length, 20);
1156:
1157: if (ngx_http_merge_types(cf, &conf->types_keys, &conf->types,
1158: &prev->types_keys, &prev->types,
1159: ngx_http_html_default_types)
1160: != NGX_OK)
1161: {
1162: return NGX_CONF_ERROR;
1163: }
1164:
1165: return NGX_CONF_OK;
1166: }
1167:
1168:
1169: static ngx_int_t
1170: ngx_http_gzip_filter_init(ngx_conf_t *cf)
1171: {
1172: ngx_http_next_header_filter = ngx_http_top_header_filter;
1173: ngx_http_top_header_filter = ngx_http_gzip_header_filter;
1174:
1175: ngx_http_next_body_filter = ngx_http_top_body_filter;
1176: ngx_http_top_body_filter = ngx_http_gzip_body_filter;
1177:
1178: return NGX_OK;
1179: }
1180:
1181:
1182: static char *
1183: ngx_http_gzip_window(ngx_conf_t *cf, void *post, void *data)
1184: {
1185: size_t *np = data;
1186:
1187: size_t wbits, wsize;
1188:
1189: wbits = 15;
1190:
1191: for (wsize = 32 * 1024; wsize > 256; wsize >>= 1) {
1192:
1193: if (wsize == *np) {
1194: *np = wbits;
1195:
1196: return NGX_CONF_OK;
1197: }
1198:
1199: wbits--;
1200: }
1201:
1202: return "must be 512, 1k, 2k, 4k, 8k, 16k, or 32k";
1203: }
1204:
1205:
1206: static char *
1207: ngx_http_gzip_hash(ngx_conf_t *cf, void *post, void *data)
1208: {
1209: size_t *np = data;
1210:
1211: size_t memlevel, hsize;
1212:
1213: memlevel = 9;
1214:
1215: for (hsize = 128 * 1024; hsize > 256; hsize >>= 1) {
1216:
1217: if (hsize == *np) {
1218: *np = memlevel;
1219:
1220: return NGX_CONF_OK;
1221: }
1222:
1223: memlevel--;
1224: }
1225:
1226: return "must be 512, 1k, 2k, 4k, 8k, 16k, 32k, 64k, or 128k";
1227: }