1 /*
2 +----------------------------------------------------------------------+
3 | Copyright (c) The PHP Group |
4 +----------------------------------------------------------------------+
5 | This source file is subject to version 3.01 of the PHP license, |
6 | that is bundled with this package in the file LICENSE, and is |
7 | available through the world-wide-web at the following url: |
8 | https://www.php.net/license/3_01.txt |
9 | If you did not receive a copy of the PHP license and are unable to |
10 | obtain it through the world-wide-web, please send a note to |
11 | license@php.net so we can mail you a copy immediately. |
12 +----------------------------------------------------------------------+
13 | Authors: Rasmus Lerdorf <rasmus@lerdorf.on.ca> |
14 | Stefan Röhrich <sr@linux.de> |
15 | Zeev Suraski <zeev@php.net> |
16 | Jade Nicoletti <nicoletti@nns.ch> |
17 | Michael Wallner <mike@php.net> |
18 +----------------------------------------------------------------------+
19 */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include "php.h"
26 #include "SAPI.h"
27 #include "php_ini.h"
28 #include "ext/standard/info.h"
29 #include "php_zlib.h"
30 #include "zlib_arginfo.h"
31
32 /*
33 * zlib include files can define the following preprocessor defines which rename
34 * the corresponding PHP functions to gzopen64, gzseek64 and gztell64 and thereby
35 * breaking some software, most notably PEAR's Archive_Tar, which halts execution
36 * without error message on gzip compressed archives.
37 *
38 * This only seems to happen on 32bit systems with large file support.
39 */
40 #undef gzopen
41 #undef gzseek
42 #undef gztell
43
44 ZEND_DECLARE_MODULE_GLOBALS(zlib)
45
46 /* InflateContext class */
47
48 zend_class_entry *inflate_context_ce;
49 static zend_object_handlers inflate_context_object_handlers;
50
inflate_context_from_obj(zend_object * obj)51 static inline php_zlib_context *inflate_context_from_obj(zend_object *obj) {
52 return (php_zlib_context *)((char *)(obj) - XtOffsetOf(php_zlib_context, std));
53 }
54
55 #define Z_INFLATE_CONTEXT_P(zv) inflate_context_from_obj(Z_OBJ_P(zv))
56
inflate_context_create_object(zend_class_entry * class_type)57 static zend_object *inflate_context_create_object(zend_class_entry *class_type) {
58 php_zlib_context *intern = zend_object_alloc(sizeof(php_zlib_context), class_type);
59
60 zend_object_std_init(&intern->std, class_type);
61 object_properties_init(&intern->std, class_type);
62
63 return &intern->std;
64 }
65
inflate_context_get_constructor(zend_object * object)66 static zend_function *inflate_context_get_constructor(zend_object *object) {
67 zend_throw_error(NULL, "Cannot directly construct InflateContext, use inflate_init() instead");
68 return NULL;
69 }
70
inflate_context_free_obj(zend_object * object)71 static void inflate_context_free_obj(zend_object *object)
72 {
73 php_zlib_context *intern = inflate_context_from_obj(object);
74
75 if (intern->inflateDict) {
76 efree(intern->inflateDict);
77 }
78 inflateEnd(&intern->Z);
79
80 zend_object_std_dtor(&intern->std);
81 }
82 /* }}} */
83
84 /* DeflateContext class */
85
86 zend_class_entry *deflate_context_ce;
87 static zend_object_handlers deflate_context_object_handlers;
88
deflate_context_from_obj(zend_object * obj)89 static inline php_zlib_context *deflate_context_from_obj(zend_object *obj) {
90 return (php_zlib_context *)((char *)(obj) - XtOffsetOf(php_zlib_context, std));
91 }
92
93 #define Z_DEFLATE_CONTEXT_P(zv) deflate_context_from_obj(Z_OBJ_P(zv))
94
deflate_context_create_object(zend_class_entry * class_type)95 static zend_object *deflate_context_create_object(zend_class_entry *class_type) {
96 php_zlib_context *intern = zend_object_alloc(sizeof(php_zlib_context), class_type);
97
98 zend_object_std_init(&intern->std, class_type);
99 object_properties_init(&intern->std, class_type);
100
101 return &intern->std;
102 }
103
deflate_context_get_constructor(zend_object * object)104 static zend_function *deflate_context_get_constructor(zend_object *object) {
105 zend_throw_error(NULL, "Cannot directly construct DeflateContext, use deflate_init() instead");
106 return NULL;
107 }
108
deflate_context_free_obj(zend_object * object)109 static void deflate_context_free_obj(zend_object *object)
110 {
111 php_zlib_context *intern = deflate_context_from_obj(object);
112
113 deflateEnd(&intern->Z);
114
115 zend_object_std_dtor(&intern->std);
116 }
117 /* }}} */
118
119 /* {{{ Memory management wrappers */
120
php_zlib_alloc(voidpf opaque,uInt items,uInt size)121 static voidpf php_zlib_alloc(voidpf opaque, uInt items, uInt size)
122 {
123 return (voidpf)safe_emalloc(items, size, 0);
124 }
125
php_zlib_free(voidpf opaque,voidpf address)126 static void php_zlib_free(voidpf opaque, voidpf address)
127 {
128 efree((void*)address);
129 }
130 /* }}} */
131
132 /* {{{ php_zlib_output_conflict_check() */
php_zlib_output_conflict_check(const char * handler_name,size_t handler_name_len)133 static zend_result php_zlib_output_conflict_check(const char *handler_name, size_t handler_name_len)
134 {
135 if (php_output_get_level() > 0) {
136 if (php_output_handler_conflict(handler_name, handler_name_len, ZEND_STRL(PHP_ZLIB_OUTPUT_HANDLER_NAME))
137 || php_output_handler_conflict(handler_name, handler_name_len, ZEND_STRL("ob_gzhandler"))
138 || php_output_handler_conflict(handler_name, handler_name_len, ZEND_STRL("mb_output_handler"))
139 || php_output_handler_conflict(handler_name, handler_name_len, ZEND_STRL("URL-Rewriter"))) {
140 return FAILURE;
141 }
142 }
143 return SUCCESS;
144 }
145 /* }}} */
146
147 /* {{{ php_zlib_output_encoding() */
php_zlib_output_encoding(void)148 static int php_zlib_output_encoding(void)
149 {
150 zval *enc;
151
152 if (!ZLIBG(compression_coding)) {
153 if ((Z_TYPE(PG(http_globals)[TRACK_VARS_SERVER]) == IS_ARRAY || zend_is_auto_global(ZSTR_KNOWN(ZEND_STR_AUTOGLOBAL_SERVER))) &&
154 (enc = zend_hash_str_find(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "HTTP_ACCEPT_ENCODING", sizeof("HTTP_ACCEPT_ENCODING") - 1))) {
155 convert_to_string(enc);
156 if (strstr(Z_STRVAL_P(enc), "gzip")) {
157 ZLIBG(compression_coding) = PHP_ZLIB_ENCODING_GZIP;
158 } else if (strstr(Z_STRVAL_P(enc), "deflate")) {
159 ZLIBG(compression_coding) = PHP_ZLIB_ENCODING_DEFLATE;
160 }
161 }
162 }
163 return ZLIBG(compression_coding);
164 }
165 /* }}} */
166
167 /* {{{ php_zlib_output_handler_ex() */
php_zlib_output_handler_ex(php_zlib_context * ctx,php_output_context * output_context)168 static zend_result php_zlib_output_handler_ex(php_zlib_context *ctx, php_output_context *output_context)
169 {
170 int flags = Z_SYNC_FLUSH;
171
172 if (output_context->op & PHP_OUTPUT_HANDLER_START) {
173 /* start up */
174 if (Z_OK != deflateInit2(&ctx->Z, ZLIBG(output_compression_level), Z_DEFLATED, ZLIBG(compression_coding), MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY)) {
175 return FAILURE;
176 }
177 }
178
179 if (output_context->op & PHP_OUTPUT_HANDLER_CLEAN) {
180 /* free buffers */
181 deflateEnd(&ctx->Z);
182
183 if (output_context->op & PHP_OUTPUT_HANDLER_FINAL) {
184 /* discard */
185 return SUCCESS;
186 } else {
187 /* restart */
188 if (Z_OK != deflateInit2(&ctx->Z, ZLIBG(output_compression_level), Z_DEFLATED, ZLIBG(compression_coding), MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY)) {
189 return FAILURE;
190 }
191 ctx->buffer.used = 0;
192 }
193 } else {
194 if (output_context->in.used) {
195 /* append input */
196 if (ctx->buffer.free < output_context->in.used) {
197 if (!(ctx->buffer.aptr = erealloc_recoverable(ctx->buffer.data, ctx->buffer.used + ctx->buffer.free + output_context->in.used))) {
198 deflateEnd(&ctx->Z);
199 return FAILURE;
200 }
201 ctx->buffer.data = ctx->buffer.aptr;
202 ctx->buffer.free += output_context->in.used;
203 }
204 memcpy(ctx->buffer.data + ctx->buffer.used, output_context->in.data, output_context->in.used);
205 ctx->buffer.free -= output_context->in.used;
206 ctx->buffer.used += output_context->in.used;
207 }
208 output_context->out.size = PHP_ZLIB_BUFFER_SIZE_GUESS(output_context->in.used);
209 output_context->out.data = emalloc(output_context->out.size);
210 output_context->out.free = 1;
211 output_context->out.used = 0;
212
213 ctx->Z.avail_in = ctx->buffer.used;
214 ctx->Z.next_in = (Bytef *) ctx->buffer.data;
215 ctx->Z.avail_out = output_context->out.size;
216 ctx->Z.next_out = (Bytef *) output_context->out.data;
217
218 if (output_context->op & PHP_OUTPUT_HANDLER_FINAL) {
219 flags = Z_FINISH;
220 } else if (output_context->op & PHP_OUTPUT_HANDLER_FLUSH) {
221 flags = Z_FULL_FLUSH;
222 }
223
224 switch (deflate(&ctx->Z, flags)) {
225 case Z_OK:
226 if (flags == Z_FINISH) {
227 deflateEnd(&ctx->Z);
228 return FAILURE;
229 }
230 ZEND_FALLTHROUGH;
231 case Z_STREAM_END:
232 if (ctx->Z.avail_in) {
233 memmove(ctx->buffer.data, ctx->buffer.data + ctx->buffer.used - ctx->Z.avail_in, ctx->Z.avail_in);
234 }
235 ctx->buffer.free += ctx->buffer.used - ctx->Z.avail_in;
236 ctx->buffer.used = ctx->Z.avail_in;
237 output_context->out.used = output_context->out.size - ctx->Z.avail_out;
238 break;
239 default:
240 deflateEnd(&ctx->Z);
241 return FAILURE;
242 }
243
244 if (output_context->op & PHP_OUTPUT_HANDLER_FINAL) {
245 deflateEnd(&ctx->Z);
246 }
247 }
248
249 return SUCCESS;
250 }
251 /* }}} */
252
253 /* {{{ php_zlib_output_handler() */
php_zlib_output_handler(void ** handler_context,php_output_context * output_context)254 static zend_result php_zlib_output_handler(void **handler_context, php_output_context *output_context)
255 {
256 php_zlib_context *ctx = *(php_zlib_context **) handler_context;
257
258 if (!php_zlib_output_encoding()) {
259 /* "Vary: Accept-Encoding" header sent along uncompressed content breaks caching in MSIE,
260 so let's just send it with successfully compressed content or unless the complete
261 buffer gets discarded, see http://bugs.php.net/40325;
262
263 Test as follows:
264 +Vary: $ HTTP_ACCEPT_ENCODING=gzip ./sapi/cgi/php <<<'<?php ob_start("ob_gzhandler"); echo "foo\n";'
265 +Vary: $ HTTP_ACCEPT_ENCODING= ./sapi/cgi/php <<<'<?php ob_start("ob_gzhandler"); echo "foo\n";'
266 -Vary: $ HTTP_ACCEPT_ENCODING=gzip ./sapi/cgi/php <<<'<?php ob_start("ob_gzhandler"); echo "foo\n"; ob_end_clean();'
267 -Vary: $ HTTP_ACCEPT_ENCODING= ./sapi/cgi/php <<<'<?php ob_start("ob_gzhandler"); echo "foo\n"; ob_end_clean();'
268 */
269 if ((output_context->op & PHP_OUTPUT_HANDLER_START)
270 && (output_context->op != (PHP_OUTPUT_HANDLER_START|PHP_OUTPUT_HANDLER_CLEAN|PHP_OUTPUT_HANDLER_FINAL))
271 ) {
272 sapi_add_header_ex(ZEND_STRL("Vary: Accept-Encoding"), 1, 0);
273 }
274 return FAILURE;
275 }
276
277 if (SUCCESS != php_zlib_output_handler_ex(ctx, output_context)) {
278 return FAILURE;
279 }
280
281 if (!(output_context->op & PHP_OUTPUT_HANDLER_CLEAN) || ((output_context->op & PHP_OUTPUT_HANDLER_START) && !(output_context->op & PHP_OUTPUT_HANDLER_FINAL))) {
282 int flags;
283
284 if (SUCCESS == php_output_handler_hook(PHP_OUTPUT_HANDLER_HOOK_GET_FLAGS, &flags)) {
285 /* only run this once */
286 if (!(flags & PHP_OUTPUT_HANDLER_STARTED)) {
287 if (SG(headers_sent) || !ZLIBG(output_compression)) {
288 deflateEnd(&ctx->Z);
289 return FAILURE;
290 }
291 switch (ZLIBG(compression_coding)) {
292 case PHP_ZLIB_ENCODING_GZIP:
293 sapi_add_header_ex(ZEND_STRL("Content-Encoding: gzip"), 1, 1);
294 break;
295 case PHP_ZLIB_ENCODING_DEFLATE:
296 sapi_add_header_ex(ZEND_STRL("Content-Encoding: deflate"), 1, 1);
297 break;
298 default:
299 deflateEnd(&ctx->Z);
300 return FAILURE;
301 }
302 sapi_add_header_ex(ZEND_STRL("Vary: Accept-Encoding"), 1, 0);
303 php_output_handler_hook(PHP_OUTPUT_HANDLER_HOOK_IMMUTABLE, NULL);
304 }
305 }
306 }
307
308 return SUCCESS;
309 }
310 /* }}} */
311
312 /* {{{ php_zlib_output_handler_context_init() */
php_zlib_output_handler_context_init(void)313 static php_zlib_context *php_zlib_output_handler_context_init(void)
314 {
315 php_zlib_context *ctx = (php_zlib_context *) ecalloc(1, sizeof(php_zlib_context));
316 ctx->Z.zalloc = php_zlib_alloc;
317 ctx->Z.zfree = php_zlib_free;
318 return ctx;
319 }
320 /* }}} */
321
322 /* {{{ php_zlib_output_handler_context_dtor() */
php_zlib_output_handler_context_dtor(void * opaq)323 static void php_zlib_output_handler_context_dtor(void *opaq)
324 {
325 php_zlib_context *ctx = (php_zlib_context *) opaq;
326
327 if (ctx) {
328 if (ctx->buffer.data) {
329 efree(ctx->buffer.data);
330 }
331 efree(ctx);
332 }
333 }
334 /* }}} */
335
336 /* {{{ php_zlib_output_handler_init() */
php_zlib_output_handler_init(const char * handler_name,size_t handler_name_len,size_t chunk_size,int flags)337 static php_output_handler *php_zlib_output_handler_init(const char *handler_name, size_t handler_name_len, size_t chunk_size, int flags)
338 {
339 php_output_handler *h = NULL;
340
341 if (!ZLIBG(output_compression)) {
342 ZLIBG(output_compression) = chunk_size ? chunk_size : PHP_OUTPUT_HANDLER_DEFAULT_SIZE;
343 }
344
345 ZLIBG(handler_registered) = 1;
346
347 if ((h = php_output_handler_create_internal(handler_name, handler_name_len, php_zlib_output_handler, chunk_size, flags))) {
348 php_output_handler_set_context(h, php_zlib_output_handler_context_init(), php_zlib_output_handler_context_dtor);
349 }
350
351 return h;
352 }
353 /* }}} */
354
355 /* {{{ php_zlib_output_compression_start() */
php_zlib_output_compression_start(void)356 static void php_zlib_output_compression_start(void)
357 {
358 zval zoh;
359 php_output_handler *h;
360
361 switch (ZLIBG(output_compression)) {
362 case 0:
363 break;
364 case 1:
365 ZLIBG(output_compression) = PHP_OUTPUT_HANDLER_DEFAULT_SIZE;
366 ZEND_FALLTHROUGH;
367 default:
368 if ( php_zlib_output_encoding() &&
369 (h = php_zlib_output_handler_init(ZEND_STRL(PHP_ZLIB_OUTPUT_HANDLER_NAME), ZLIBG(output_compression), PHP_OUTPUT_HANDLER_STDFLAGS)) &&
370 (SUCCESS == php_output_handler_start(h))) {
371 if (ZLIBG(output_handler) && *ZLIBG(output_handler)) {
372 ZVAL_STRING(&zoh, ZLIBG(output_handler));
373 php_output_start_user(&zoh, ZLIBG(output_compression), PHP_OUTPUT_HANDLER_STDFLAGS);
374 zval_ptr_dtor(&zoh);
375 }
376 }
377 break;
378 }
379 }
380 /* }}} */
381
382 /* {{{ php_zlib_encode() */
php_zlib_encode(const char * in_buf,size_t in_len,int encoding,int level)383 static zend_string *php_zlib_encode(const char *in_buf, size_t in_len, int encoding, int level)
384 {
385 int status;
386 z_stream Z;
387 zend_string *out;
388
389 memset(&Z, 0, sizeof(z_stream));
390 Z.zalloc = php_zlib_alloc;
391 Z.zfree = php_zlib_free;
392
393 if (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, encoding, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) {
394 out = zend_string_alloc(PHP_ZLIB_BUFFER_SIZE_GUESS(in_len), 0);
395
396 Z.next_in = (Bytef *) in_buf;
397 Z.next_out = (Bytef *) ZSTR_VAL(out);
398 Z.avail_in = in_len;
399 Z.avail_out = ZSTR_LEN(out);
400
401 status = deflate(&Z, Z_FINISH);
402 deflateEnd(&Z);
403
404 if (Z_STREAM_END == status) {
405 /* size buffer down to actual length */
406 out = zend_string_truncate(out, Z.total_out, 0);
407 ZSTR_VAL(out)[ZSTR_LEN(out)] = '\0';
408 return out;
409 } else {
410 zend_string_efree(out);
411 }
412 }
413
414 php_error_docref(NULL, E_WARNING, "%s", zError(status));
415 return NULL;
416 }
417 /* }}} */
418
419 /* {{{ php_zlib_inflate_rounds() */
php_zlib_inflate_rounds(z_stream * Z,size_t max,char ** buf,size_t * len)420 static inline int php_zlib_inflate_rounds(z_stream *Z, size_t max, char **buf, size_t *len)
421 {
422 int status, round = 0;
423 php_zlib_buffer buffer = {NULL, NULL, 0, 0, 0};
424
425 *buf = NULL;
426 *len = 0;
427
428 buffer.size = (max && (max < Z->avail_in)) ? max : Z->avail_in;
429
430 do {
431 if ((max && (max <= buffer.used)) || !(buffer.aptr = erealloc_recoverable(buffer.data, buffer.size))) {
432 status = Z_MEM_ERROR;
433 } else {
434 buffer.data = buffer.aptr;
435 Z->avail_out = buffer.free = buffer.size - buffer.used;
436 Z->next_out = (Bytef *) buffer.data + buffer.used;
437 #if 0
438 fprintf(stderr, "\n%3d: %3d PRIOR: size=%7lu,\tfree=%7lu,\tused=%7lu,\tavail_in=%7lu,\tavail_out=%7lu\n", round, status, buffer.size, buffer.free, buffer.used, Z->avail_in, Z->avail_out);
439 #endif
440 status = inflate(Z, Z_NO_FLUSH);
441
442 buffer.used += buffer.free - Z->avail_out;
443 buffer.free = Z->avail_out;
444 #if 0
445 fprintf(stderr, "%3d: %3d AFTER: size=%7lu,\tfree=%7lu,\tused=%7lu,\tavail_in=%7lu,\tavail_out=%7lu\n", round, status, buffer.size, buffer.free, buffer.used, Z->avail_in, Z->avail_out);
446 #endif
447 buffer.size += (buffer.size >> 3) + 1;
448 }
449 } while ((Z_BUF_ERROR == status || (Z_OK == status && Z->avail_in)) && ++round < 100);
450
451 if (status == Z_STREAM_END) {
452 buffer.data = erealloc(buffer.data, buffer.used + 1);
453 buffer.data[buffer.used] = '\0';
454 *buf = buffer.data;
455 *len = buffer.used;
456 } else {
457 if (buffer.data) {
458 efree(buffer.data);
459 }
460 /* HACK: See zlib/examples/zpipe.c inf() function for explanation. */
461 /* This works as long as this function is not used for streaming. Required to catch very short invalid data. */
462 status = (status == Z_OK) ? Z_DATA_ERROR : status;
463 }
464 return status;
465 }
466 /* }}} */
467
468 /* {{{ php_zlib_decode() */
php_zlib_decode(const char * in_buf,size_t in_len,char ** out_buf,size_t * out_len,int encoding,size_t max_len)469 static int php_zlib_decode(const char *in_buf, size_t in_len, char **out_buf, size_t *out_len, int encoding, size_t max_len)
470 {
471 int status = Z_DATA_ERROR;
472 z_stream Z;
473
474 memset(&Z, 0, sizeof(z_stream));
475 Z.zalloc = php_zlib_alloc;
476 Z.zfree = php_zlib_free;
477
478 if (in_len) {
479 retry_raw_inflate:
480 status = inflateInit2(&Z, encoding);
481 if (Z_OK == status) {
482 Z.next_in = (Bytef *) in_buf;
483 Z.avail_in = in_len + 1; /* NOTE: data must be zero terminated */
484
485 switch (status = php_zlib_inflate_rounds(&Z, max_len, out_buf, out_len)) {
486 case Z_STREAM_END:
487 inflateEnd(&Z);
488 return SUCCESS;
489
490 case Z_DATA_ERROR:
491 /* raw deflated data? */
492 if (PHP_ZLIB_ENCODING_ANY == encoding) {
493 inflateEnd(&Z);
494 encoding = PHP_ZLIB_ENCODING_RAW;
495 goto retry_raw_inflate;
496 }
497 }
498 inflateEnd(&Z);
499 }
500 }
501
502 *out_buf = NULL;
503 *out_len = 0;
504
505 php_error_docref(NULL, E_WARNING, "%s", zError(status));
506 return FAILURE;
507 }
508 /* }}} */
509
510 /* {{{ php_zlib_cleanup_ob_gzhandler_mess() */
php_zlib_cleanup_ob_gzhandler_mess(void)511 static void php_zlib_cleanup_ob_gzhandler_mess(void)
512 {
513 if (ZLIBG(ob_gzhandler)) {
514 deflateEnd(&(ZLIBG(ob_gzhandler)->Z));
515 php_zlib_output_handler_context_dtor(ZLIBG(ob_gzhandler));
516 ZLIBG(ob_gzhandler) = NULL;
517 }
518 }
519 /* }}} */
520
521 /* {{{ Legacy hack */
PHP_FUNCTION(ob_gzhandler)522 PHP_FUNCTION(ob_gzhandler)
523 {
524 char *in_str;
525 size_t in_len;
526 zend_long flags = 0;
527 php_output_context ctx = {0};
528 int encoding;
529
530 /*
531 * NOTE that the real ob_gzhandler is an alias to "zlib output compression".
532 * This is a really bad hack, because
533 * - we have to initialize a php_zlib_context on demand
534 * - we have to clean it up in RSHUTDOWN
535 * - OG(running) is not set or set to any other output handler
536 * - we have to mess around with php_output_context */
537
538 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "sl", &in_str, &in_len, &flags)) {
539 RETURN_THROWS();
540 }
541
542 if (!(encoding = php_zlib_output_encoding())) {
543 RETURN_FALSE;
544 }
545
546 if (flags & PHP_OUTPUT_HANDLER_START) {
547 switch (encoding) {
548 case PHP_ZLIB_ENCODING_GZIP:
549 sapi_add_header_ex(ZEND_STRL("Content-Encoding: gzip"), 1, 1);
550 break;
551 case PHP_ZLIB_ENCODING_DEFLATE:
552 sapi_add_header_ex(ZEND_STRL("Content-Encoding: deflate"), 1, 1);
553 break;
554 }
555 sapi_add_header_ex(ZEND_STRL("Vary: Accept-Encoding"), 1, 0);
556 }
557
558 if (!ZLIBG(ob_gzhandler)) {
559 ZLIBG(ob_gzhandler) = php_zlib_output_handler_context_init();
560 }
561
562 ctx.op = flags;
563 ctx.in.data = in_str;
564 ctx.in.used = in_len;
565
566 zend_result rv = php_zlib_output_handler_ex(ZLIBG(ob_gzhandler), &ctx);
567
568 if (SUCCESS != rv) {
569 if (ctx.out.data && ctx.out.free) {
570 efree(ctx.out.data);
571 }
572 php_zlib_cleanup_ob_gzhandler_mess();
573 RETURN_FALSE;
574 }
575
576 if (ctx.out.data) {
577 RETVAL_STRINGL(ctx.out.data, ctx.out.used);
578 if (ctx.out.free) {
579 efree(ctx.out.data);
580 }
581 } else {
582 RETVAL_EMPTY_STRING();
583 }
584 }
585 /* }}} */
586
587 /* {{{ Returns the coding type used for output compression */
PHP_FUNCTION(zlib_get_coding_type)588 PHP_FUNCTION(zlib_get_coding_type)
589 {
590 if (zend_parse_parameters_none() == FAILURE) {
591 RETURN_THROWS();
592 }
593 switch (ZLIBG(compression_coding)) {
594 case PHP_ZLIB_ENCODING_GZIP:
595 RETURN_STRINGL("gzip", sizeof("gzip") - 1);
596 case PHP_ZLIB_ENCODING_DEFLATE:
597 RETURN_STRINGL("deflate", sizeof("deflate") - 1);
598 default:
599 RETURN_FALSE;
600 }
601 }
602 /* }}} */
603
604 /* {{{ Read and uncompress entire .gz-file into an array */
PHP_FUNCTION(gzfile)605 PHP_FUNCTION(gzfile)
606 {
607 char *filename;
608 size_t filename_len;
609 int flags = REPORT_ERRORS;
610 char buf[8192] = {0};
611 int i = 0;
612 zend_long use_include_path = 0;
613 php_stream *stream;
614
615 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "p|l", &filename, &filename_len, &use_include_path)) {
616 RETURN_THROWS();
617 }
618
619 if (use_include_path) {
620 flags |= USE_PATH;
621 }
622
623 /* using a stream here is a bit more efficient (resource wise) than php_gzopen_wrapper */
624 stream = php_stream_gzopen(NULL, filename, "rb", flags, NULL, NULL STREAMS_CC);
625
626 if (!stream) {
627 /* Error reporting is already done by stream code */
628 RETURN_FALSE;
629 }
630
631 /* Initialize return array */
632 array_init(return_value);
633
634 /* Now loop through the file and do the magic quotes thing if needed */
635 memset(buf, 0, sizeof(buf));
636
637 while (php_stream_gets(stream, buf, sizeof(buf) - 1) != NULL) {
638 add_index_string(return_value, i++, buf);
639 }
640 php_stream_close(stream);
641 }
642 /* }}} */
643
644 /* {{{ Open a .gz-file and return a .gz-file pointer */
PHP_FUNCTION(gzopen)645 PHP_FUNCTION(gzopen)
646 {
647 char *filename;
648 char *mode;
649 size_t filename_len, mode_len;
650 int flags = REPORT_ERRORS;
651 php_stream *stream;
652 zend_long use_include_path = 0;
653
654 if (zend_parse_parameters(ZEND_NUM_ARGS(), "ps|l", &filename, &filename_len, &mode, &mode_len, &use_include_path) == FAILURE) {
655 RETURN_THROWS();
656 }
657
658 if (use_include_path) {
659 flags |= USE_PATH;
660 }
661
662 stream = php_stream_gzopen(NULL, filename, mode, flags, NULL, NULL STREAMS_CC);
663
664 if (!stream) {
665 RETURN_FALSE;
666 }
667 php_stream_to_zval(stream, return_value);
668 }
669 /* }}} */
670
671 /* {{{ Output a .gz-file */
PHP_FUNCTION(readgzfile)672 PHP_FUNCTION(readgzfile)
673 {
674 char *filename;
675 size_t filename_len;
676 int flags = REPORT_ERRORS;
677 php_stream *stream;
678 size_t size;
679 zend_long use_include_path = 0;
680
681 if (zend_parse_parameters(ZEND_NUM_ARGS(), "p|l", &filename, &filename_len, &use_include_path) == FAILURE) {
682 RETURN_THROWS();
683 }
684
685 if (use_include_path) {
686 flags |= USE_PATH;
687 }
688
689 stream = php_stream_gzopen(NULL, filename, "rb", flags, NULL, NULL STREAMS_CC);
690
691 if (!stream) {
692 RETURN_FALSE;
693 }
694 size = php_stream_passthru(stream);
695 php_stream_close(stream);
696 RETURN_LONG(size);
697 }
698 /* }}} */
699
700 #define PHP_ZLIB_ENCODE_FUNC(name, default_encoding) \
701 PHP_FUNCTION(name) \
702 { \
703 zend_string *in, *out; \
704 zend_long level = -1; \
705 zend_long encoding = default_encoding; \
706 if (default_encoding) { \
707 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "S|ll", &in, &level, &encoding)) { \
708 RETURN_THROWS(); \
709 } \
710 } else { \
711 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Sl|l", &in, &encoding, &level)) { \
712 RETURN_THROWS(); \
713 } \
714 } \
715 if (level < -1 || level > 9) { \
716 zend_argument_value_error(default_encoding ? 2 : 3, "must be between -1 and 9"); \
717 RETURN_THROWS(); \
718 } \
719 switch (encoding) { \
720 case PHP_ZLIB_ENCODING_RAW: \
721 case PHP_ZLIB_ENCODING_GZIP: \
722 case PHP_ZLIB_ENCODING_DEFLATE: \
723 break; \
724 default: \
725 zend_argument_value_error(default_encoding ? 3 : 2, "must be one of ZLIB_ENCODING_RAW, ZLIB_ENCODING_GZIP, or ZLIB_ENCODING_DEFLATE"); \
726 RETURN_THROWS(); \
727 } \
728 if ((out = php_zlib_encode(ZSTR_VAL(in), ZSTR_LEN(in), encoding, level)) == NULL) { \
729 RETURN_FALSE; \
730 } \
731 RETURN_STR(out); \
732 }
733
734 #define PHP_ZLIB_DECODE_FUNC(name, encoding) \
735 PHP_FUNCTION(name) \
736 { \
737 char *in_buf, *out_buf; \
738 size_t in_len; \
739 size_t out_len; \
740 zend_long max_len = 0; \
741 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &in_buf, &in_len, &max_len)) { \
742 RETURN_THROWS(); \
743 } \
744 if (max_len < 0) { \
745 zend_argument_value_error(2, "must be greater than or equal to 0"); \
746 RETURN_THROWS(); \
747 } \
748 if (SUCCESS != php_zlib_decode(in_buf, in_len, &out_buf, &out_len, encoding, max_len)) { \
749 RETURN_FALSE; \
750 } \
751 RETVAL_STRINGL(out_buf, out_len); \
752 efree(out_buf); \
753 }
754
755 /* {{{ Compress data with the specified encoding */
756 PHP_ZLIB_ENCODE_FUNC(zlib_encode, 0);
757 /* }}} */
758
759 /* {{{ Uncompress any raw/gzip/zlib encoded data */
760 PHP_ZLIB_DECODE_FUNC(zlib_decode, PHP_ZLIB_ENCODING_ANY);
761 /* }}} */
762
763 /* NOTE: The naming of these userland functions was quite unlucky */
764 /* {{{ Encode data with the raw deflate encoding */
765 PHP_ZLIB_ENCODE_FUNC(gzdeflate, PHP_ZLIB_ENCODING_RAW);
766 /* }}} */
767
768 /* {{{ Encode data with the gzip encoding */
769 PHP_ZLIB_ENCODE_FUNC(gzencode, PHP_ZLIB_ENCODING_GZIP);
770 /* }}} */
771
772 /* {{{ Encode data with the zlib encoding */
773 PHP_ZLIB_ENCODE_FUNC(gzcompress, PHP_ZLIB_ENCODING_DEFLATE);
774 /* }}} */
775
776 /* {{{ Decode raw deflate encoded data */
777 PHP_ZLIB_DECODE_FUNC(gzinflate, PHP_ZLIB_ENCODING_RAW);
778 /* }}} */
779
780 /* {{{ Decode gzip encoded data */
781 PHP_ZLIB_DECODE_FUNC(gzdecode, PHP_ZLIB_ENCODING_GZIP);
782 /* }}} */
783
784 /* {{{ Decode zlib encoded data */
785 PHP_ZLIB_DECODE_FUNC(gzuncompress, PHP_ZLIB_ENCODING_DEFLATE);
786 /* }}} */
787
zlib_create_dictionary_string(HashTable * options,char ** dict,size_t * dictlen)788 static bool zlib_create_dictionary_string(HashTable *options, char **dict, size_t *dictlen) {
789 zval *option_buffer;
790
791 if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("dictionary"))) != NULL) {
792 ZVAL_DEREF(option_buffer);
793 switch (Z_TYPE_P(option_buffer)) {
794 case IS_STRING: {
795 zend_string *str = Z_STR_P(option_buffer);
796 *dict = emalloc(ZSTR_LEN(str));
797 memcpy(*dict, ZSTR_VAL(str), ZSTR_LEN(str));
798 *dictlen = ZSTR_LEN(str);
799 } break;
800
801 case IS_ARRAY: {
802 HashTable *dictionary = Z_ARR_P(option_buffer);
803
804 if (zend_hash_num_elements(dictionary) > 0) {
805 char *dictptr;
806 zval *cur;
807 zend_string **strings = emalloc(sizeof(zend_string *) * zend_hash_num_elements(dictionary));
808 zend_string **end, **ptr = strings - 1;
809
810 ZEND_HASH_FOREACH_VAL(dictionary, cur) {
811 size_t i;
812
813 *++ptr = zval_get_string(cur);
814 if (!*ptr || ZSTR_LEN(*ptr) == 0 || EG(exception)) {
815 if (*ptr) {
816 efree(*ptr);
817 }
818 while (--ptr >= strings) {
819 efree(ptr);
820 }
821 efree(strings);
822 if (!EG(exception)) {
823 zend_argument_value_error(2, "must not contain empty strings");
824 }
825 return 0;
826 }
827 for (i = 0; i < ZSTR_LEN(*ptr); i++) {
828 if (ZSTR_VAL(*ptr)[i] == 0) {
829 do {
830 efree(ptr);
831 } while (--ptr >= strings);
832 efree(strings);
833 zend_argument_value_error(2, "must not contain strings with null bytes");
834 return 0;
835 }
836 }
837
838 *dictlen += ZSTR_LEN(*ptr) + 1;
839 } ZEND_HASH_FOREACH_END();
840
841 dictptr = *dict = emalloc(*dictlen);
842 ptr = strings;
843 end = strings + zend_hash_num_elements(dictionary);
844 do {
845 memcpy(dictptr, ZSTR_VAL(*ptr), ZSTR_LEN(*ptr));
846 dictptr += ZSTR_LEN(*ptr);
847 *dictptr++ = 0;
848 zend_string_release_ex(*ptr, 0);
849 } while (++ptr != end);
850 efree(strings);
851 }
852 } break;
853
854 default:
855 zend_argument_type_error(2, "must be of type zero-terminated string or array, %s given", zend_zval_value_name(option_buffer));
856 return 0;
857 }
858 }
859
860 return 1;
861 }
862
863 /* {{{ Initialize an incremental inflate context with the specified encoding */
PHP_FUNCTION(inflate_init)864 PHP_FUNCTION(inflate_init)
865 {
866 php_zlib_context *ctx;
867 zend_long encoding, window = 15;
868 char *dict = NULL;
869 size_t dictlen = 0;
870 HashTable *options = NULL;
871 zval *option_buffer;
872
873 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "l|H", &encoding, &options)) {
874 RETURN_THROWS();
875 }
876
877 if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("window"))) != NULL) {
878 window = zval_get_long(option_buffer);
879 }
880 if (window < 8 || window > 15) {
881 zend_value_error("zlib window size (logarithm) (" ZEND_LONG_FMT ") must be within 8..15", window);
882 RETURN_THROWS();
883 }
884
885 if (!zlib_create_dictionary_string(options, &dict, &dictlen)) {
886 RETURN_THROWS();
887 }
888
889 switch (encoding) {
890 case PHP_ZLIB_ENCODING_RAW:
891 case PHP_ZLIB_ENCODING_GZIP:
892 case PHP_ZLIB_ENCODING_DEFLATE:
893 break;
894 default:
895 zend_value_error("Encoding mode must be ZLIB_ENCODING_RAW, ZLIB_ENCODING_GZIP or ZLIB_ENCODING_DEFLATE");
896 RETURN_THROWS();
897 }
898
899 object_init_ex(return_value, inflate_context_ce);
900 ctx = Z_INFLATE_CONTEXT_P(return_value);
901
902 ctx->Z.zalloc = php_zlib_alloc;
903 ctx->Z.zfree = php_zlib_free;
904 ctx->inflateDict = dict;
905 ctx->inflateDictlen = dictlen;
906 ctx->status = Z_OK;
907
908 if (encoding < 0) {
909 encoding += 15 - window;
910 } else {
911 encoding -= 15 - window;
912 }
913
914 if (inflateInit2(&ctx->Z, encoding) != Z_OK) {
915 zval_ptr_dtor(return_value);
916 php_error_docref(NULL, E_WARNING, "Failed allocating zlib.inflate context");
917 RETURN_FALSE;
918 }
919
920 if (encoding == PHP_ZLIB_ENCODING_RAW && dictlen > 0) {
921 switch (inflateSetDictionary(&ctx->Z, (Bytef *) ctx->inflateDict, ctx->inflateDictlen)) {
922 case Z_OK:
923 efree(ctx->inflateDict);
924 ctx->inflateDict = NULL;
925 break;
926 case Z_DATA_ERROR:
927 php_error_docref(NULL, E_WARNING, "Dictionary does not match expected dictionary (incorrect adler32 hash)");
928 efree(ctx->inflateDict);
929 ctx->inflateDict = NULL;
930 break;
931 EMPTY_SWITCH_DEFAULT_CASE()
932 }
933 }
934 }
935 /* }}} */
936
937 /* {{{ Incrementally inflate encoded data in the specified context */
PHP_FUNCTION(inflate_add)938 PHP_FUNCTION(inflate_add)
939 {
940 zend_string *out;
941 char *in_buf;
942 size_t in_len, buffer_used = 0, CHUNK_SIZE = 8192;
943 zval *res;
944 php_zlib_context *ctx;
945 zend_long flush_type = Z_SYNC_FLUSH;
946 int status;
947
948 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Os|l", &res, inflate_context_ce, &in_buf, &in_len, &flush_type)) {
949 RETURN_THROWS();
950 }
951
952 ctx = Z_INFLATE_CONTEXT_P(res);
953
954 switch (flush_type) {
955 case Z_NO_FLUSH:
956 case Z_PARTIAL_FLUSH:
957 case Z_SYNC_FLUSH:
958 case Z_FULL_FLUSH:
959 case Z_BLOCK:
960 case Z_FINISH:
961 break;
962
963 default:
964 zend_argument_value_error(3, "must be one of ZLIB_NO_FLUSH, ZLIB_PARTIAL_FLUSH, ZLIB_SYNC_FLUSH, ZLIB_FULL_FLUSH, ZLIB_BLOCK, or ZLIB_FINISH");
965 RETURN_THROWS();
966 }
967
968 /* Lazy-resetting the zlib stream so ctx->total_in remains available until the next inflate_add() call. */
969 if (ctx->status == Z_STREAM_END)
970 {
971 ctx->status = Z_OK;
972 inflateReset(&ctx->Z);
973 }
974
975 if (in_len <= 0 && flush_type != Z_FINISH) {
976 RETURN_EMPTY_STRING();
977 }
978
979 out = zend_string_alloc((in_len > CHUNK_SIZE) ? in_len : CHUNK_SIZE, 0);
980 ctx->Z.next_in = (Bytef *) in_buf;
981 ctx->Z.next_out = (Bytef *) ZSTR_VAL(out);
982 ctx->Z.avail_in = in_len;
983 ctx->Z.avail_out = ZSTR_LEN(out);
984
985 do {
986 status = inflate(&ctx->Z, flush_type);
987 buffer_used = ZSTR_LEN(out) - ctx->Z.avail_out;
988
989 ctx->status = status; /* Save status for exposing to userspace */
990
991 switch (status) {
992 case Z_OK:
993 if (ctx->Z.avail_out == 0) {
994 /* more output buffer space needed; realloc and try again */
995 out = zend_string_realloc(out, ZSTR_LEN(out) + CHUNK_SIZE, 0);
996 ctx->Z.avail_out = CHUNK_SIZE;
997 ctx->Z.next_out = (Bytef *) ZSTR_VAL(out) + buffer_used;
998 break;
999 } else {
1000 goto complete;
1001 }
1002 case Z_STREAM_END:
1003 goto complete;
1004 case Z_BUF_ERROR:
1005 if (flush_type == Z_FINISH && ctx->Z.avail_out == 0) {
1006 /* more output buffer space needed; realloc and try again */
1007 out = zend_string_realloc(out, ZSTR_LEN(out) + CHUNK_SIZE, 0);
1008 ctx->Z.avail_out = CHUNK_SIZE;
1009 ctx->Z.next_out = (Bytef *) ZSTR_VAL(out) + buffer_used;
1010 break;
1011 } else {
1012 /* No more input data; we're finished */
1013 goto complete;
1014 }
1015 case Z_NEED_DICT:
1016 if (ctx->inflateDict) {
1017 switch (inflateSetDictionary(&ctx->Z, (Bytef *) ctx->inflateDict, ctx->inflateDictlen)) {
1018 case Z_OK:
1019 efree(ctx->inflateDict);
1020 ctx->inflateDict = NULL;
1021 break;
1022 case Z_DATA_ERROR:
1023 efree(ctx->inflateDict);
1024 ctx->inflateDict = NULL;
1025 zend_string_release_ex(out, 0);
1026 php_error_docref(NULL, E_WARNING, "Dictionary does not match expected dictionary (incorrect adler32 hash)");
1027 RETURN_FALSE;
1028 EMPTY_SWITCH_DEFAULT_CASE()
1029 }
1030 break;
1031 } else {
1032 php_error_docref(NULL, E_WARNING, "Inflating this data requires a preset dictionary, please specify it in the options array of inflate_init()");
1033 RETURN_FALSE;
1034 }
1035 default:
1036 zend_string_release_ex(out, 0);
1037 php_error_docref(NULL, E_WARNING, "%s", zError(status));
1038 RETURN_FALSE;
1039 }
1040 } while (1);
1041
1042 complete:
1043 out = zend_string_realloc(out, buffer_used, 0);
1044 ZSTR_VAL(out)[buffer_used] = 0;
1045 RETURN_STR(out);
1046 }
1047 /* }}} */
1048
1049 /* {{{ Get decompression status, usually returns either ZLIB_OK or ZLIB_STREAM_END. */
PHP_FUNCTION(inflate_get_status)1050 PHP_FUNCTION(inflate_get_status)
1051 {
1052 zval *res;
1053 php_zlib_context *ctx;
1054
1055 if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &res, inflate_context_ce) != SUCCESS) {
1056 RETURN_THROWS();
1057 }
1058
1059 ctx = Z_INFLATE_CONTEXT_P(res);
1060
1061 RETURN_LONG(ctx->status);
1062 }
1063 /* }}} */
1064
1065 /* {{{ Get number of bytes read so far. */
PHP_FUNCTION(inflate_get_read_len)1066 PHP_FUNCTION(inflate_get_read_len)
1067 {
1068 zval *res;
1069 php_zlib_context *ctx;
1070
1071 if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &res, inflate_context_ce) != SUCCESS) {
1072 RETURN_THROWS();
1073 }
1074
1075 ctx = Z_INFLATE_CONTEXT_P(res);
1076
1077 RETURN_LONG(ctx->Z.total_in);
1078 }
1079 /* }}} */
1080
1081 /* {{{ Initialize an incremental deflate context using the specified encoding */
PHP_FUNCTION(deflate_init)1082 PHP_FUNCTION(deflate_init)
1083 {
1084 php_zlib_context *ctx;
1085 zend_long encoding, level = -1, memory = 8, window = 15, strategy = Z_DEFAULT_STRATEGY;
1086 char *dict = NULL;
1087 size_t dictlen = 0;
1088 HashTable *options = NULL;
1089 zval *option_buffer;
1090
1091 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "l|H", &encoding, &options)) {
1092 RETURN_THROWS();
1093 }
1094
1095 if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("level"))) != NULL) {
1096 level = zval_get_long(option_buffer);
1097 }
1098 if (level < -1 || level > 9) {
1099 zend_value_error("deflate_init(): \"level\" option must be between -1 and 9");
1100 RETURN_THROWS();
1101 }
1102
1103 if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("memory"))) != NULL) {
1104 memory = zval_get_long(option_buffer);
1105 }
1106 if (memory < 1 || memory > 9) {
1107 zend_value_error("deflate_init(): \"memory\" option must be between 1 and 9");
1108 RETURN_THROWS();
1109 }
1110
1111 if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("window"))) != NULL) {
1112 window = zval_get_long(option_buffer);
1113 }
1114 if (window < 8 || window > 15) {
1115 zend_value_error("deflate_init(): \"window\" option must be between 8 and 15");
1116 RETURN_THROWS();
1117 }
1118
1119 if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("strategy"))) != NULL) {
1120 strategy = zval_get_long(option_buffer);
1121 }
1122 switch (strategy) {
1123 case Z_FILTERED:
1124 case Z_HUFFMAN_ONLY:
1125 case Z_RLE:
1126 case Z_FIXED:
1127 case Z_DEFAULT_STRATEGY:
1128 break;
1129 default:
1130 zend_value_error("deflate_init(): \"strategy\" option must be one of ZLIB_FILTERED, ZLIB_HUFFMAN_ONLY, ZLIB_RLE, ZLIB_FIXED, or ZLIB_DEFAULT_STRATEGY");
1131 RETURN_THROWS();
1132 }
1133
1134 if (!zlib_create_dictionary_string(options, &dict, &dictlen)) {
1135 RETURN_THROWS();
1136 }
1137
1138 switch (encoding) {
1139 case PHP_ZLIB_ENCODING_RAW:
1140 case PHP_ZLIB_ENCODING_GZIP:
1141 case PHP_ZLIB_ENCODING_DEFLATE:
1142 break;
1143 default:
1144 zend_argument_value_error(1, "must be one of ZLIB_ENCODING_RAW, ZLIB_ENCODING_GZIP, or ZLIB_ENCODING_DEFLATE");
1145 RETURN_THROWS();
1146 }
1147
1148 object_init_ex(return_value, deflate_context_ce);
1149 ctx = Z_DEFLATE_CONTEXT_P(return_value);
1150
1151 ctx->Z.zalloc = php_zlib_alloc;
1152 ctx->Z.zfree = php_zlib_free;
1153
1154 if (encoding < 0) {
1155 encoding += 15 - window;
1156 } else {
1157 encoding -= 15 - window;
1158 }
1159
1160 if (deflateInit2(&ctx->Z, level, Z_DEFLATED, encoding, memory, strategy) != Z_OK) {
1161 zval_ptr_dtor(return_value);
1162 php_error_docref(NULL, E_WARNING, "Failed allocating zlib.deflate context");
1163 RETURN_FALSE;
1164 }
1165
1166 if (dict) {
1167 int success = deflateSetDictionary(&ctx->Z, (Bytef *) dict, dictlen);
1168 ZEND_ASSERT(success == Z_OK);
1169 efree(dict);
1170 }
1171 }
1172 /* }}} */
1173
1174 /* {{{ Incrementally deflate data in the specified context */
PHP_FUNCTION(deflate_add)1175 PHP_FUNCTION(deflate_add)
1176 {
1177 zend_string *out;
1178 char *in_buf;
1179 size_t in_len, out_size, buffer_used;
1180 zval *res;
1181 php_zlib_context *ctx;
1182 zend_long flush_type = Z_SYNC_FLUSH;
1183 int status;
1184
1185 if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Os|l", &res, deflate_context_ce, &in_buf, &in_len, &flush_type)) {
1186 RETURN_THROWS();
1187 }
1188
1189 ctx = Z_DEFLATE_CONTEXT_P(res);
1190
1191 switch (flush_type) {
1192 case Z_BLOCK:
1193 #if ZLIB_VERNUM < 0x1240L
1194 zend_throw_error(NULL, "zlib >= 1.2.4 required for BLOCK deflate; current version: %s", ZLIB_VERSION);
1195 RETURN_THROWS();
1196 #endif
1197 case Z_NO_FLUSH:
1198 case Z_PARTIAL_FLUSH:
1199 case Z_SYNC_FLUSH:
1200 case Z_FULL_FLUSH:
1201 case Z_FINISH:
1202 break;
1203
1204 default:
1205 zend_argument_value_error(3, "must be one of ZLIB_NO_FLUSH, ZLIB_PARTIAL_FLUSH, ZLIB_SYNC_FLUSH, ZLIB_FULL_FLUSH, ZLIB_BLOCK, or ZLIB_FINISH");
1206 RETURN_THROWS();
1207 }
1208
1209 if (in_len <= 0 && flush_type != Z_FINISH) {
1210 RETURN_EMPTY_STRING();
1211 }
1212
1213 out_size = PHP_ZLIB_BUFFER_SIZE_GUESS(in_len);
1214 out_size = (out_size < 64) ? 64 : out_size;
1215 out = zend_string_alloc(out_size, 0);
1216
1217 ctx->Z.next_in = (Bytef *) in_buf;
1218 ctx->Z.next_out = (Bytef *) ZSTR_VAL(out);
1219 ctx->Z.avail_in = in_len;
1220 ctx->Z.avail_out = ZSTR_LEN(out);
1221
1222 buffer_used = 0;
1223
1224 do {
1225 if (ctx->Z.avail_out == 0) {
1226 /* more output buffer space needed; realloc and try again */
1227 /* adding 64 more bytes solved every issue I have seen */
1228 out = zend_string_realloc(out, ZSTR_LEN(out) + 64, 0);
1229 ctx->Z.avail_out = 64;
1230 ctx->Z.next_out = (Bytef *) ZSTR_VAL(out) + buffer_used;
1231 }
1232 status = deflate(&ctx->Z, flush_type);
1233 buffer_used = ZSTR_LEN(out) - ctx->Z.avail_out;
1234 } while (status == Z_OK && ctx->Z.avail_out == 0);
1235
1236 switch (status) {
1237 case Z_OK:
1238 ZSTR_LEN(out) = (char *) ctx->Z.next_out - ZSTR_VAL(out);
1239 ZSTR_VAL(out)[ZSTR_LEN(out)] = 0;
1240 RETURN_STR(out);
1241 break;
1242 case Z_STREAM_END:
1243 ZSTR_LEN(out) = (char *) ctx->Z.next_out - ZSTR_VAL(out);
1244 ZSTR_VAL(out)[ZSTR_LEN(out)] = 0;
1245 deflateReset(&ctx->Z);
1246 RETURN_STR(out);
1247 break;
1248 default:
1249 zend_string_release_ex(out, 0);
1250 php_error_docref(NULL, E_WARNING, "zlib error (%s)", zError(status));
1251 RETURN_FALSE;
1252 }
1253 }
1254 /* }}} */
1255
1256 #ifdef COMPILE_DL_ZLIB
1257 #ifdef ZTS
1258 ZEND_TSRMLS_CACHE_DEFINE()
1259 #endif
ZEND_GET_MODULE(php_zlib)1260 ZEND_GET_MODULE(php_zlib)
1261 #endif
1262
1263 /* {{{ OnUpdate_zlib_output_compression */
1264 static PHP_INI_MH(OnUpdate_zlib_output_compression)
1265 {
1266 int int_value;
1267 char *ini_value;
1268 if (new_value == NULL) {
1269 return FAILURE;
1270 }
1271
1272 if (zend_string_equals_literal_ci(new_value, "off")) {
1273 int_value = 0;
1274 } else if (zend_string_equals_literal_ci(new_value, "on")) {
1275 int_value = 1;
1276 } else {
1277 int_value = (int) zend_ini_parse_quantity_warn(new_value, entry->name);
1278 }
1279 ini_value = zend_ini_string("output_handler", sizeof("output_handler") - 1, 0);
1280
1281 if (ini_value && *ini_value && int_value) {
1282 php_error_docref("ref.outcontrol", E_CORE_ERROR, "Cannot use both zlib.output_compression and output_handler together!!");
1283 return FAILURE;
1284 }
1285 if (stage == PHP_INI_STAGE_RUNTIME) {
1286 int status = php_output_get_status();
1287 if (status & PHP_OUTPUT_SENT) {
1288 php_error_docref("ref.outcontrol", E_WARNING, "Cannot change zlib.output_compression - headers already sent");
1289 return FAILURE;
1290 }
1291 }
1292
1293 zend_long *p = (zend_long *) ZEND_INI_GET_ADDR();
1294 *p = int_value;
1295
1296 ZLIBG(output_compression) = ZLIBG(output_compression_default);
1297 if (stage == PHP_INI_STAGE_RUNTIME && int_value) {
1298 if (!php_output_handler_started(ZEND_STRL(PHP_ZLIB_OUTPUT_HANDLER_NAME))) {
1299 php_zlib_output_compression_start();
1300 }
1301 }
1302
1303 return SUCCESS;
1304 }
1305 /* }}} */
1306
1307 /* {{{ OnUpdate_zlib_output_handler */
PHP_INI_MH(OnUpdate_zlib_output_handler)1308 static PHP_INI_MH(OnUpdate_zlib_output_handler)
1309 {
1310 if (stage == PHP_INI_STAGE_RUNTIME && (php_output_get_status() & PHP_OUTPUT_SENT)) {
1311 php_error_docref("ref.outcontrol", E_WARNING, "Cannot change zlib.output_handler - headers already sent");
1312 return FAILURE;
1313 }
1314
1315 return OnUpdateString(entry, new_value, mh_arg1, mh_arg2, mh_arg3, stage);
1316 }
1317 /* }}} */
1318
1319 /* {{{ INI */
1320 PHP_INI_BEGIN()
1321 STD_PHP_INI_BOOLEAN("zlib.output_compression", "0", PHP_INI_ALL, OnUpdate_zlib_output_compression, output_compression_default, zend_zlib_globals, zlib_globals)
1322 STD_PHP_INI_ENTRY("zlib.output_compression_level", "-1", PHP_INI_ALL, OnUpdateLong, output_compression_level, zend_zlib_globals, zlib_globals)
1323 STD_PHP_INI_ENTRY("zlib.output_handler", "", PHP_INI_ALL, OnUpdate_zlib_output_handler, output_handler, zend_zlib_globals, zlib_globals)
PHP_INI_END()1324 PHP_INI_END()
1325
1326 /* }}} */
1327
1328 /* {{{ PHP_MINIT_FUNCTION */
1329 static PHP_MINIT_FUNCTION(zlib)
1330 {
1331 php_register_url_stream_wrapper("compress.zlib", &php_stream_gzip_wrapper);
1332 php_stream_filter_register_factory("zlib.*", &php_zlib_filter_factory);
1333
1334 php_output_handler_alias_register(ZEND_STRL("ob_gzhandler"), php_zlib_output_handler_init);
1335 php_output_handler_conflict_register(ZEND_STRL("ob_gzhandler"), php_zlib_output_conflict_check);
1336 php_output_handler_conflict_register(ZEND_STRL(PHP_ZLIB_OUTPUT_HANDLER_NAME), php_zlib_output_conflict_check);
1337
1338 inflate_context_ce = register_class_InflateContext();
1339 inflate_context_ce->create_object = inflate_context_create_object;
1340 inflate_context_ce->default_object_handlers = &inflate_context_object_handlers;
1341
1342 memcpy(&inflate_context_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
1343 inflate_context_object_handlers.offset = XtOffsetOf(php_zlib_context, std);
1344 inflate_context_object_handlers.free_obj = inflate_context_free_obj;
1345 inflate_context_object_handlers.get_constructor = inflate_context_get_constructor;
1346 inflate_context_object_handlers.clone_obj = NULL;
1347 inflate_context_object_handlers.compare = zend_objects_not_comparable;
1348
1349 deflate_context_ce = register_class_DeflateContext();
1350 deflate_context_ce->create_object = deflate_context_create_object;
1351 deflate_context_ce->default_object_handlers = &deflate_context_object_handlers;
1352
1353 memcpy(&deflate_context_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
1354 deflate_context_object_handlers.offset = XtOffsetOf(php_zlib_context, std);
1355 deflate_context_object_handlers.free_obj = deflate_context_free_obj;
1356 deflate_context_object_handlers.get_constructor = deflate_context_get_constructor;
1357 deflate_context_object_handlers.clone_obj = NULL;
1358 deflate_context_object_handlers.compare = zend_objects_not_comparable;
1359
1360 register_zlib_symbols(module_number);
1361
1362 REGISTER_INI_ENTRIES();
1363 return SUCCESS;
1364 }
1365 /* }}} */
1366
1367 /* {{{ PHP_MSHUTDOWN_FUNCTION */
PHP_MSHUTDOWN_FUNCTION(zlib)1368 static PHP_MSHUTDOWN_FUNCTION(zlib)
1369 {
1370 php_unregister_url_stream_wrapper("zlib");
1371 php_stream_filter_unregister_factory("zlib.*");
1372
1373 UNREGISTER_INI_ENTRIES();
1374
1375 return SUCCESS;
1376 }
1377 /* }}} */
1378
1379 /* {{{ PHP_RINIT_FUNCTION */
PHP_RINIT_FUNCTION(zlib)1380 static PHP_RINIT_FUNCTION(zlib)
1381 {
1382 ZLIBG(compression_coding) = 0;
1383 if (!ZLIBG(handler_registered)) {
1384 ZLIBG(output_compression) = ZLIBG(output_compression_default);
1385 php_zlib_output_compression_start();
1386 }
1387
1388 return SUCCESS;
1389 }
1390 /* }}} */
1391
1392 /* {{{ PHP_RSHUTDOWN_FUNCTION */
PHP_RSHUTDOWN_FUNCTION(zlib)1393 static PHP_RSHUTDOWN_FUNCTION(zlib)
1394 {
1395 php_zlib_cleanup_ob_gzhandler_mess();
1396 ZLIBG(handler_registered) = 0;
1397
1398 return SUCCESS;
1399 }
1400 /* }}} */
1401
1402 /* {{{ PHP_MINFO_FUNCTION */
PHP_MINFO_FUNCTION(zlib)1403 static PHP_MINFO_FUNCTION(zlib)
1404 {
1405 php_info_print_table_start();
1406 php_info_print_table_row(2, "ZLib Support", "enabled");
1407 php_info_print_table_row(2, "Stream Wrapper", "compress.zlib://");
1408 php_info_print_table_row(2, "Stream Filter", "zlib.inflate, zlib.deflate");
1409 php_info_print_table_row(2, "Compiled Version", ZLIB_VERSION);
1410 php_info_print_table_row(2, "Linked Version", (char *) zlibVersion());
1411 php_info_print_table_end();
1412
1413 DISPLAY_INI_ENTRIES();
1414 }
1415 /* }}} */
1416
1417 /* {{{ ZEND_MODULE_GLOBALS_CTOR */
PHP_GINIT_FUNCTION(zlib)1418 static PHP_GINIT_FUNCTION(zlib)
1419 {
1420 #if defined(COMPILE_DL_ZLIB) && defined(ZTS)
1421 ZEND_TSRMLS_CACHE_UPDATE();
1422 #endif
1423 zlib_globals->ob_gzhandler = NULL;
1424 zlib_globals->handler_registered = 0;
1425 }
1426 /* }}} */
1427
1428 /* {{{ php_zlib_module_entry */
1429 zend_module_entry php_zlib_module_entry = {
1430 STANDARD_MODULE_HEADER,
1431 "zlib",
1432 ext_functions,
1433 PHP_MINIT(zlib),
1434 PHP_MSHUTDOWN(zlib),
1435 PHP_RINIT(zlib),
1436 PHP_RSHUTDOWN(zlib),
1437 PHP_MINFO(zlib),
1438 PHP_ZLIB_VERSION,
1439 PHP_MODULE_GLOBALS(zlib),
1440 PHP_GINIT(zlib),
1441 NULL,
1442 NULL,
1443 STANDARD_MODULE_PROPERTIES_EX
1444 };
1445 /* }}} */
1446
