Annotation of embedaddon/php/ext/bz2/bz2.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: | Author: Sterling Hughes <sterling@php.net> |
! 16: +----------------------------------------------------------------------+
! 17: */
! 18:
! 19: /* $Id: bz2.c 321634 2012-01-01 13:15:04Z felipe $ */
! 20:
! 21: #ifdef HAVE_CONFIG_H
! 22: #include "config.h"
! 23: #endif
! 24:
! 25: #include "php.h"
! 26: #include "php_bz2.h"
! 27:
! 28: #if HAVE_BZ2
! 29:
! 30: /* PHP Includes */
! 31: #include "ext/standard/file.h"
! 32: #include "ext/standard/info.h"
! 33: #include "ext/standard/php_string.h"
! 34:
! 35: /* for fileno() */
! 36: #include <stdio.h>
! 37:
! 38: /* Internal error constants */
! 39: #define PHP_BZ_ERRNO 0
! 40: #define PHP_BZ_ERRSTR 1
! 41: #define PHP_BZ_ERRBOTH 2
! 42:
! 43: static PHP_MINIT_FUNCTION(bz2);
! 44: static PHP_MSHUTDOWN_FUNCTION(bz2);
! 45: static PHP_MINFO_FUNCTION(bz2);
! 46: static PHP_FUNCTION(bzopen);
! 47: static PHP_FUNCTION(bzread);
! 48: static PHP_FUNCTION(bzerrno);
! 49: static PHP_FUNCTION(bzerrstr);
! 50: static PHP_FUNCTION(bzerror);
! 51: static PHP_FUNCTION(bzcompress);
! 52: static PHP_FUNCTION(bzdecompress);
! 53:
! 54: /* {{{ arginfo */
! 55: ZEND_BEGIN_ARG_INFO_EX(arginfo_bzread, 0, 0, 1)
! 56: ZEND_ARG_INFO(0, bz)
! 57: ZEND_ARG_INFO(0, length)
! 58: ZEND_END_ARG_INFO()
! 59:
! 60: ZEND_BEGIN_ARG_INFO(arginfo_bzopen, 0)
! 61: ZEND_ARG_INFO(0, file)
! 62: ZEND_ARG_INFO(0, mode)
! 63: ZEND_END_ARG_INFO()
! 64:
! 65: ZEND_BEGIN_ARG_INFO(arginfo_bzerrno, 0)
! 66: ZEND_ARG_INFO(0, bz)
! 67: ZEND_END_ARG_INFO()
! 68:
! 69: ZEND_BEGIN_ARG_INFO(arginfo_bzerrstr, 0)
! 70: ZEND_ARG_INFO(0, bz)
! 71: ZEND_END_ARG_INFO()
! 72:
! 73: ZEND_BEGIN_ARG_INFO(arginfo_bzerror, 0)
! 74: ZEND_ARG_INFO(0, bz)
! 75: ZEND_END_ARG_INFO()
! 76:
! 77: ZEND_BEGIN_ARG_INFO_EX(arginfo_bzcompress, 0, 0, 2)
! 78: ZEND_ARG_INFO(0, source)
! 79: ZEND_ARG_INFO(0, blocksize)
! 80: ZEND_ARG_INFO(0, workfactor)
! 81: ZEND_END_ARG_INFO()
! 82:
! 83: ZEND_BEGIN_ARG_INFO_EX(arginfo_bzdecompress, 0, 0, 1)
! 84: ZEND_ARG_INFO(0, source)
! 85: ZEND_ARG_INFO(0, small)
! 86: ZEND_END_ARG_INFO()
! 87:
! 88: ZEND_BEGIN_ARG_INFO_EX(arginfo_bzwrite, 0, 0, 2)
! 89: ZEND_ARG_INFO(0, fp)
! 90: ZEND_ARG_INFO(0, str)
! 91: ZEND_ARG_INFO(0, length)
! 92: ZEND_END_ARG_INFO()
! 93:
! 94: ZEND_BEGIN_ARG_INFO(arginfo_bzflush, 0)
! 95: ZEND_ARG_INFO(0, fp)
! 96: ZEND_END_ARG_INFO()
! 97: /* }}} */
! 98:
! 99: static const zend_function_entry bz2_functions[] = {
! 100: PHP_FE(bzopen, arginfo_bzopen)
! 101: PHP_FE(bzread, arginfo_bzread)
! 102: PHP_FALIAS(bzwrite, fwrite, arginfo_bzwrite)
! 103: PHP_FALIAS(bzflush, fflush, arginfo_bzflush)
! 104: PHP_FALIAS(bzclose, fclose, arginfo_bzflush)
! 105: PHP_FE(bzerrno, arginfo_bzerrno)
! 106: PHP_FE(bzerrstr, arginfo_bzerrstr)
! 107: PHP_FE(bzerror, arginfo_bzerror)
! 108: PHP_FE(bzcompress, arginfo_bzcompress)
! 109: PHP_FE(bzdecompress, arginfo_bzdecompress)
! 110: PHP_FE_END
! 111: };
! 112:
! 113: zend_module_entry bz2_module_entry = {
! 114: STANDARD_MODULE_HEADER,
! 115: "bz2",
! 116: bz2_functions,
! 117: PHP_MINIT(bz2),
! 118: PHP_MSHUTDOWN(bz2),
! 119: NULL,
! 120: NULL,
! 121: PHP_MINFO(bz2),
! 122: NO_VERSION_YET,
! 123: STANDARD_MODULE_PROPERTIES
! 124: };
! 125:
! 126: #ifdef COMPILE_DL_BZ2
! 127: ZEND_GET_MODULE(bz2)
! 128: #endif
! 129:
! 130: struct php_bz2_stream_data_t {
! 131: BZFILE *bz_file;
! 132: php_stream *stream;
! 133: };
! 134:
! 135: /* {{{ BZip2 stream implementation */
! 136:
! 137: static size_t php_bz2iop_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
! 138: {
! 139: struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *) stream->abstract;
! 140: size_t ret;
! 141:
! 142: ret = BZ2_bzread(self->bz_file, buf, count);
! 143:
! 144: if (ret == 0) {
! 145: stream->eof = 1;
! 146: }
! 147:
! 148: return ret;
! 149: }
! 150:
! 151: static size_t php_bz2iop_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
! 152: {
! 153: struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *) stream->abstract;
! 154:
! 155: return BZ2_bzwrite(self->bz_file, (char*)buf, count);
! 156: }
! 157:
! 158: static int php_bz2iop_close(php_stream *stream, int close_handle TSRMLS_DC)
! 159: {
! 160: struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
! 161: int ret = EOF;
! 162:
! 163: if (close_handle) {
! 164: BZ2_bzclose(self->bz_file);
! 165: }
! 166:
! 167: if (self->stream) {
! 168: php_stream_free(self->stream, PHP_STREAM_FREE_CLOSE | (close_handle == 0 ? PHP_STREAM_FREE_PRESERVE_HANDLE : 0));
! 169: }
! 170:
! 171: efree(self);
! 172:
! 173: return ret;
! 174: }
! 175:
! 176: static int php_bz2iop_flush(php_stream *stream TSRMLS_DC)
! 177: {
! 178: struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
! 179: return BZ2_bzflush(self->bz_file);
! 180: }
! 181: /* }}} */
! 182:
! 183: php_stream_ops php_stream_bz2io_ops = {
! 184: php_bz2iop_write, php_bz2iop_read,
! 185: php_bz2iop_close, php_bz2iop_flush,
! 186: "BZip2",
! 187: NULL, /* seek */
! 188: NULL, /* cast */
! 189: NULL, /* stat */
! 190: NULL /* set_option */
! 191: };
! 192:
! 193: /* {{{ Bzip2 stream openers */
! 194: PHP_BZ2_API php_stream *_php_stream_bz2open_from_BZFILE(BZFILE *bz,
! 195: char *mode, php_stream *innerstream STREAMS_DC TSRMLS_DC)
! 196: {
! 197: struct php_bz2_stream_data_t *self;
! 198:
! 199: self = emalloc(sizeof(*self));
! 200:
! 201: self->stream = innerstream;
! 202: self->bz_file = bz;
! 203:
! 204: return php_stream_alloc_rel(&php_stream_bz2io_ops, self, 0, mode);
! 205: }
! 206:
! 207: PHP_BZ2_API php_stream *_php_stream_bz2open(php_stream_wrapper *wrapper,
! 208: char *path,
! 209: char *mode,
! 210: int options,
! 211: char **opened_path,
! 212: php_stream_context *context STREAMS_DC TSRMLS_DC)
! 213: {
! 214: php_stream *retstream = NULL, *stream = NULL;
! 215: char *path_copy = NULL;
! 216: BZFILE *bz_file = NULL;
! 217:
! 218: if (strncasecmp("compress.bzip2://", path, 17) == 0) {
! 219: path += 17;
! 220: }
! 221: if (mode[0] == '\0' || (mode[0] != 'w' && mode[0] != 'r' && mode[1] != '\0')) {
! 222: return NULL;
! 223: }
! 224:
! 225: #ifdef VIRTUAL_DIR
! 226: virtual_filepath_ex(path, &path_copy, NULL TSRMLS_CC);
! 227: #else
! 228: path_copy = path;
! 229: #endif
! 230:
! 231: if ((PG(safe_mode) && (!php_checkuid(path_copy, NULL, CHECKUID_CHECK_FILE_AND_DIR))) || php_check_open_basedir(path_copy TSRMLS_CC)) {
! 232: return NULL;
! 233: }
! 234:
! 235: /* try and open it directly first */
! 236: bz_file = BZ2_bzopen(path_copy, mode);
! 237:
! 238: if (opened_path && bz_file) {
! 239: *opened_path = estrdup(path_copy);
! 240: }
! 241: path_copy = NULL;
! 242:
! 243: if (bz_file == NULL) {
! 244: /* that didn't work, so try and get something from the network/wrapper */
! 245: stream = php_stream_open_wrapper(path, mode, options | STREAM_WILL_CAST | ENFORCE_SAFE_MODE, opened_path);
! 246:
! 247: if (stream) {
! 248: int fd;
! 249: if (SUCCESS == php_stream_cast(stream, PHP_STREAM_AS_FD, (void **) &fd, REPORT_ERRORS)) {
! 250: bz_file = BZ2_bzdopen(fd, mode);
! 251: }
! 252: }
! 253:
! 254: /* remove the file created by php_stream_open_wrapper(), it is not needed since BZ2 functions
! 255: * failed.
! 256: */
! 257: if (opened_path && !bz_file && mode[0] == 'w') {
! 258: VCWD_UNLINK(*opened_path);
! 259: }
! 260: }
! 261:
! 262: if (bz_file) {
! 263: retstream = _php_stream_bz2open_from_BZFILE(bz_file, mode, stream STREAMS_REL_CC TSRMLS_CC);
! 264: if (retstream) {
! 265: return retstream;
! 266: }
! 267:
! 268: BZ2_bzclose(bz_file);
! 269: }
! 270:
! 271: if (stream) {
! 272: php_stream_close(stream);
! 273: }
! 274:
! 275: return NULL;
! 276: }
! 277:
! 278: /* }}} */
! 279:
! 280: static php_stream_wrapper_ops bzip2_stream_wops = {
! 281: _php_stream_bz2open,
! 282: NULL, /* close */
! 283: NULL, /* fstat */
! 284: NULL, /* stat */
! 285: NULL, /* opendir */
! 286: "BZip2",
! 287: NULL, /* unlink */
! 288: NULL, /* rename */
! 289: NULL, /* mkdir */
! 290: NULL /* rmdir */
! 291: };
! 292:
! 293: static php_stream_wrapper php_stream_bzip2_wrapper = {
! 294: &bzip2_stream_wops,
! 295: NULL,
! 296: 0 /* is_url */
! 297: };
! 298:
! 299: static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int);
! 300:
! 301: static PHP_MINIT_FUNCTION(bz2)
! 302: {
! 303: php_register_url_stream_wrapper("compress.bzip2", &php_stream_bzip2_wrapper TSRMLS_CC);
! 304: php_stream_filter_register_factory("bzip2.*", &php_bz2_filter_factory TSRMLS_CC);
! 305: return SUCCESS;
! 306: }
! 307:
! 308: static PHP_MSHUTDOWN_FUNCTION(bz2)
! 309: {
! 310: php_unregister_url_stream_wrapper("compress.bzip2" TSRMLS_CC);
! 311: php_stream_filter_unregister_factory("bzip2.*" TSRMLS_CC);
! 312:
! 313: return SUCCESS;
! 314: }
! 315:
! 316: static PHP_MINFO_FUNCTION(bz2)
! 317: {
! 318: php_info_print_table_start();
! 319: php_info_print_table_row(2, "BZip2 Support", "Enabled");
! 320: php_info_print_table_row(2, "Stream Wrapper support", "compress.bzip2://");
! 321: php_info_print_table_row(2, "Stream Filter support", "bzip2.decompress, bzip2.compress");
! 322: php_info_print_table_row(2, "BZip2 Version", (char *) BZ2_bzlibVersion());
! 323: php_info_print_table_end();
! 324: }
! 325:
! 326: /* {{{ proto string bzread(resource bz[, int length])
! 327: Reads up to length bytes from a BZip2 stream, or 1024 bytes if length is not specified */
! 328: static PHP_FUNCTION(bzread)
! 329: {
! 330: zval *bz;
! 331: long len = 1024;
! 332: php_stream *stream;
! 333:
! 334: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &bz, &len)) {
! 335: RETURN_FALSE;
! 336: }
! 337:
! 338: php_stream_from_zval(stream, &bz);
! 339:
! 340: if ((len + 1) < 1) {
! 341: php_error_docref(NULL TSRMLS_CC, E_WARNING, "length may not be negative");
! 342: RETURN_FALSE;
! 343: }
! 344:
! 345: Z_STRVAL_P(return_value) = emalloc(len + 1);
! 346: Z_STRLEN_P(return_value) = php_stream_read(stream, Z_STRVAL_P(return_value), len);
! 347:
! 348: if (Z_STRLEN_P(return_value) < 0) {
! 349: efree(Z_STRVAL_P(return_value));
! 350: php_error_docref(NULL TSRMLS_CC, E_WARNING, "could not read valid bz2 data from stream");
! 351: RETURN_FALSE;
! 352: }
! 353:
! 354: Z_STRVAL_P(return_value)[Z_STRLEN_P(return_value)] = 0;
! 355:
! 356: if (PG(magic_quotes_runtime)) {
! 357: Z_STRVAL_P(return_value) = php_addslashes( Z_STRVAL_P(return_value),
! 358: Z_STRLEN_P(return_value),
! 359: &Z_STRLEN_P(return_value), 1 TSRMLS_CC);
! 360: }
! 361:
! 362: Z_TYPE_P(return_value) = IS_STRING;
! 363: }
! 364: /* }}} */
! 365:
! 366: /* {{{ proto resource bzopen(string|int file|fp, string mode)
! 367: Opens a new BZip2 stream */
! 368: static PHP_FUNCTION(bzopen)
! 369: {
! 370: zval **file; /* The file to open */
! 371: char *mode; /* The mode to open the stream with */
! 372: int mode_len;
! 373:
! 374: BZFILE *bz; /* The compressed file stream */
! 375: php_stream *stream = NULL;
! 376:
! 377: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zs", &file, &mode, &mode_len) == FAILURE) {
! 378: return;
! 379: }
! 380:
! 381: if (mode_len != 1 || (mode[0] != 'r' && mode[0] != 'w')) {
! 382: php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid mode for bzopen(). Only 'w' and 'r' are supported.", mode);
! 383: RETURN_FALSE;
! 384: }
! 385:
! 386: /* If it's not a resource its a string containing the filename to open */
! 387: if (Z_TYPE_PP(file) == IS_STRING) {
! 388: convert_to_string_ex(file);
! 389:
! 390: if (strlen(Z_STRVAL_PP(file)) != Z_STRLEN_PP(file)) {
! 391: RETURN_FALSE;
! 392: }
! 393: if (Z_STRLEN_PP(file) == 0) {
! 394: php_error_docref(NULL TSRMLS_CC, E_WARNING, "filename cannot be empty");
! 395: RETURN_FALSE;
! 396: }
! 397:
! 398: stream = php_stream_bz2open(NULL,
! 399: Z_STRVAL_PP(file),
! 400: mode,
! 401: ENFORCE_SAFE_MODE | REPORT_ERRORS,
! 402: NULL);
! 403: } else if (Z_TYPE_PP(file) == IS_RESOURCE) {
! 404: /* If it is a resource, than its a stream resource */
! 405: int fd;
! 406: int stream_mode_len;
! 407:
! 408: php_stream_from_zval(stream, file);
! 409: stream_mode_len = strlen(stream->mode);
! 410:
! 411: if (stream_mode_len != 1 && !(stream_mode_len == 2 && memchr(stream->mode, 'b', 2))) {
! 412: php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot use stream opened in mode '%s'", stream->mode);
! 413: RETURN_FALSE;
! 414: } else if (stream_mode_len == 1 && stream->mode[0] != 'r' && stream->mode[0] != 'w' && stream->mode[0] != 'a' && stream->mode[0] != 'x') {
! 415: php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot use stream opened in mode '%s'", stream->mode);
! 416: RETURN_FALSE;
! 417: }
! 418:
! 419: switch(mode[0]) {
! 420: case 'r':
! 421: /* only "r" and "rb" are supported */
! 422: if (stream->mode[0] != mode[0] && !(stream_mode_len == 2 && stream->mode[1] != mode[0])) {
! 423: php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot read from a stream opened in write only mode");
! 424: RETURN_FALSE;
! 425: }
! 426: break;
! 427: case 'w':
! 428: /* support only "w"(b), "a"(b), "x"(b) */
! 429: if (stream->mode[0] != mode[0] && !(stream_mode_len == 2 && stream->mode[1] != mode[0])
! 430: && stream->mode[0] != 'a' && !(stream_mode_len == 2 && stream->mode[1] != 'a')
! 431: && stream->mode[0] != 'x' && !(stream_mode_len == 2 && stream->mode[1] != 'x')) {
! 432: php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot write to a stream opened in read only mode");
! 433: RETURN_FALSE;
! 434: }
! 435: break;
! 436: default:
! 437: /* not reachable */
! 438: break;
! 439: }
! 440:
! 441: if (FAILURE == php_stream_cast(stream, PHP_STREAM_AS_FD, (void *) &fd, REPORT_ERRORS)) {
! 442: RETURN_FALSE;
! 443: }
! 444:
! 445: bz = BZ2_bzdopen(fd, mode);
! 446:
! 447: stream = php_stream_bz2open_from_BZFILE(bz, mode, stream);
! 448: } else {
! 449: php_error_docref(NULL TSRMLS_CC, E_WARNING, "first parameter has to be string or file-resource");
! 450: RETURN_FALSE;
! 451: }
! 452:
! 453: if (stream) {
! 454: php_stream_to_zval(stream, return_value);
! 455: } else {
! 456: RETURN_FALSE;
! 457: }
! 458: }
! 459: /* }}} */
! 460:
! 461: /* {{{ proto int bzerrno(resource bz)
! 462: Returns the error number */
! 463: static PHP_FUNCTION(bzerrno)
! 464: {
! 465: php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRNO);
! 466: }
! 467: /* }}} */
! 468:
! 469: /* {{{ proto string bzerrstr(resource bz)
! 470: Returns the error string */
! 471: static PHP_FUNCTION(bzerrstr)
! 472: {
! 473: php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRSTR);
! 474: }
! 475: /* }}} */
! 476:
! 477: /* {{{ proto array bzerror(resource bz)
! 478: Returns the error number and error string in an associative array */
! 479: static PHP_FUNCTION(bzerror)
! 480: {
! 481: php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRBOTH);
! 482: }
! 483: /* }}} */
! 484:
! 485: /* {{{ proto string bzcompress(string source [, int blocksize100k [, int workfactor]])
! 486: Compresses a string into BZip2 encoded data */
! 487: static PHP_FUNCTION(bzcompress)
! 488: {
! 489: char *source; /* Source data to compress */
! 490: long zblock_size = 0; /* Optional block size to use */
! 491: long zwork_factor = 0;/* Optional work factor to use */
! 492: char *dest = NULL; /* Destination to place the compressed data into */
! 493: int error, /* Error Container */
! 494: block_size = 4, /* Block size for compression algorithm */
! 495: work_factor = 0, /* Work factor for compression algorithm */
! 496: argc; /* Argument count */
! 497: int source_len; /* Length of the source data */
! 498: unsigned int dest_len; /* Length of the destination buffer */
! 499:
! 500: argc = ZEND_NUM_ARGS();
! 501:
! 502: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &source, &source_len, &zblock_size, &zwork_factor) == FAILURE) {
! 503: return;
! 504: }
! 505:
! 506: /* Assign them to easy to use variables, dest_len is initially the length of the data
! 507: + .01 x length of data + 600 which is the largest size the results of the compression
! 508: could possibly be, at least that's what the libbz2 docs say (thanks to jeremy@nirvani.net
! 509: for pointing this out). */
! 510: dest_len = (unsigned int) (source_len + (0.01 * source_len) + 600);
! 511:
! 512: /* Allocate the destination buffer */
! 513: dest = emalloc(dest_len + 1);
! 514:
! 515: /* Handle the optional arguments */
! 516: if (argc > 1) {
! 517: block_size = zblock_size;
! 518: }
! 519:
! 520: if (argc > 2) {
! 521: work_factor = zwork_factor;
! 522: }
! 523:
! 524: error = BZ2_bzBuffToBuffCompress(dest, &dest_len, source, source_len, block_size, 0, work_factor);
! 525: if (error != BZ_OK) {
! 526: efree(dest);
! 527: RETURN_LONG(error);
! 528: } else {
! 529: /* Copy the buffer, we have perhaps allocate alot more than we need,
! 530: so we erealloc() the buffer to the proper size */
! 531: dest = erealloc(dest, dest_len + 1);
! 532: dest[dest_len] = 0;
! 533: RETURN_STRINGL(dest, dest_len, 0);
! 534: }
! 535: }
! 536: /* }}} */
! 537:
! 538: /* {{{ proto string bzdecompress(string source [, int small])
! 539: Decompresses BZip2 compressed data */
! 540: static PHP_FUNCTION(bzdecompress)
! 541: {
! 542: char *source, *dest;
! 543: int source_len, error;
! 544: long small = 0;
! 545: #if defined(PHP_WIN32)
! 546: unsigned __int64 size = 0;
! 547: #else
! 548: unsigned long long size = 0;
! 549: #endif
! 550: bz_stream bzs;
! 551:
! 552: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &source, &source_len, &small)) {
! 553: RETURN_FALSE;
! 554: }
! 555:
! 556: bzs.bzalloc = NULL;
! 557: bzs.bzfree = NULL;
! 558:
! 559: if (BZ2_bzDecompressInit(&bzs, 0, small) != BZ_OK) {
! 560: RETURN_FALSE;
! 561: }
! 562:
! 563: bzs.next_in = source;
! 564: bzs.avail_in = source_len;
! 565:
! 566: /* in most cases bz2 offers at least 2:1 compression, so we use that as our base */
! 567: bzs.avail_out = source_len * 2;
! 568: bzs.next_out = dest = emalloc(bzs.avail_out + 1);
! 569:
! 570: while ((error = BZ2_bzDecompress(&bzs)) == BZ_OK && bzs.avail_in > 0) {
! 571: /* compression is better then 2:1, need to allocate more memory */
! 572: bzs.avail_out = source_len;
! 573: size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
! 574: dest = safe_erealloc(dest, 1, bzs.avail_out+1, (size_t) size );
! 575: bzs.next_out = dest + size;
! 576: }
! 577:
! 578: if (error == BZ_STREAM_END || error == BZ_OK) {
! 579: size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
! 580: dest = safe_erealloc(dest, 1, (size_t) size, 1);
! 581: dest[size] = '\0';
! 582: RETVAL_STRINGL(dest, (int) size, 0);
! 583: } else { /* real error */
! 584: efree(dest);
! 585: RETVAL_LONG(error);
! 586: }
! 587:
! 588: BZ2_bzDecompressEnd(&bzs);
! 589: }
! 590: /* }}} */
! 591:
! 592: /* {{{ php_bz2_error()
! 593: The central error handling interface, does the work for bzerrno, bzerrstr and bzerror */
! 594: static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int opt)
! 595: {
! 596: zval *bzp; /* BZip2 Resource Pointer */
! 597: php_stream *stream;
! 598: const char *errstr; /* Error string */
! 599: int errnum; /* Error number */
! 600: struct php_bz2_stream_data_t *self;
! 601:
! 602: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &bzp) == FAILURE) {
! 603: return;
! 604: }
! 605:
! 606: php_stream_from_zval(stream, &bzp);
! 607:
! 608: if (!php_stream_is(stream, PHP_STREAM_IS_BZIP2)) {
! 609: RETURN_FALSE;
! 610: }
! 611:
! 612: self = (struct php_bz2_stream_data_t *) stream->abstract;
! 613:
! 614: /* Fetch the error information */
! 615: errstr = BZ2_bzerror(self->bz_file, &errnum);
! 616:
! 617: /* Determine what to return */
! 618: switch (opt) {
! 619: case PHP_BZ_ERRNO:
! 620: RETURN_LONG(errnum);
! 621: break;
! 622: case PHP_BZ_ERRSTR:
! 623: RETURN_STRING((char*)errstr, 1);
! 624: break;
! 625: case PHP_BZ_ERRBOTH:
! 626: array_init(return_value);
! 627:
! 628: add_assoc_long (return_value, "errno", errnum);
! 629: add_assoc_string(return_value, "errstr", (char*)errstr, 1);
! 630: break;
! 631: }
! 632: }
! 633: /* }}} */
! 634:
! 635: #endif
! 636:
! 637: /*
! 638: * Local variables:
! 639: * tab-width: 4
! 640: * c-basic-offset: 4
! 641: * End:
! 642: * vim600: fdm=marker
! 643: * vim: noet sw=4 ts=4
! 644: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bz2.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 / bz2