ext/bz2/bz2.c

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

DEFINITIONS
