Annotation of embedaddon/php/ext/zlib/zlib.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Authors: Rasmus Lerdorf <rasmus@lerdorf.on.ca> |
! 16: | Stefan Röhrich <sr@linux.de> |
! 17: | Zeev Suraski <zeev@zend.com> |
! 18: | Jade Nicoletti <nicoletti@nns.ch> |
! 19: +----------------------------------------------------------------------+
! 20: */
! 21:
! 22: /* $Id: zlib.c 321634 2012-01-01 13:15:04Z felipe $ */
! 23:
! 24: #ifdef HAVE_CONFIG_H
! 25: #include "config.h"
! 26: #endif
! 27:
! 28: #include "php.h"
! 29: #include "SAPI.h"
! 30: #include "php_ini.h"
! 31:
! 32: #include <stdlib.h>
! 33: #include <errno.h>
! 34: #include <sys/types.h>
! 35: #include <sys/stat.h>
! 36: #include <fcntl.h>
! 37:
! 38: #ifdef PHP_WIN32
! 39: # define O_RDONLY _O_RDONLY
! 40: # include "win32/param.h"
! 41: #else
! 42: # include <sys/param.h>
! 43: /* #include <sys/uio.h> */
! 44: #endif
! 45:
! 46: #include "ext/standard/head.h"
! 47: #include "safe_mode.h"
! 48: #include "ext/standard/php_standard.h"
! 49: #include "ext/standard/info.h"
! 50: #include "php_zlib.h"
! 51: #include "fopen_wrappers.h"
! 52:
! 53: #if HAVE_PWD_H
! 54: # ifdef PHP_WIN32
! 55: # include "win32/pwd.h"
! 56: # else
! 57: # include <pwd.h>
! 58: # endif
! 59: #endif
! 60:
! 61: #if defined(HAVE_UNISTD_H) && defined(PHP_WIN32)
! 62: # undef HAVE_UNISTD_H
! 63: #endif
! 64:
! 65: #ifdef COMPILE_DL_ZLIB
! 66: # ifndef PUTS
! 67: # define PUTS(a) php_printf("%s",a)
! 68: # endif
! 69: # ifndef PUTC
! 70: # define PUTC(a) PUTS(a)
! 71: # endif
! 72: # ifndef PHPWRITE
! 73: # define PHPWRITE(a,n) php_write((a),(n) TSRMLS_CC)
! 74: # endif
! 75: #endif
! 76:
! 77: /* Win32 needs some more memory */
! 78: #ifdef PHP_WIN32
! 79: # define PHP_ZLIB_MODIFIER 100
! 80: #else
! 81: # define PHP_ZLIB_MODIFIER 1000
! 82: #endif
! 83:
! 84: #define OS_CODE 0x03 /* FIXME */
! 85: #define GZIP_HEADER_LENGTH 10
! 86: #define GZIP_FOOTER_LENGTH 8
! 87:
! 88: /* True globals, no need for thread safety */
! 89: static const int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */
! 90:
! 91: static int php_zlib_output_compression_start(TSRMLS_D);
! 92:
! 93: static PHP_MINIT_FUNCTION(zlib);
! 94: static PHP_MSHUTDOWN_FUNCTION(zlib);
! 95: static PHP_RINIT_FUNCTION(zlib);
! 96: static PHP_MINFO_FUNCTION(zlib);
! 97: static PHP_FUNCTION(gzopen);
! 98: static PHP_FUNCTION(readgzfile);
! 99: static PHP_FUNCTION(gzfile);
! 100: static PHP_FUNCTION(gzcompress);
! 101: static PHP_FUNCTION(gzuncompress);
! 102: static PHP_FUNCTION(gzdeflate);
! 103: static PHP_FUNCTION(gzinflate);
! 104: static PHP_FUNCTION(gzencode);
! 105: static PHP_FUNCTION(ob_gzhandler);
! 106: static PHP_FUNCTION(zlib_get_coding_type);
! 107:
! 108: /* {{{ arginfo */
! 109: ZEND_BEGIN_ARG_INFO_EX(arginfo_gzfile, 0, 0, 1)
! 110: ZEND_ARG_INFO(0, filename)
! 111: ZEND_ARG_INFO(0, use_include_path)
! 112: ZEND_END_ARG_INFO()
! 113:
! 114: ZEND_BEGIN_ARG_INFO_EX(arginfo_gzopen, 0, 0, 2)
! 115: ZEND_ARG_INFO(0, filename)
! 116: ZEND_ARG_INFO(0, mode)
! 117: ZEND_ARG_INFO(0, use_include_path)
! 118: ZEND_END_ARG_INFO()
! 119:
! 120: ZEND_BEGIN_ARG_INFO_EX(arginfo_readgzfile, 0, 0, 1)
! 121: ZEND_ARG_INFO(0, filename)
! 122: ZEND_ARG_INFO(0, use_include_path)
! 123: ZEND_END_ARG_INFO()
! 124:
! 125: ZEND_BEGIN_ARG_INFO_EX(arginfo_gzcompress, 0, 0, 1)
! 126: ZEND_ARG_INFO(0, data)
! 127: ZEND_ARG_INFO(0, level)
! 128: ZEND_END_ARG_INFO()
! 129:
! 130: ZEND_BEGIN_ARG_INFO_EX(arginfo_gzuncompress, 0, 0, 1)
! 131: ZEND_ARG_INFO(0, data)
! 132: ZEND_ARG_INFO(0, length)
! 133: ZEND_END_ARG_INFO()
! 134:
! 135: ZEND_BEGIN_ARG_INFO_EX(arginfo_gzdeflate, 0, 0, 1)
! 136: ZEND_ARG_INFO(0, data)
! 137: ZEND_ARG_INFO(0, level)
! 138: ZEND_END_ARG_INFO()
! 139:
! 140: ZEND_BEGIN_ARG_INFO_EX(arginfo_gzinflate, 0, 0, 1)
! 141: ZEND_ARG_INFO(0, data)
! 142: ZEND_ARG_INFO(0, length)
! 143: ZEND_END_ARG_INFO()
! 144:
! 145: ZEND_BEGIN_ARG_INFO(arginfo_zlib_get_coding_type, 0)
! 146: ZEND_END_ARG_INFO()
! 147:
! 148: ZEND_BEGIN_ARG_INFO_EX(arginfo_gzencode, 0, 0, 1)
! 149: ZEND_ARG_INFO(0, data)
! 150: ZEND_ARG_INFO(0, level)
! 151: ZEND_ARG_INFO(0, encoding_mode)
! 152: ZEND_END_ARG_INFO()
! 153:
! 154: ZEND_BEGIN_ARG_INFO_EX(arginfo_ob_gzhandler, 0, 0, 2)
! 155: ZEND_ARG_INFO(0, str)
! 156: ZEND_ARG_INFO(0, mode)
! 157: ZEND_END_ARG_INFO()
! 158:
! 159: ZEND_BEGIN_ARG_INFO_EX(arginfo_gzputs, 0, 0, 2)
! 160: ZEND_ARG_INFO(0, fp)
! 161: ZEND_ARG_INFO(0, str)
! 162: ZEND_ARG_INFO(0, length)
! 163: ZEND_END_ARG_INFO()
! 164:
! 165: ZEND_BEGIN_ARG_INFO(arginfo_gzpassthru, 0)
! 166: ZEND_ARG_INFO(0, fp)
! 167: ZEND_END_ARG_INFO()
! 168:
! 169: ZEND_BEGIN_ARG_INFO_EX(arginfo_gzseek, 0, 0, 2)
! 170: ZEND_ARG_INFO(0, fp)
! 171: ZEND_ARG_INFO(0, offset)
! 172: ZEND_ARG_INFO(0, whence)
! 173: ZEND_END_ARG_INFO()
! 174:
! 175: ZEND_BEGIN_ARG_INFO(arginfo_gzread, 0)
! 176: ZEND_ARG_INFO(0, fp)
! 177: ZEND_ARG_INFO(0, length)
! 178: ZEND_END_ARG_INFO()
! 179:
! 180: ZEND_BEGIN_ARG_INFO_EX(arginfo_gzgetss, 0, 0, 1)
! 181: ZEND_ARG_INFO(0, fp)
! 182: ZEND_ARG_INFO(0, length)
! 183: ZEND_ARG_INFO(0, allowable_tags)
! 184: ZEND_END_ARG_INFO()
! 185:
! 186: ZEND_BEGIN_ARG_INFO_EX(arginfo_gzgets, 0, 0, 1)
! 187: ZEND_ARG_INFO(0, fp)
! 188: ZEND_ARG_INFO(0, length)
! 189: ZEND_END_ARG_INFO()
! 190: /* }}} */
! 191:
! 192: /* {{{ php_zlib_functions[]
! 193: */
! 194: static const zend_function_entry php_zlib_functions[] = {
! 195: PHP_FE(readgzfile, arginfo_readgzfile)
! 196: PHP_FALIAS(gzrewind, rewind, arginfo_gzpassthru)
! 197: PHP_FALIAS(gzclose, fclose, arginfo_gzpassthru)
! 198: PHP_FALIAS(gzeof, feof, arginfo_gzpassthru)
! 199: PHP_FALIAS(gzgetc, fgetc, arginfo_gzpassthru)
! 200: PHP_FALIAS(gzgets, fgets, arginfo_gzgets)
! 201: PHP_FALIAS(gzgetss, fgetss, arginfo_gzgetss)
! 202: PHP_FALIAS(gzread, fread, arginfo_gzread)
! 203: PHP_FE(gzopen, arginfo_gzopen)
! 204: PHP_FALIAS(gzpassthru, fpassthru, arginfo_gzpassthru)
! 205: PHP_FALIAS(gzseek, fseek, arginfo_gzseek)
! 206: PHP_FALIAS(gztell, ftell, arginfo_gzpassthru)
! 207: PHP_FALIAS(gzwrite, fwrite, arginfo_gzputs)
! 208: PHP_FALIAS(gzputs, fwrite, arginfo_gzputs)
! 209: PHP_FE(gzfile, arginfo_gzfile)
! 210: PHP_FE(gzcompress, arginfo_gzcompress)
! 211: PHP_FE(gzuncompress, arginfo_gzuncompress)
! 212: PHP_FE(gzdeflate, arginfo_gzdeflate)
! 213: PHP_FE(gzinflate, arginfo_gzinflate)
! 214: PHP_FE(gzencode, arginfo_gzencode)
! 215: PHP_FE(ob_gzhandler, arginfo_ob_gzhandler)
! 216: PHP_FE(zlib_get_coding_type, arginfo_zlib_get_coding_type)
! 217: PHP_FE_END
! 218: };
! 219: /* }}} */
! 220:
! 221: ZEND_DECLARE_MODULE_GLOBALS(zlib)
! 222:
! 223: /* {{{ php_zlib_module_entry
! 224: */
! 225: zend_module_entry php_zlib_module_entry = {
! 226: STANDARD_MODULE_HEADER,
! 227: "zlib",
! 228: php_zlib_functions,
! 229: PHP_MINIT(zlib),
! 230: PHP_MSHUTDOWN(zlib),
! 231: PHP_RINIT(zlib),
! 232: NULL,
! 233: PHP_MINFO(zlib),
! 234: "1.1",
! 235: PHP_MODULE_GLOBALS(zlib),
! 236: NULL,
! 237: NULL,
! 238: NULL,
! 239: STANDARD_MODULE_PROPERTIES_EX
! 240: };
! 241: /* }}} */
! 242:
! 243: #ifdef COMPILE_DL_ZLIB
! 244: ZEND_GET_MODULE(php_zlib)
! 245: #endif
! 246:
! 247: /* {{{ Memory management wrappers */
! 248:
! 249: static voidpf php_zlib_alloc(voidpf opaque, uInt items, uInt size)
! 250: {
! 251: return (voidpf)safe_emalloc(items, size, 0);
! 252: }
! 253:
! 254: static void php_zlib_free(voidpf opaque, voidpf address)
! 255: {
! 256: efree((void*)address);
! 257: }
! 258: /* }}} */
! 259:
! 260: /* {{{ OnUpdate_zlib_output_compression */
! 261: static PHP_INI_MH(OnUpdate_zlib_output_compression)
! 262: {
! 263: int status, int_value;
! 264: char *ini_value;
! 265:
! 266: if (new_value == NULL) {
! 267: return FAILURE;
! 268: }
! 269:
! 270: if (!strncasecmp(new_value, "off", sizeof("off"))) {
! 271: new_value = "0";
! 272: new_value_length = sizeof("0");
! 273: } else if (!strncasecmp(new_value, "on", sizeof("on"))) {
! 274: new_value = "1";
! 275: new_value_length = sizeof("1");
! 276: }
! 277:
! 278: int_value = zend_atoi(new_value, new_value_length);
! 279: ini_value = zend_ini_string("output_handler", sizeof("output_handler"), 0);
! 280:
! 281: if (ini_value && *ini_value && int_value) {
! 282: php_error_docref("ref.outcontrol" TSRMLS_CC, E_CORE_ERROR, "Cannot use both zlib.output_compression and output_handler together!!");
! 283: return FAILURE;
! 284: }
! 285:
! 286: if (stage == PHP_INI_STAGE_RUNTIME && SG(headers_sent) && !SG(request_info).no_headers) {
! 287: php_error_docref("ref.outcontrol" TSRMLS_CC, E_WARNING, "Cannot change zlib.output_compression - headers already sent");
! 288: return FAILURE;
! 289: }
! 290:
! 291: status = OnUpdateLong(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
! 292:
! 293: if (stage == PHP_INI_STAGE_RUNTIME && int_value) {
! 294: status = php_zlib_output_compression_start(TSRMLS_C);
! 295: }
! 296:
! 297: return status;
! 298: }
! 299: /* }}} */
! 300:
! 301: /* {{{ OnUpdate_zlib_output_compression_level */
! 302: static PHP_INI_MH(OnUpdate_zlib_output_compression_level)
! 303: {
! 304: OnUpdateLong(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
! 305:
! 306: return SUCCESS;
! 307: }
! 308: /* }}} */
! 309:
! 310: /* {{{ OnUpdate_zlib_output_handler */
! 311: static PHP_INI_MH(OnUpdate_zlib_output_handler)
! 312: {
! 313: if (stage == PHP_INI_STAGE_RUNTIME && SG(headers_sent) && !SG(request_info).no_headers) {
! 314: php_error_docref("ref.outcontrol" TSRMLS_CC, E_WARNING, "Cannot change zlib.output_handler - headers already sent");
! 315: return FAILURE;
! 316: }
! 317:
! 318: OnUpdateString(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
! 319:
! 320: return SUCCESS;
! 321: }
! 322: /* }}} */
! 323:
! 324:
! 325: PHP_INI_BEGIN()
! 326: STD_PHP_INI_BOOLEAN("zlib.output_compression", "0", PHP_INI_ALL, OnUpdate_zlib_output_compression, output_compression, zend_zlib_globals, zlib_globals)
! 327: STD_PHP_INI_ENTRY("zlib.output_compression_level", "-1", PHP_INI_ALL, OnUpdate_zlib_output_compression_level, output_compression_level, zend_zlib_globals, zlib_globals)
! 328: STD_PHP_INI_ENTRY("zlib.output_handler", "", PHP_INI_ALL, OnUpdate_zlib_output_handler, output_handler, zend_zlib_globals, zlib_globals)
! 329: PHP_INI_END()
! 330:
! 331: /* {{{ PHP_MINIT_FUNCTION
! 332: */
! 333: static PHP_MINIT_FUNCTION(zlib)
! 334: {
! 335: php_register_url_stream_wrapper("compress.zlib", &php_stream_gzip_wrapper TSRMLS_CC);
! 336: php_stream_filter_register_factory("zlib.*", &php_zlib_filter_factory TSRMLS_CC);
! 337:
! 338: REGISTER_LONG_CONSTANT("FORCE_GZIP", CODING_GZIP, CONST_CS | CONST_PERSISTENT);
! 339: REGISTER_LONG_CONSTANT("FORCE_DEFLATE", CODING_DEFLATE, CONST_CS | CONST_PERSISTENT);
! 340:
! 341: REGISTER_INI_ENTRIES();
! 342:
! 343: return SUCCESS;
! 344: }
! 345: /* }}} */
! 346:
! 347: /* {{{ PHP_RINIT_FUNCTION
! 348: */
! 349: static PHP_RINIT_FUNCTION(zlib)
! 350: {
! 351: ZLIBG(ob_gzhandler_status) = 0;
! 352: ZLIBG(compression_coding) = 0;
! 353:
! 354: php_zlib_output_compression_start(TSRMLS_C);
! 355:
! 356: return SUCCESS;
! 357: }
! 358: /* }}} */
! 359:
! 360: /* {{{ PHP_MSHUTDOWN_FUNCTION
! 361: */
! 362: static PHP_MSHUTDOWN_FUNCTION(zlib)
! 363: {
! 364: php_unregister_url_stream_wrapper("zlib" TSRMLS_CC);
! 365: php_stream_filter_unregister_factory("zlib.*" TSRMLS_CC);
! 366:
! 367: UNREGISTER_INI_ENTRIES();
! 368:
! 369: return SUCCESS;
! 370: }
! 371: /* }}} */
! 372:
! 373: /* {{{ PHP_MINFO_FUNCTION
! 374: */
! 375: static PHP_MINFO_FUNCTION(zlib)
! 376: {
! 377: php_info_print_table_start();
! 378: php_info_print_table_row(2, "ZLib Support", "enabled");
! 379: php_info_print_table_row(2, "Stream Wrapper support", "compress.zlib://");
! 380: php_info_print_table_row(2, "Stream Filter support", "zlib.inflate, zlib.deflate");
! 381: php_info_print_table_row(2, "Compiled Version", ZLIB_VERSION);
! 382: php_info_print_table_row(2, "Linked Version", (char *) zlibVersion());
! 383: php_info_print_table_end();
! 384:
! 385: DISPLAY_INI_ENTRIES();
! 386: }
! 387: /* }}} */
! 388:
! 389: /* {{{ proto array gzfile(string filename [, int use_include_path])
! 390: Read und uncompress entire .gz-file into an array */
! 391: static PHP_FUNCTION(gzfile)
! 392: {
! 393: char *filename;
! 394: int filename_len;
! 395: long flags = 0;
! 396: char *slashed, buf[8192];
! 397: register int i = 0;
! 398: int use_include_path = 0;
! 399: php_stream *stream;
! 400:
! 401: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &filename, &filename_len, &flags) == FAILURE) {
! 402: return;
! 403: }
! 404:
! 405: use_include_path = flags ? USE_PATH : 0;
! 406:
! 407: /* using a stream here is a bit more efficient (resource wise) than php_gzopen_wrapper */
! 408: stream = php_stream_gzopen(NULL, filename, "rb", use_include_path | ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL, NULL STREAMS_CC TSRMLS_CC);
! 409: if (stream == NULL) {
! 410: /* Error reporting is already done by stream code */
! 411: RETURN_FALSE;
! 412: }
! 413:
! 414: /* Initialize return array */
! 415: array_init(return_value);
! 416:
! 417: /* Now loop through the file and do the magic quotes thing if needed */
! 418: memset(buf,0,sizeof(buf));
! 419:
! 420: while (php_stream_gets(stream, buf, sizeof(buf) - 1) != NULL) {
! 421: if (PG(magic_quotes_runtime)) {
! 422: int len;
! 423:
! 424: slashed = php_addslashes(buf, 0, &len, 0 TSRMLS_CC); /* 0 = don't free source string */
! 425: add_index_stringl(return_value, i++, slashed, len, 0);
! 426: } else {
! 427: add_index_string(return_value, i++, buf, 1);
! 428: }
! 429: }
! 430: php_stream_close(stream);
! 431: }
! 432: /* }}} */
! 433:
! 434: /* {{{ proto resource gzopen(string filename, string mode [, int use_include_path])
! 435: Open a .gz-file and return a .gz-file pointer */
! 436: static PHP_FUNCTION(gzopen)
! 437: {
! 438: char *filename, *mode;
! 439: int filename_len, mode_len;
! 440: long flags = 0;
! 441: php_stream *stream;
! 442: int use_include_path = 0;
! 443:
! 444: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", &filename, &filename_len, &mode, &mode_len, &flags) == FAILURE) {
! 445: return;
! 446: }
! 447:
! 448: use_include_path = flags ? USE_PATH : 0;
! 449:
! 450: stream = php_stream_gzopen(NULL, filename, mode, use_include_path | ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL, NULL STREAMS_CC TSRMLS_CC);
! 451:
! 452: if (!stream) {
! 453: RETURN_FALSE;
! 454: }
! 455: php_stream_to_zval(stream, return_value);
! 456: }
! 457: /* }}} */
! 458:
! 459: /*
! 460: * Read a file and write the ouput to stdout
! 461: */
! 462: /* {{{ proto int readgzfile(string filename [, int use_include_path])
! 463: Output a .gz-file */
! 464: static PHP_FUNCTION(readgzfile)
! 465: {
! 466: char *filename;
! 467: int filename_len;
! 468: long flags = 0;
! 469: php_stream *stream;
! 470: int size;
! 471: int use_include_path = 0;
! 472:
! 473: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &filename, &filename_len, &flags) == FAILURE) {
! 474: return;
! 475: }
! 476:
! 477: use_include_path = flags ? USE_PATH : 0;
! 478:
! 479: stream = php_stream_gzopen(NULL, filename, "rb", use_include_path | ENFORCE_SAFE_MODE, NULL, NULL STREAMS_CC TSRMLS_CC);
! 480: if (!stream) {
! 481: RETURN_FALSE;
! 482: }
! 483: size = php_stream_passthru(stream);
! 484: php_stream_close(stream);
! 485: RETURN_LONG(size);
! 486: }
! 487: /* }}} */
! 488:
! 489: /* {{{ proto string gzcompress(string data [, int level])
! 490: Gzip-compress a string */
! 491: static PHP_FUNCTION(gzcompress)
! 492: {
! 493: int data_len, status;
! 494: long level = Z_DEFAULT_COMPRESSION;
! 495: unsigned long l2;
! 496: char *data, *s2;
! 497:
! 498: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &data, &data_len, &level) == FAILURE) {
! 499: return;
! 500: }
! 501:
! 502: if ((level < -1) || (level > 9)) {
! 503: php_error_docref(NULL TSRMLS_CC, E_WARNING, "compression level (%ld) must be within -1..9", level);
! 504: RETURN_FALSE;
! 505: }
! 506:
! 507: l2 = data_len + (data_len / PHP_ZLIB_MODIFIER) + 15 + 1; /* room for \0 */
! 508: s2 = (char *) emalloc(l2);
! 509: if (!s2) {
! 510: RETURN_FALSE;
! 511: }
! 512:
! 513: if (level >= 0) {
! 514: status = compress2(s2, &l2, data, data_len, level);
! 515: } else {
! 516: status = compress(s2, &l2, data, data_len);
! 517: }
! 518:
! 519: if (status == Z_OK) {
! 520: s2 = erealloc(s2, l2 + 1);
! 521: s2[l2] = '\0';
! 522: RETURN_STRINGL(s2, l2, 0);
! 523: } else {
! 524: efree(s2);
! 525: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", zError(status));
! 526: RETURN_FALSE;
! 527: }
! 528: }
! 529: /* }}} */
! 530:
! 531: /* {{{ proto string gzuncompress(string data [, int length])
! 532: Unzip a gzip-compressed string */
! 533: static PHP_FUNCTION(gzuncompress)
! 534: {
! 535: int data_len, status;
! 536: unsigned int factor=1, maxfactor=16;
! 537: long limit = 0;
! 538: unsigned long plength=0, length;
! 539: char *data, *s1=NULL, *s2=NULL;
! 540:
! 541: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &data, &data_len, &limit) == FAILURE) {
! 542: return;
! 543: }
! 544:
! 545: if (limit < 0) {
! 546: php_error_docref(NULL TSRMLS_CC, E_WARNING, "length (%ld) must be greater or equal zero", limit);
! 547: RETURN_FALSE;
! 548: }
! 549: plength = limit;
! 550:
! 551: /*
! 552: zlib::uncompress() wants to know the output data length
! 553: if none was given as a parameter
! 554: we try from input length * 2 up to input length * 2^15
! 555: doubling it whenever it wasn't big enough
! 556: that should be eneugh for all real life cases
! 557: */
! 558: do {
! 559: length = plength ? plength : (unsigned long)data_len * (1 << factor++);
! 560: s2 = (char *) erealloc(s1, length);
! 561: status = uncompress(s2, &length, data, data_len);
! 562: s1 = s2;
! 563: } while ((status == Z_BUF_ERROR) && (!plength) && (factor < maxfactor));
! 564:
! 565: if (status == Z_OK) {
! 566: s2 = erealloc(s2, length + 1); /* space for \0 */
! 567: s2[ length ] = '\0';
! 568: RETURN_STRINGL(s2, length, 0);
! 569: } else {
! 570: efree(s2);
! 571: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", zError(status));
! 572: RETURN_FALSE;
! 573: }
! 574: }
! 575: /* }}} */
! 576:
! 577: /* {{{ proto string gzdeflate(string data [, int level])
! 578: Gzip-compress a string */
! 579: static PHP_FUNCTION(gzdeflate)
! 580: {
! 581: int data_len,status;
! 582: long level = Z_DEFAULT_COMPRESSION;
! 583: z_stream stream;
! 584: char *data, *s2;
! 585:
! 586: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &data, &data_len, &level) == FAILURE) {
! 587: return;
! 588: }
! 589:
! 590: if ((level < -1) || (level > 9)) {
! 591: php_error_docref(NULL TSRMLS_CC, E_WARNING, "compression level (%ld) must be within -1..9", level);
! 592: RETURN_FALSE;
! 593: }
! 594:
! 595: stream.data_type = Z_ASCII;
! 596: stream.zalloc = php_zlib_alloc;
! 597: stream.zfree = php_zlib_free;
! 598: stream.opaque = (voidpf) Z_NULL;
! 599:
! 600: stream.next_in = (Bytef *) data;
! 601: stream.avail_in = data_len;
! 602:
! 603: stream.avail_out = stream.avail_in + (stream.avail_in / PHP_ZLIB_MODIFIER) + 15 + 1; /* room for \0 */
! 604:
! 605: s2 = (char *) emalloc(stream.avail_out);
! 606: if (!s2) {
! 607: RETURN_FALSE;
! 608: }
! 609:
! 610: stream.next_out = s2;
! 611:
! 612: /* init with -MAX_WBITS disables the zlib internal headers */
! 613: status = deflateInit2(&stream, level, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, 0);
! 614: if (status == Z_OK) {
! 615: status = deflate(&stream, Z_FINISH);
! 616: if (status != Z_STREAM_END) {
! 617: deflateEnd(&stream);
! 618: if (status == Z_OK) {
! 619: status = Z_BUF_ERROR;
! 620: }
! 621: } else {
! 622: status = deflateEnd(&stream);
! 623: }
! 624: }
! 625:
! 626: if (status == Z_OK) {
! 627: s2 = erealloc(s2,stream.total_out + 1); /* resize to buffer to the "right" size */
! 628: s2[ stream.total_out ] = '\0';
! 629: RETURN_STRINGL(s2, stream.total_out, 0);
! 630: } else {
! 631: efree(s2);
! 632: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", zError(status));
! 633: RETURN_FALSE;
! 634: }
! 635: }
! 636: /* }}} */
! 637:
! 638: /* {{{ proto string gzinflate(string data [, int length])
! 639: Unzip a gzip-compressed string */
! 640: static PHP_FUNCTION(gzinflate)
! 641: {
! 642: int data_len, status;
! 643: unsigned int factor=1, maxfactor=16;
! 644: long limit = 0;
! 645: unsigned long plength=0, length;
! 646: char *data, *s1=NULL, *s2=NULL;
! 647: z_stream stream;
! 648:
! 649: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &data, &data_len, &limit) == FAILURE) {
! 650: return;
! 651: }
! 652:
! 653: if (!data_len) {
! 654: RETURN_FALSE;
! 655: }
! 656:
! 657: if (limit < 0) {
! 658: php_error_docref(NULL TSRMLS_CC, E_WARNING, "length (%ld) must be greater or equal zero", limit);
! 659: RETURN_FALSE;
! 660: }
! 661: plength = limit;
! 662:
! 663: stream.zalloc = php_zlib_alloc;
! 664: stream.zfree = php_zlib_free;
! 665: stream.opaque = Z_NULL;
! 666: stream.avail_in = data_len + 1; /* there is room for \0 */
! 667: stream.next_in = (Bytef *) data;
! 668: stream.total_out = 0;
! 669:
! 670: /* init with -MAX_WBITS disables the zlib internal headers */
! 671: status = inflateInit2(&stream, -MAX_WBITS);
! 672: if (status != Z_OK) {
! 673: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", zError(status));
! 674: RETURN_FALSE;
! 675: }
! 676:
! 677: /*
! 678: stream.avail_out wants to know the output data length
! 679: if none was given as a parameter
! 680: we try from input length * 2 up to input length * 2^15
! 681: doubling it whenever it wasn't big enough
! 682: that should be enaugh for all real life cases
! 683: */
! 684: do {
! 685: length = plength ? plength : (unsigned long)data_len * (1 << factor++);
! 686: s2 = (char *) erealloc(s1, length);
! 687:
! 688: if (!s2) {
! 689: if (s1) {
! 690: efree(s1);
! 691: }
! 692: inflateEnd(&stream);
! 693: RETURN_FALSE;
! 694: }
! 695: s1 = s2;
! 696:
! 697: stream.next_out = (Bytef *) &s2[stream.total_out];
! 698: stream.avail_out = length - stream.total_out;
! 699: status = inflate(&stream, Z_NO_FLUSH);
! 700:
! 701: } while ((Z_BUF_ERROR == status || (Z_OK == status && stream.avail_in)) && !plength && factor < maxfactor);
! 702:
! 703: inflateEnd(&stream);
! 704:
! 705: if ((plength && Z_OK == status) || factor >= maxfactor) {
! 706: status = Z_MEM_ERROR;
! 707: }
! 708:
! 709: if (Z_STREAM_END == status || Z_OK == status) {
! 710: s2 = erealloc(s2, stream.total_out + 1); /* room for \0 */
! 711: s2[ stream.total_out ] = '\0';
! 712: RETURN_STRINGL(s2, stream.total_out, 0);
! 713: } else {
! 714: efree(s2);
! 715: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", zError(status));
! 716: RETURN_FALSE;
! 717: }
! 718: }
! 719: /* }}} */
! 720:
! 721: /* {{{ proto string zlib_get_coding_type(void)
! 722: Returns the coding type used for output compression */
! 723: static PHP_FUNCTION(zlib_get_coding_type)
! 724: {
! 725: switch (ZLIBG(compression_coding)) {
! 726: case CODING_GZIP:
! 727: RETURN_STRINGL("gzip", sizeof("gzip") - 1, 1);
! 728:
! 729: case CODING_DEFLATE:
! 730: RETURN_STRINGL("deflate", sizeof("deflate") - 1, 1);
! 731: }
! 732:
! 733: RETURN_FALSE;
! 734: }
! 735:
! 736: /* {{{ php_do_deflate
! 737: */
! 738: static int php_do_deflate(uint str_length, Bytef **p_buffer, uint *p_buffer_len, zend_bool do_start, zend_bool do_end TSRMLS_DC)
! 739: {
! 740: Bytef *buffer;
! 741: uInt prev_outlen, outlen;
! 742: int err;
! 743: int start_offset = ((do_start && ZLIBG(compression_coding) == CODING_GZIP) ? 10 : 0);
! 744: int end_offset = (do_end ? 8 : 0);
! 745:
! 746: outlen = (uint) (str_length + (str_length / PHP_ZLIB_MODIFIER) + 12 + 1); /* leave some room for a trailing \0 */
! 747: if ((outlen + start_offset + end_offset) > *p_buffer_len) {
! 748: buffer = (Bytef *) emalloc(outlen + start_offset + end_offset);
! 749: } else {
! 750: buffer = *p_buffer;
! 751: }
! 752:
! 753: ZLIBG(stream).next_out = buffer + start_offset;
! 754: ZLIBG(stream).avail_out = outlen;
! 755:
! 756: err = deflate(&ZLIBG(stream), Z_SYNC_FLUSH);
! 757: while (err == Z_OK && !ZLIBG(stream).avail_out) {
! 758: prev_outlen = outlen;
! 759: outlen *= 3;
! 760: if ((outlen + start_offset + end_offset) > *p_buffer_len) {
! 761: buffer = erealloc(buffer, outlen + start_offset + end_offset);
! 762: }
! 763:
! 764: ZLIBG(stream).next_out = buffer + start_offset + prev_outlen;
! 765: ZLIBG(stream).avail_out = prev_outlen * 2;
! 766:
! 767: err = deflate(&ZLIBG(stream), Z_SYNC_FLUSH);
! 768: }
! 769:
! 770: if (do_end) {
! 771: err = deflate(&ZLIBG(stream), Z_FINISH);
! 772: buffer[outlen + start_offset - ZLIBG(stream).avail_out] = '\0';
! 773: }
! 774:
! 775: *p_buffer = buffer;
! 776: *p_buffer_len = outlen - ZLIBG(stream).avail_out;
! 777:
! 778: return err;
! 779: }
! 780: /* }}} */
! 781:
! 782: /* {{{ php_deflate_string
! 783: */
! 784: static int php_deflate_string(const char *str, uint str_length, char **newstr, uint *new_length, zend_bool do_start, zend_bool do_end TSRMLS_DC)
! 785: {
! 786: int err;
! 787:
! 788: if (do_start) {
! 789: ZLIBG(stream).zalloc = php_zlib_alloc;
! 790: ZLIBG(stream).zfree = php_zlib_free;
! 791: ZLIBG(stream).opaque = Z_NULL;
! 792:
! 793: switch (ZLIBG(compression_coding)) {
! 794: case CODING_GZIP:
! 795: /* windowBits is passed < 0 to suppress zlib header & trailer */
! 796: if (deflateInit2(&ZLIBG(stream), ZLIBG(output_compression_level), Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY) != Z_OK) {
! 797: /* TODO: print out error */
! 798: return FAILURE;
! 799: }
! 800:
! 801: ZLIBG(crc) = crc32(0L, Z_NULL, 0);
! 802: break;
! 803:
! 804: case CODING_DEFLATE:
! 805: if (deflateInit(&ZLIBG(stream), ZLIBG(output_compression_level)) != Z_OK) {
! 806: /* TODO: print out error */
! 807: return FAILURE;
! 808: }
! 809: break;
! 810: }
! 811: }
! 812:
! 813: ZLIBG(stream).next_in = (Bytef *) str;
! 814: ZLIBG(stream).avail_in = (uInt) str_length;
! 815:
! 816: if (ZLIBG(compression_coding) == CODING_GZIP) {
! 817: ZLIBG(crc) = crc32(ZLIBG(crc), (const Bytef *) str, str_length);
! 818: }
! 819:
! 820: err = php_do_deflate(str_length, (Bytef **) newstr, new_length, do_start, do_end TSRMLS_CC);
! 821: /* TODO: error handling (err may be Z_STREAM_ERROR, Z_BUF_ERROR, ?) */
! 822:
! 823: if (do_start && ZLIBG(compression_coding) == CODING_GZIP) {
! 824: /* Write a very simple .gz header: */
! 825: (*newstr)[0] = gz_magic[0];
! 826: (*newstr)[1] = gz_magic[1];
! 827: (*newstr)[2] = Z_DEFLATED;
! 828: (*newstr)[3] = (*newstr)[4] = (*newstr)[5] = (*newstr)[6] = (*newstr)[7] = (*newstr)[8] = 0;
! 829: (*newstr)[9] = OS_CODE;
! 830: *new_length += 10;
! 831: }
! 832: if (do_end) {
! 833: if (ZLIBG(compression_coding) == CODING_GZIP) {
! 834: char *trailer = (*newstr) + (*new_length);
! 835:
! 836: /* write crc & stream.total_in in LSB order */
! 837: trailer[0] = (char) ZLIBG(crc) & 0xFF;
! 838: trailer[1] = (char) (ZLIBG(crc) >> 8) & 0xFF;
! 839: trailer[2] = (char) (ZLIBG(crc) >> 16) & 0xFF;
! 840: trailer[3] = (char) (ZLIBG(crc) >> 24) & 0xFF;
! 841: trailer[4] = (char) ZLIBG(stream).total_in & 0xFF;
! 842: trailer[5] = (char) (ZLIBG(stream).total_in >> 8) & 0xFF;
! 843: trailer[6] = (char) (ZLIBG(stream).total_in >> 16) & 0xFF;
! 844: trailer[7] = (char) (ZLIBG(stream).total_in >> 24) & 0xFF;
! 845: trailer[8] = '\0';
! 846: *new_length += 8;
! 847: }
! 848: deflateEnd(&ZLIBG(stream));
! 849: }
! 850:
! 851: return SUCCESS;
! 852: }
! 853: /* }}} */
! 854:
! 855: /* {{{ proto string gzencode(string data [, int level [, int encoding_mode]])
! 856: GZ encode a string */
! 857: static PHP_FUNCTION(gzencode)
! 858: {
! 859: char *data, *s2;
! 860: int data_len;
! 861: long level = Z_DEFAULT_COMPRESSION, coding = CODING_GZIP;
! 862: int status;
! 863: z_stream stream;
! 864:
! 865: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &data, &data_len, &level, &coding) == FAILURE) {
! 866: return;
! 867: }
! 868:
! 869: if ((level < -1) || (level > 9)) {
! 870: php_error_docref(NULL TSRMLS_CC, E_WARNING, "compression level(%ld) must be within -1..9", level);
! 871: RETURN_FALSE;
! 872: }
! 873:
! 874: if ((coding != CODING_GZIP) && (coding != CODING_DEFLATE)) {
! 875: php_error_docref(NULL TSRMLS_CC, E_WARNING, "encoding mode must be FORCE_GZIP or FORCE_DEFLATE");
! 876: RETURN_FALSE;
! 877: }
! 878:
! 879: stream.zalloc = php_zlib_alloc;
! 880: stream.zfree = php_zlib_free;
! 881: stream.opaque = Z_NULL;
! 882:
! 883: stream.next_in = (Bytef *) data;
! 884: stream.avail_in = data_len;
! 885:
! 886: stream.avail_out = stream.avail_in + (stream.avail_in / PHP_ZLIB_MODIFIER) + 15 + 1; /* room for \0 */
! 887: s2 = (char *) emalloc(stream.avail_out + GZIP_HEADER_LENGTH + (coding == CODING_GZIP ? GZIP_FOOTER_LENGTH : 0));
! 888:
! 889: /* add gzip file header */
! 890: s2[0] = gz_magic[0];
! 891: s2[1] = gz_magic[1];
! 892: s2[2] = Z_DEFLATED;
! 893: s2[3] = s2[4] = s2[5] = s2[6] = s2[7] = s2[8] = 0; /* time set to 0 */
! 894: s2[9] = OS_CODE;
! 895:
! 896: stream.next_out = &(s2[GZIP_HEADER_LENGTH]);
! 897:
! 898: switch (coding) {
! 899: case CODING_GZIP:
! 900: /* windowBits is passed < 0 to suppress zlib header & trailer */
! 901: if ((status = deflateInit2(&stream, level, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY)) != Z_OK) {
! 902: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", zError(status));
! 903: RETURN_FALSE;
! 904: }
! 905:
! 906: break;
! 907: case CODING_DEFLATE:
! 908: if ((status = deflateInit(&stream, level)) != Z_OK) {
! 909: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", zError(status));
! 910: RETURN_FALSE;
! 911: }
! 912: break;
! 913: }
! 914:
! 915: status = deflate(&stream, Z_FINISH);
! 916: if (status != Z_STREAM_END) {
! 917: deflateEnd(&stream);
! 918: if (status == Z_OK) {
! 919: status = Z_BUF_ERROR;
! 920: }
! 921: } else {
! 922: status = deflateEnd(&stream);
! 923: }
! 924:
! 925: if (status == Z_OK) {
! 926: /* resize to buffer to the "right" size */
! 927: s2 = erealloc(s2, stream.total_out + GZIP_HEADER_LENGTH + (coding == CODING_GZIP ? GZIP_FOOTER_LENGTH : 0) + 1);
! 928:
! 929: if (coding == CODING_GZIP) {
! 930: char *trailer = s2 + (stream.total_out + GZIP_HEADER_LENGTH);
! 931: uLong crc = crc32(0L, Z_NULL, 0);
! 932:
! 933: crc = crc32(crc, (const Bytef *) data, data_len);
! 934:
! 935: /* write crc & stream.total_in in LSB order */
! 936: trailer[0] = (char) crc & 0xFF;
! 937: trailer[1] = (char) (crc >> 8) & 0xFF;
! 938: trailer[2] = (char) (crc >> 16) & 0xFF;
! 939: trailer[3] = (char) (crc >> 24) & 0xFF;
! 940: trailer[4] = (char) stream.total_in & 0xFF;
! 941: trailer[5] = (char) (stream.total_in >> 8) & 0xFF;
! 942: trailer[6] = (char) (stream.total_in >> 16) & 0xFF;
! 943: trailer[7] = (char) (stream.total_in >> 24) & 0xFF;
! 944: trailer[8] = '\0';
! 945: } else {
! 946: s2[stream.total_out + GZIP_HEADER_LENGTH + (coding == CODING_GZIP ? GZIP_FOOTER_LENGTH : 0)] = '\0';
! 947: }
! 948: RETURN_STRINGL(s2, stream.total_out + GZIP_HEADER_LENGTH + (coding == CODING_GZIP ? GZIP_FOOTER_LENGTH : 0), 0);
! 949: } else {
! 950: efree(s2);
! 951: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", zError(status));
! 952: RETURN_FALSE;
! 953: }
! 954: }
! 955: /* }}} */
! 956:
! 957: /* {{{ php_ob_gzhandler_check
! 958: */
! 959: int php_ob_gzhandler_check(TSRMLS_D)
! 960: {
! 961: /* check for wrong usages */
! 962: if (OG(ob_nesting_level > 0)) {
! 963: if (php_ob_handler_used("ob_gzhandler" TSRMLS_CC)) {
! 964: php_error_docref("ref.outcontrol" TSRMLS_CC, E_WARNING, "output handler 'ob_gzhandler' cannot be used twice");
! 965: return FAILURE;
! 966: }
! 967: if (php_ob_handler_used("mb_output_handler" TSRMLS_CC)) {
! 968: php_error_docref("ref.outcontrol" TSRMLS_CC, E_WARNING, "output handler 'ob_gzhandler' cannot be used after 'mb_output_handler'");
! 969: return FAILURE;
! 970: }
! 971: if (php_ob_handler_used("URL-Rewriter" TSRMLS_CC)) {
! 972: php_error_docref("ref.outcontrol" TSRMLS_CC, E_WARNING, "output handler 'ob_gzhandler' cannot be used after 'URL-Rewriter'");
! 973: return FAILURE;
! 974: }
! 975: if (php_ob_init_conflict("ob_gzhandler", "zlib output compression" TSRMLS_CC)) {
! 976: return FAILURE;
! 977: }
! 978: }
! 979:
! 980: return SUCCESS;
! 981: }
! 982:
! 983: /* }}} */
! 984:
! 985: /* {{{ proto string ob_gzhandler(string str, int mode)
! 986: Encode str based on accept-encoding setting - designed to be called from ob_start() */
! 987: static PHP_FUNCTION(ob_gzhandler)
! 988: {
! 989: char *string;
! 990: int string_len;
! 991: long mode;
! 992: zval **a_encoding;
! 993: zend_bool return_original = 0;
! 994: zend_bool do_start, do_end;
! 995:
! 996: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &string, &string_len, &mode) == FAILURE) {
! 997: return;
! 998: }
! 999:
! 1000: if (ZLIBG(ob_gzhandler_status) == -1) {
! 1001: RETURN_FALSE;
! 1002: }
! 1003:
! 1004: zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
! 1005:
! 1006: if (!PG(http_globals)[TRACK_VARS_SERVER]
! 1007: || zend_hash_find(PG(http_globals)[TRACK_VARS_SERVER]->value.ht, "HTTP_ACCEPT_ENCODING", sizeof("HTTP_ACCEPT_ENCODING"), (void **) &a_encoding) == FAILURE
! 1008: ) {
! 1009: ZLIBG(ob_gzhandler_status) = -1;
! 1010: RETURN_FALSE;
! 1011: }
! 1012:
! 1013: convert_to_string_ex(a_encoding);
! 1014: if (php_memnstr(Z_STRVAL_PP(a_encoding), "gzip", 4, Z_STRVAL_PP(a_encoding) + Z_STRLEN_PP(a_encoding))) {
! 1015: ZLIBG(compression_coding) = CODING_GZIP;
! 1016: } else if (php_memnstr(Z_STRVAL_PP(a_encoding), "deflate", 7, Z_STRVAL_PP(a_encoding) + Z_STRLEN_PP(a_encoding))) {
! 1017: ZLIBG(compression_coding) = CODING_DEFLATE;
! 1018: } else {
! 1019: ZLIBG(ob_gzhandler_status) = -1;
! 1020: RETURN_FALSE;
! 1021: }
! 1022:
! 1023: do_start = ((mode & PHP_OUTPUT_HANDLER_START) ? 1 : 0);
! 1024: do_end = ((mode & PHP_OUTPUT_HANDLER_END) ? 1 : 0);
! 1025: Z_STRVAL_P(return_value) = NULL;
! 1026: Z_STRLEN_P(return_value) = 0;
! 1027:
! 1028: if (php_deflate_string(string, string_len, &Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value), do_start, do_end TSRMLS_CC) == SUCCESS) {
! 1029: Z_TYPE_P(return_value) = IS_STRING;
! 1030: if (do_start) {
! 1031: switch (ZLIBG(compression_coding)) {
! 1032: case CODING_GZIP:
! 1033: if (sapi_add_header("Content-Encoding: gzip", sizeof("Content-Encoding: gzip") - 1, 1) == FAILURE) {
! 1034: return_original = 1;
! 1035: }
! 1036: if (sapi_add_header_ex("Vary: Accept-Encoding", sizeof("Vary: Accept-Encoding") - 1, 1, 0 TSRMLS_CC)==FAILURE) {
! 1037: return_original = 1;
! 1038: }
! 1039: break;
! 1040: case CODING_DEFLATE:
! 1041: if (sapi_add_header("Content-Encoding: deflate", sizeof("Content-Encoding: deflate") - 1, 1) == FAILURE) {
! 1042: return_original = 1;
! 1043: }
! 1044: if (sapi_add_header_ex("Vary: Accept-Encoding", sizeof("Vary: Accept-Encoding") - 1, 1, 0 TSRMLS_CC)==FAILURE) {
! 1045: return_original = 1;
! 1046: }
! 1047: break;
! 1048: default:
! 1049: return_original = 1;
! 1050: break;
! 1051: }
! 1052: }
! 1053:
! 1054: if (return_original) {
! 1055: zval_dtor(return_value);
! 1056: }
! 1057:
! 1058: } else {
! 1059: return_original = 1;
! 1060: }
! 1061:
! 1062: if (return_original) {
! 1063: /* return the original string */
! 1064: RETURN_STRINGL(string, string_len, 1);
! 1065: }
! 1066: }
! 1067: /* }}} */
! 1068:
! 1069: /* {{{ php_gzip_output_handler
! 1070: */
! 1071: static void php_gzip_output_handler(char *output, uint output_len, char **handled_output, uint *handled_output_len, int mode TSRMLS_DC)
! 1072: {
! 1073: zend_bool do_start, do_end;
! 1074:
! 1075: if (!ZLIBG(output_compression) || SG(sapi_headers).http_response_code == 204 || SG(sapi_headers).http_response_code == 304) {
! 1076: *handled_output = NULL;
! 1077: } else {
! 1078: do_start = (mode & PHP_OUTPUT_HANDLER_START ? 1 : 0);
! 1079: do_end = (mode & PHP_OUTPUT_HANDLER_END ? 1 : 0);
! 1080:
! 1081: if (do_start) {
! 1082: if (!SG(headers_sent) && !SG(request_info).no_headers) {
! 1083: switch (ZLIBG(compression_coding)) {
! 1084: case CODING_GZIP:
! 1085: sapi_add_header_ex(ZEND_STRL("Content-Encoding: gzip"), 1, 1 TSRMLS_CC);
! 1086: break;
! 1087: case CODING_DEFLATE:
! 1088: sapi_add_header_ex(ZEND_STRL("Content-Encoding: deflate"), 1, 1 TSRMLS_CC);
! 1089: break;
! 1090: }
! 1091: sapi_add_header_ex(ZEND_STRL("Vary: Accept-Encoding"), 1, 0 TSRMLS_CC);
! 1092: } else {
! 1093: /* Disable compression if headers can not be set (Fix for bug #49816) */
! 1094: ZLIBG(output_compression) = 0;
! 1095: *handled_output = NULL;
! 1096: return;
! 1097: }
! 1098: }
! 1099:
! 1100: if (php_deflate_string(output, output_len, handled_output, handled_output_len, do_start, do_end TSRMLS_CC) != SUCCESS) {
! 1101: zend_error(E_ERROR, "Compression failed");
! 1102: }
! 1103: }
! 1104: }
! 1105: /* }}} */
! 1106:
! 1107: /* {{{ php_enable_output_compression
! 1108: */
! 1109: static int php_enable_output_compression(int buffer_size TSRMLS_DC)
! 1110: {
! 1111: zval **a_encoding;
! 1112:
! 1113: zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
! 1114:
! 1115: if (!PG(http_globals)[TRACK_VARS_SERVER]
! 1116: || zend_hash_find(PG(http_globals)[TRACK_VARS_SERVER]->value.ht, "HTTP_ACCEPT_ENCODING", sizeof("HTTP_ACCEPT_ENCODING"), (void **) &a_encoding) == FAILURE
! 1117: ) {
! 1118: return FAILURE;
! 1119: }
! 1120:
! 1121: convert_to_string_ex(a_encoding);
! 1122:
! 1123: if (php_memnstr(Z_STRVAL_PP(a_encoding), "gzip", 4, Z_STRVAL_PP(a_encoding) + Z_STRLEN_PP(a_encoding))) {
! 1124: ZLIBG(compression_coding) = CODING_GZIP;
! 1125: } else if (php_memnstr(Z_STRVAL_PP(a_encoding), "deflate", 7, Z_STRVAL_PP(a_encoding) + Z_STRLEN_PP(a_encoding))) {
! 1126: ZLIBG(compression_coding) = CODING_DEFLATE;
! 1127: } else {
! 1128: return FAILURE;
! 1129: }
! 1130:
! 1131: php_ob_set_internal_handler(php_gzip_output_handler, (uint)buffer_size, "zlib output compression", 0 TSRMLS_CC);
! 1132:
! 1133: if (ZLIBG(output_handler) && strlen(ZLIBG(output_handler))) {
! 1134: php_start_ob_buffer_named(ZLIBG(output_handler), 0, 1 TSRMLS_CC);
! 1135: }
! 1136: return SUCCESS;
! 1137: }
! 1138: /* }}} */
! 1139:
! 1140: /* {{{ php_zlib_output_compression_start() */
! 1141: static int php_zlib_output_compression_start(TSRMLS_D)
! 1142: {
! 1143: switch (ZLIBG(output_compression)) {
! 1144: case 0:
! 1145: break;
! 1146: case 1:
! 1147: ZLIBG(output_compression) = 4096;
! 1148: /* break omitted intentionally */
! 1149: default:
! 1150: /* ZLIBG(compression_coding) should be 0 when zlib compression hasn't been started yet.. */
! 1151: if (ZLIBG(compression_coding) == 0) {
! 1152: return php_enable_output_compression(ZLIBG(output_compression) TSRMLS_CC);
! 1153: }
! 1154: }
! 1155: return SUCCESS;
! 1156: }
! 1157: /* }}} */
! 1158:
! 1159: /*
! 1160: * Local variables:
! 1161: * tab-width: 4
! 1162: * c-basic-offset: 4
! 1163: * End:
! 1164: * vim600: sw=4 ts=4 fdm=marker
! 1165: * vim<600: sw=4 ts=4
! 1166: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zlib.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / zlib