|
686
|
1
|
|
|
2 /*
|
|
|
3 * Copyright (C) Igor Sysoev
|
|
|
4 * Copyright (C) Maxim Dounin
|
|
|
5 * Copyright (C) Nginx, Inc.
|
|
|
6 */
|
|
|
7
|
|
|
8
|
|
|
9 #include <ngx_config.h>
|
|
|
10 #include <ngx_core.h>
|
|
|
11 #include <ngx_http.h>
|
|
|
12
|
|
|
13 #include <zlib.h>
|
|
|
14
|
|
|
15
|
|
|
16 typedef struct {
|
|
|
17 ngx_flag_t enable;
|
|
|
18 ngx_bufs_t bufs;
|
|
|
19 } ngx_http_gunzip_conf_t;
|
|
|
20
|
|
|
21
|
|
|
22 typedef struct {
|
|
|
23 ngx_chain_t *in;
|
|
|
24 ngx_chain_t *free;
|
|
|
25 ngx_chain_t *busy;
|
|
|
26 ngx_chain_t *out;
|
|
|
27 ngx_chain_t **last_out;
|
|
|
28
|
|
|
29 ngx_buf_t *in_buf;
|
|
|
30 ngx_buf_t *out_buf;
|
|
|
31 ngx_int_t bufs;
|
|
|
32
|
|
|
33 unsigned started:1;
|
|
|
34 unsigned flush:4;
|
|
|
35 unsigned redo:1;
|
|
|
36 unsigned done:1;
|
|
|
37 unsigned nomem:1;
|
|
|
38
|
|
|
39 z_stream zstream;
|
|
|
40 ngx_http_request_t *request;
|
|
|
41 } ngx_http_gunzip_ctx_t;
|
|
|
42
|
|
|
43
|
|
|
44 static ngx_int_t ngx_http_gunzip_filter_inflate_start(ngx_http_request_t *r,
|
|
|
45 ngx_http_gunzip_ctx_t *ctx);
|
|
|
46 static ngx_int_t ngx_http_gunzip_filter_add_data(ngx_http_request_t *r,
|
|
|
47 ngx_http_gunzip_ctx_t *ctx);
|
|
|
48 static ngx_int_t ngx_http_gunzip_filter_get_buf(ngx_http_request_t *r,
|
|
|
49 ngx_http_gunzip_ctx_t *ctx);
|
|
|
50 static ngx_int_t ngx_http_gunzip_filter_inflate(ngx_http_request_t *r,
|
|
|
51 ngx_http_gunzip_ctx_t *ctx);
|
|
|
52 static ngx_int_t ngx_http_gunzip_filter_inflate_end(ngx_http_request_t *r,
|
|
|
53 ngx_http_gunzip_ctx_t *ctx);
|
|
|
54
|
|
|
55 static void *ngx_http_gunzip_filter_alloc(void *opaque, u_int items,
|
|
|
56 u_int size);
|
|
|
57 static void ngx_http_gunzip_filter_free(void *opaque, void *address);
|
|
|
58
|
|
|
59 static ngx_int_t ngx_http_gunzip_filter_init(ngx_conf_t *cf);
|
|
|
60 static void *ngx_http_gunzip_create_conf(ngx_conf_t *cf);
|
|
|
61 static char *ngx_http_gunzip_merge_conf(ngx_conf_t *cf,
|
|
|
62 void *parent, void *child);
|
|
|
63
|
|
|
64
|
|
|
65 static ngx_command_t ngx_http_gunzip_filter_commands[] = {
|
|
|
66
|
|
|
67 { ngx_string("gunzip"),
|
|
|
68 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
|
|
|
69 ngx_conf_set_flag_slot,
|
|
|
70 NGX_HTTP_LOC_CONF_OFFSET,
|
|
|
71 offsetof(ngx_http_gunzip_conf_t, enable),
|
|
|
72 NULL },
|
|
|
73
|
|
|
74 { ngx_string("gunzip_buffers"),
|
|
|
75 NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
|
|
|
76 ngx_conf_set_bufs_slot,
|
|
|
77 NGX_HTTP_LOC_CONF_OFFSET,
|
|
|
78 offsetof(ngx_http_gunzip_conf_t, bufs),
|
|
|
79 NULL },
|
|
|
80
|
|
|
81 ngx_null_command
|
|
|
82 };
|
|
|
83
|
|
|
84
|
|
|
85 static ngx_http_module_t ngx_http_gunzip_filter_module_ctx = {
|
|
|
86 NULL, /* preconfiguration */
|
|
|
87 ngx_http_gunzip_filter_init, /* postconfiguration */
|
|
|
88
|
|
|
89 NULL, /* create main configuration */
|
|
|
90 NULL, /* init main configuration */
|
|
|
91
|
|
|
92 NULL, /* create server configuration */
|
|
|
93 NULL, /* merge server configuration */
|
|
|
94
|
|
|
95 ngx_http_gunzip_create_conf, /* create location configuration */
|
|
|
96 ngx_http_gunzip_merge_conf /* merge location configuration */
|
|
|
97 };
|
|
|
98
|
|
|
99
|
|
|
100 ngx_module_t ngx_http_gunzip_filter_module = {
|
|
|
101 NGX_MODULE_V1,
|
|
|
102 &ngx_http_gunzip_filter_module_ctx, /* module context */
|
|
|
103 ngx_http_gunzip_filter_commands, /* module directives */
|
|
|
104 NGX_HTTP_MODULE, /* module type */
|
|
|
105 NULL, /* init master */
|
|
|
106 NULL, /* init module */
|
|
|
107 NULL, /* init process */
|
|
|
108 NULL, /* init thread */
|
|
|
109 NULL, /* exit thread */
|
|
|
110 NULL, /* exit process */
|
|
|
111 NULL, /* exit master */
|
|
|
112 NGX_MODULE_V1_PADDING
|
|
|
113 };
|
|
|
114
|
|
|
115
|
|
|
116 static ngx_http_output_header_filter_pt ngx_http_next_header_filter;
|
|
|
117 static ngx_http_output_body_filter_pt ngx_http_next_body_filter;
|
|
|
118
|
|
|
119
|
|
|
120 static ngx_int_t
|
|
|
121 ngx_http_gunzip_header_filter(ngx_http_request_t *r)
|
|
|
122 {
|
|
|
123 ngx_http_gunzip_ctx_t *ctx;
|
|
|
124 ngx_http_gunzip_conf_t *conf;
|
|
|
125
|
|
|
126 conf = ngx_http_get_module_loc_conf(r, ngx_http_gunzip_filter_module);
|
|
|
127
|
|
|
128 /* TODO support multiple content-codings */
|
|
|
129 /* TODO always gunzip - due to configuration or module request */
|
|
|
130 /* TODO ignore content encoding? */
|
|
|
131
|
|
|
132 if (!conf->enable
|
|
|
133 || r->headers_out.content_encoding == NULL
|
|
|
134 || r->headers_out.content_encoding->value.len != 4
|
|
|
135 || ngx_strncasecmp(r->headers_out.content_encoding->value.data,
|
|
|
136 (u_char *) "gzip", 4) != 0)
|
|
|
137 {
|
|
|
138 return ngx_http_next_header_filter(r);
|
|
|
139 }
|
|
|
140
|
|
|
141 r->gzip_vary = 1;
|
|
|
142
|
|
|
143 if (!r->gzip_tested) {
|
|
|
144 if (ngx_http_gzip_ok(r) == NGX_OK) {
|
|
|
145 return ngx_http_next_header_filter(r);
|
|
|
146 }
|
|
|
147
|
|
690
|
148 } else if (r->gzip_ok) {
|
|
686
|
149 return ngx_http_next_header_filter(r);
|
|
|
150 }
|
|
|
151
|
|
|
152 ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_gunzip_ctx_t));
|
|
|
153 if (ctx == NULL) {
|
|
|
154 return NGX_ERROR;
|
|
|
155 }
|
|
|
156
|
|
|
157 ngx_http_set_ctx(r, ctx, ngx_http_gunzip_filter_module);
|
|
|
158
|
|
|
159 ctx->request = r;
|
|
|
160
|
|
|
161 r->filter_need_in_memory = 1;
|
|
|
162
|
|
|
163 r->headers_out.content_encoding->hash = 0;
|
|
|
164 r->headers_out.content_encoding = NULL;
|
|
|
165
|
|
|
166 ngx_http_clear_content_length(r);
|
|
|
167 ngx_http_clear_accept_ranges(r);
|
|
692
|
168 ngx_http_clear_etag(r);
|
|
686
|
169
|
|
|
170 return ngx_http_next_header_filter(r);
|
|
|
171 }
|
|
|
172
|
|
|
173
|
|
|
174 static ngx_int_t
|
|
|
175 ngx_http_gunzip_body_filter(ngx_http_request_t *r, ngx_chain_t *in)
|
|
|
176 {
|
|
|
177 int rc;
|
|
|
178 ngx_chain_t *cl;
|
|
|
179 ngx_http_gunzip_ctx_t *ctx;
|
|
|
180
|
|
|
181 ctx = ngx_http_get_module_ctx(r, ngx_http_gunzip_filter_module);
|
|
|
182
|
|
|
183 if (ctx == NULL || ctx->done) {
|
|
|
184 return ngx_http_next_body_filter(r, in);
|
|
|
185 }
|
|
|
186
|
|
|
187 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
|
|
|
188 "http gunzip filter");
|
|
|
189
|
|
|
190 if (!ctx->started) {
|
|
|
191 if (ngx_http_gunzip_filter_inflate_start(r, ctx) != NGX_OK) {
|
|
|
192 goto failed;
|
|
|
193 }
|
|
|
194 }
|
|
|
195
|
|
|
196 if (in) {
|
|
|
197 if (ngx_chain_add_copy(r->pool, &ctx->in, in) != NGX_OK) {
|
|
|
198 goto failed;
|
|
|
199 }
|
|
|
200 }
|
|
|
201
|
|
|
202 if (ctx->nomem) {
|
|
|
203
|
|
|
204 /* flush busy buffers */
|
|
|
205
|
|
|
206 if (ngx_http_next_body_filter(r, NULL) == NGX_ERROR) {
|
|
|
207 goto failed;
|
|
|
208 }
|
|
|
209
|
|
|
210 cl = NULL;
|
|
|
211
|
|
|
212 ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &cl,
|
|
|
213 (ngx_buf_tag_t) &ngx_http_gunzip_filter_module);
|
|
|
214 ctx->nomem = 0;
|
|
|
215 }
|
|
|
216
|
|
|
217 for ( ;; ) {
|
|
|
218
|
|
|
219 /* cycle while we can write to a client */
|
|
|
220
|
|
|
221 for ( ;; ) {
|
|
|
222
|
|
|
223 /* cycle while there is data to feed zlib and ... */
|
|
|
224
|
|
|
225 rc = ngx_http_gunzip_filter_add_data(r, ctx);
|
|
|
226
|
|
|
227 if (rc == NGX_DECLINED) {
|
|
|
228 break;
|
|
|
229 }
|
|
|
230
|
|
|
231 if (rc == NGX_AGAIN) {
|
|
|
232 continue;
|
|
|
233 }
|
|
|
234
|
|
|
235
|
|
|
236 /* ... there are buffers to write zlib output */
|
|
|
237
|
|
|
238 rc = ngx_http_gunzip_filter_get_buf(r, ctx);
|
|
|
239
|
|
|
240 if (rc == NGX_DECLINED) {
|
|
|
241 break;
|
|
|
242 }
|
|
|
243
|
|
|
244 if (rc == NGX_ERROR) {
|
|
|
245 goto failed;
|
|
|
246 }
|
|
|
247
|
|
|
248 rc = ngx_http_gunzip_filter_inflate(r, ctx);
|
|
|
249
|
|
|
250 if (rc == NGX_OK) {
|
|
|
251 break;
|
|
|
252 }
|
|
|
253
|
|
|
254 if (rc == NGX_ERROR) {
|
|
|
255 goto failed;
|
|
|
256 }
|
|
|
257
|
|
|
258 /* rc == NGX_AGAIN */
|
|
|
259 }
|
|
|
260
|
|
|
261 if (ctx->out == NULL) {
|
|
|
262 return ctx->busy ? NGX_AGAIN : NGX_OK;
|
|
|
263 }
|
|
|
264
|
|
|
265 rc = ngx_http_next_body_filter(r, ctx->out);
|
|
|
266
|
|
|
267 if (rc == NGX_ERROR) {
|
|
|
268 goto failed;
|
|
|
269 }
|
|
|
270
|
|
|
271 ngx_chain_update_chains(r->pool, &ctx->free, &ctx->busy, &ctx->out,
|
|
|
272 (ngx_buf_tag_t) &ngx_http_gunzip_filter_module);
|
|
|
273 ctx->last_out = &ctx->out;
|
|
|
274
|
|
|
275 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
|
|
|
276 "gunzip out: %p", ctx->out);
|
|
|
277
|
|
|
278 ctx->nomem = 0;
|
|
|
279
|
|
|
280 if (ctx->done) {
|
|
|
281 return rc;
|
|
|
282 }
|
|
|
283 }
|
|
|
284
|
|
|
285 /* unreachable */
|
|
|
286
|
|
|
287 failed:
|
|
|
288
|
|
|
289 ctx->done = 1;
|
|
|
290
|
|
|
291 return NGX_ERROR;
|
|
|
292 }
|
|
|
293
|
|
|
294
|
|
|
295 static ngx_int_t
|
|
|
296 ngx_http_gunzip_filter_inflate_start(ngx_http_request_t *r,
|
|
|
297 ngx_http_gunzip_ctx_t *ctx)
|
|
|
298 {
|
|
|
299 int rc;
|
|
|
300
|
|
|
301 ctx->zstream.next_in = Z_NULL;
|
|
|
302 ctx->zstream.avail_in = 0;
|
|
|
303
|
|
|
304 ctx->zstream.zalloc = ngx_http_gunzip_filter_alloc;
|
|
|
305 ctx->zstream.zfree = ngx_http_gunzip_filter_free;
|
|
|
306 ctx->zstream.opaque = ctx;
|
|
|
307
|
|
|
308 /* windowBits +16 to decode gzip, zlib 1.2.0.4+ */
|
|
|
309 rc = inflateInit2(&ctx->zstream, MAX_WBITS + 16);
|
|
|
310
|
|
|
311 if (rc != Z_OK) {
|
|
|
312 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
|
|
|
313 "inflateInit2() failed: %d", rc);
|
|
|
314 return NGX_ERROR;
|
|
|
315 }
|
|
|
316
|
|
|
317 ctx->started = 1;
|
|
|
318
|
|
|
319 ctx->last_out = &ctx->out;
|
|
|
320 ctx->flush = Z_NO_FLUSH;
|
|
|
321
|
|
|
322 return NGX_OK;
|
|
|
323 }
|
|
|
324
|
|
|
325
|
|
|
326 static ngx_int_t
|
|
|
327 ngx_http_gunzip_filter_add_data(ngx_http_request_t *r,
|
|
|
328 ngx_http_gunzip_ctx_t *ctx)
|
|
|
329 {
|
|
|
330 if (ctx->zstream.avail_in || ctx->flush != Z_NO_FLUSH || ctx->redo) {
|
|
|
331 return NGX_OK;
|
|
|
332 }
|
|
|
333
|
|
|
334 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
|
|
|
335 "gunzip in: %p", ctx->in);
|
|
|
336
|
|
|
337 if (ctx->in == NULL) {
|
|
|
338 return NGX_DECLINED;
|
|
|
339 }
|
|
|
340
|
|
|
341 ctx->in_buf = ctx->in->buf;
|
|
|
342 ctx->in = ctx->in->next;
|
|
|
343
|
|
|
344 ctx->zstream.next_in = ctx->in_buf->pos;
|
|
|
345 ctx->zstream.avail_in = ctx->in_buf->last - ctx->in_buf->pos;
|
|
|
346
|
|
|
347 ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
|
|
|
348 "gunzip in_buf:%p ni:%p ai:%ud",
|
|
|
349 ctx->in_buf,
|
|
|
350 ctx->zstream.next_in, ctx->zstream.avail_in);
|
|
|
351
|
|
|
352 if (ctx->in_buf->last_buf || ctx->in_buf->last_in_chain) {
|
|
|
353 ctx->flush = Z_FINISH;
|
|
|
354
|
|
|
355 } else if (ctx->in_buf->flush) {
|
|
|
356 ctx->flush = Z_SYNC_FLUSH;
|
|
|
357
|
|
|
358 } else if (ctx->zstream.avail_in == 0) {
|
|
|
359 /* ctx->flush == Z_NO_FLUSH */
|
|
|
360 return NGX_AGAIN;
|
|
|
361 }
|
|
|
362
|
|
|
363 return NGX_OK;
|
|
|
364 }
|
|
|
365
|
|
|
366
|
|
|
367 static ngx_int_t
|
|
|
368 ngx_http_gunzip_filter_get_buf(ngx_http_request_t *r,
|
|
|
369 ngx_http_gunzip_ctx_t *ctx)
|
|
|
370 {
|
|
|
371 ngx_http_gunzip_conf_t *conf;
|
|
|
372
|
|
|
373 if (ctx->zstream.avail_out) {
|
|
|
374 return NGX_OK;
|
|
|
375 }
|
|
|
376
|
|
|
377 conf = ngx_http_get_module_loc_conf(r, ngx_http_gunzip_filter_module);
|
|
|
378
|
|
|
379 if (ctx->free) {
|
|
|
380 ctx->out_buf = ctx->free->buf;
|
|
|
381 ctx->free = ctx->free->next;
|
|
|
382
|
|
|
383 ctx->out_buf->flush = 0;
|
|
|
384
|
|
|
385 } else if (ctx->bufs < conf->bufs.num) {
|
|
|
386
|
|
|
387 ctx->out_buf = ngx_create_temp_buf(r->pool, conf->bufs.size);
|
|
|
388 if (ctx->out_buf == NULL) {
|
|
|
389 return NGX_ERROR;
|
|
|
390 }
|
|
|
391
|
|
|
392 ctx->out_buf->tag = (ngx_buf_tag_t) &ngx_http_gunzip_filter_module;
|
|
|
393 ctx->out_buf->recycled = 1;
|
|
|
394 ctx->bufs++;
|
|
|
395
|
|
|
396 } else {
|
|
|
397 ctx->nomem = 1;
|
|
|
398 return NGX_DECLINED;
|
|
|
399 }
|
|
|
400
|
|
|
401 ctx->zstream.next_out = ctx->out_buf->pos;
|
|
|
402 ctx->zstream.avail_out = conf->bufs.size;
|
|
|
403
|
|
|
404 return NGX_OK;
|
|
|
405 }
|
|
|
406
|
|
|
407
|
|
|
408 static ngx_int_t
|
|
|
409 ngx_http_gunzip_filter_inflate(ngx_http_request_t *r,
|
|
|
410 ngx_http_gunzip_ctx_t *ctx)
|
|
|
411 {
|
|
|
412 int rc;
|
|
|
413 ngx_buf_t *b;
|
|
|
414 ngx_chain_t *cl;
|
|
|
415
|
|
|
416 ngx_log_debug6(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
|
|
|
417 "inflate in: ni:%p no:%p ai:%ud ao:%ud fl:%d redo:%d",
|
|
|
418 ctx->zstream.next_in, ctx->zstream.next_out,
|
|
|
419 ctx->zstream.avail_in, ctx->zstream.avail_out,
|
|
|
420 ctx->flush, ctx->redo);
|
|
|
421
|
|
|
422 rc = inflate(&ctx->zstream, ctx->flush);
|
|
|
423
|
|
|
424 if (rc != Z_OK && rc != Z_STREAM_END && rc != Z_BUF_ERROR) {
|
|
|
425 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
|
|
|
426 "inflate() failed: %d, %d", ctx->flush, rc);
|
|
|
427 return NGX_ERROR;
|
|
|
428 }
|
|
|
429
|
|
|
430 ngx_log_debug5(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
|
|
|
431 "inflate out: ni:%p no:%p ai:%ud ao:%ud rc:%d",
|
|
|
432 ctx->zstream.next_in, ctx->zstream.next_out,
|
|
|
433 ctx->zstream.avail_in, ctx->zstream.avail_out,
|
|
|
434 rc);
|
|
|
435
|
|
|
436 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
|
|
|
437 "gunzip in_buf:%p pos:%p",
|
|
|
438 ctx->in_buf, ctx->in_buf->pos);
|
|
|
439
|
|
|
440 if (ctx->zstream.next_in) {
|
|
|
441 ctx->in_buf->pos = ctx->zstream.next_in;
|
|
|
442
|
|
|
443 if (ctx->zstream.avail_in == 0) {
|
|
|
444 ctx->zstream.next_in = NULL;
|
|
|
445 }
|
|
|
446 }
|
|
|
447
|
|
|
448 ctx->out_buf->last = ctx->zstream.next_out;
|
|
|
449
|
|
|
450 if (ctx->zstream.avail_out == 0) {
|
|
|
451
|
|
|
452 /* zlib wants to output some more data */
|
|
|
453
|
|
|
454 cl = ngx_alloc_chain_link(r->pool);
|
|
|
455 if (cl == NULL) {
|
|
|
456 return NGX_ERROR;
|
|
|
457 }
|
|
|
458
|
|
|
459 cl->buf = ctx->out_buf;
|
|
|
460 cl->next = NULL;
|
|
|
461 *ctx->last_out = cl;
|
|
|
462 ctx->last_out = &cl->next;
|
|
|
463
|
|
|
464 ctx->redo = 1;
|
|
|
465
|
|
|
466 return NGX_AGAIN;
|
|
|
467 }
|
|
|
468
|
|
|
469 ctx->redo = 0;
|
|
|
470
|
|
|
471 if (ctx->flush == Z_SYNC_FLUSH) {
|
|
|
472
|
|
|
473 ctx->flush = Z_NO_FLUSH;
|
|
|
474
|
|
|
475 cl = ngx_alloc_chain_link(r->pool);
|
|
|
476 if (cl == NULL) {
|
|
|
477 return NGX_ERROR;
|
|
|
478 }
|
|
|
479
|
|
|
480 b = ctx->out_buf;
|
|
|
481
|
|
|
482 if (ngx_buf_size(b) == 0) {
|
|
|
483
|
|
|
484 b = ngx_calloc_buf(ctx->request->pool);
|
|
|
485 if (b == NULL) {
|
|
|
486 return NGX_ERROR;
|
|
|
487 }
|
|
|
488
|
|
|
489 } else {
|
|
|
490 ctx->zstream.avail_out = 0;
|
|
|
491 }
|
|
|
492
|
|
|
493 b->flush = 1;
|
|
|
494
|
|
|
495 cl->buf = b;
|
|
|
496 cl->next = NULL;
|
|
|
497 *ctx->last_out = cl;
|
|
|
498 ctx->last_out = &cl->next;
|
|
|
499
|
|
|
500 return NGX_OK;
|
|
|
501 }
|
|
|
502
|
|
|
503 if (rc == Z_STREAM_END && ctx->flush == Z_FINISH
|
|
|
504 && ctx->zstream.avail_in == 0)
|
|
|
505 {
|
|
|
506
|
|
|
507 if (ngx_http_gunzip_filter_inflate_end(r, ctx) != NGX_OK) {
|
|
|
508 return NGX_ERROR;
|
|
|
509 }
|
|
|
510
|
|
|
511 return NGX_OK;
|
|
|
512 }
|
|
|
513
|
|
|
514 if (rc == Z_STREAM_END && ctx->zstream.avail_in > 0) {
|
|
|
515
|
|
|
516 rc = inflateReset(&ctx->zstream);
|
|
|
517
|
|
|
518 if (rc != Z_OK) {
|
|
|
519 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
|
|
|
520 "inflateReset() failed: %d", rc);
|
|
|
521 return NGX_ERROR;
|
|
|
522 }
|
|
|
523
|
|
|
524 ctx->redo = 1;
|
|
|
525
|
|
|
526 return NGX_AGAIN;
|
|
|
527 }
|
|
|
528
|
|
|
529 if (ctx->in == NULL) {
|
|
|
530
|
|
|
531 b = ctx->out_buf;
|
|
|
532
|
|
|
533 if (ngx_buf_size(b) == 0) {
|
|
|
534 return NGX_OK;
|
|
|
535 }
|
|
|
536
|
|
|
537 cl = ngx_alloc_chain_link(r->pool);
|
|
|
538 if (cl == NULL) {
|
|
|
539 return NGX_ERROR;
|
|
|
540 }
|
|
|
541
|
|
|
542 ctx->zstream.avail_out = 0;
|
|
|
543
|
|
|
544 cl->buf = b;
|
|
|
545 cl->next = NULL;
|
|
|
546 *ctx->last_out = cl;
|
|
|
547 ctx->last_out = &cl->next;
|
|
|
548
|
|
|
549 return NGX_OK;
|
|
|
550 }
|
|
|
551
|
|
|
552 return NGX_AGAIN;
|
|
|
553 }
|
|
|
554
|
|
|
555
|
|
|
556 static ngx_int_t
|
|
|
557 ngx_http_gunzip_filter_inflate_end(ngx_http_request_t *r,
|
|
|
558 ngx_http_gunzip_ctx_t *ctx)
|
|
|
559 {
|
|
|
560 int rc;
|
|
|
561 ngx_buf_t *b;
|
|
|
562 ngx_chain_t *cl;
|
|
|
563
|
|
|
564 ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
|
|
|
565 "gunzip inflate end");
|
|
|
566
|
|
|
567 rc = inflateEnd(&ctx->zstream);
|
|
|
568
|
|
|
569 if (rc != Z_OK) {
|
|
|
570 ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
|
|
|
571 "inflateEnd() failed: %d", rc);
|
|
|
572 return NGX_ERROR;
|
|
|
573 }
|
|
|
574
|
|
|
575 b = ctx->out_buf;
|
|
|
576
|
|
|
577 if (ngx_buf_size(b) == 0) {
|
|
|
578
|
|
|
579 b = ngx_calloc_buf(ctx->request->pool);
|
|
|
580 if (b == NULL) {
|
|
|
581 return NGX_ERROR;
|
|
|
582 }
|
|
|
583 }
|
|
|
584
|
|
|
585 cl = ngx_alloc_chain_link(r->pool);
|
|
|
586 if (cl == NULL) {
|
|
|
587 return NGX_ERROR;
|
|
|
588 }
|
|
|
589
|
|
|
590 cl->buf = b;
|
|
|
591 cl->next = NULL;
|
|
|
592 *ctx->last_out = cl;
|
|
|
593 ctx->last_out = &cl->next;
|
|
|
594
|
|
|
595 b->last_buf = (r == r->main) ? 1 : 0;
|
|
|
596 b->last_in_chain = 1;
|
|
|
597 b->sync = 1;
|
|
|
598
|
|
|
599 ctx->done = 1;
|
|
|
600
|
|
|
601 return NGX_OK;
|
|
|
602 }
|
|
|
603
|
|
|
604
|
|
|
605 static void *
|
|
|
606 ngx_http_gunzip_filter_alloc(void *opaque, u_int items, u_int size)
|
|
|
607 {
|
|
|
608 ngx_http_gunzip_ctx_t *ctx = opaque;
|
|
|
609
|
|
|
610 ngx_log_debug2(NGX_LOG_DEBUG_HTTP, ctx->request->connection->log, 0,
|
|
|
611 "gunzip alloc: n:%ud s:%ud",
|
|
|
612 items, size);
|
|
|
613
|
|
|
614 return ngx_palloc(ctx->request->pool, items * size);
|
|
|
615 }
|
|
|
616
|
|
|
617
|
|
|
618 static void
|
|
|
619 ngx_http_gunzip_filter_free(void *opaque, void *address)
|
|
|
620 {
|
|
|
621 #if 0
|
|
|
622 ngx_http_gunzip_ctx_t *ctx = opaque;
|
|
|
623
|
|
|
624 ngx_log_debug1(NGX_LOG_DEBUG_HTTP, ctx->request->connection->log, 0,
|
|
|
625 "gunzip free: %p", address);
|
|
|
626 #endif
|
|
|
627 }
|
|
|
628
|
|
|
629
|
|
|
630 static void *
|
|
|
631 ngx_http_gunzip_create_conf(ngx_conf_t *cf)
|
|
|
632 {
|
|
|
633 ngx_http_gunzip_conf_t *conf;
|
|
|
634
|
|
|
635 conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_gunzip_conf_t));
|
|
|
636 if (conf == NULL) {
|
|
|
637 return NULL;
|
|
|
638 }
|
|
|
639
|
|
|
640 /*
|
|
|
641 * set by ngx_pcalloc():
|
|
|
642 *
|
|
|
643 * conf->bufs.num = 0;
|
|
|
644 */
|
|
|
645
|
|
|
646 conf->enable = NGX_CONF_UNSET;
|
|
|
647
|
|
|
648 return conf;
|
|
|
649 }
|
|
|
650
|
|
|
651
|
|
|
652 static char *
|
|
|
653 ngx_http_gunzip_merge_conf(ngx_conf_t *cf, void *parent, void *child)
|
|
|
654 {
|
|
|
655 ngx_http_gunzip_conf_t *prev = parent;
|
|
|
656 ngx_http_gunzip_conf_t *conf = child;
|
|
|
657
|
|
|
658 ngx_conf_merge_value(conf->enable, prev->enable, 0);
|
|
|
659
|
|
|
660 ngx_conf_merge_bufs_value(conf->bufs, prev->bufs,
|
|
|
661 (128 * 1024) / ngx_pagesize, ngx_pagesize);
|
|
|
662
|
|
|
663 return NGX_CONF_OK;
|
|
|
664 }
|
|
|
665
|
|
|
666
|
|
|
667 static ngx_int_t
|
|
|
668 ngx_http_gunzip_filter_init(ngx_conf_t *cf)
|
|
|
669 {
|
|
|
670 ngx_http_next_header_filter = ngx_http_top_header_filter;
|
|
|
671 ngx_http_top_header_filter = ngx_http_gunzip_header_filter;
|
|
|
672
|
|
|
673 ngx_http_next_body_filter = ngx_http_top_body_filter;
|
|
|
674 ngx_http_top_body_filter = ngx_http_gunzip_body_filter;
|
|
|
675
|
|
|
676 return NGX_OK;
|
|
|
677 }
|
