PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/bz2 - bz2.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 192 212 90.6 %
Date: 2015-06-27 Functions: 17 17 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :   +----------------------------------------------------------------------+
       3             :   | PHP Version 7                                                        |
       4             :   +----------------------------------------------------------------------+
       5             :   | Copyright (c) 1997-2015 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          10 : static size_t php_bz2iop_read(php_stream *stream, char *buf, size_t count)
     139             : {
     140          10 :         struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
     141          10 :         size_t ret = 0;
     142             : 
     143             :         do {
     144             :                 int just_read;
     145          13 :                 size_t remain = count - ret;
     146          13 :                 int to_read = (int)(remain <= INT_MAX ? remain : INT_MAX);
     147             : 
     148          13 :                 just_read = BZ2_bzread(self->bz_file, buf, to_read);
     149             : 
     150          13 :                 if (just_read < 1) {
     151          10 :                         stream->eof = 0 == just_read;
     152          10 :                         break;
     153             :                 }
     154             : 
     155           3 :                 ret += just_read;
     156           3 :         } while (ret < count);
     157             : 
     158          10 :         return ret;
     159             : }
     160             : 
     161          15 : static size_t php_bz2iop_write(php_stream *stream, const char *buf, size_t count)
     162             : {
     163          15 :         size_t wrote = 0;
     164          15 :         struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
     165             : 
     166             : 
     167             :         do {
     168             :                 int just_wrote;
     169          15 :                 size_t remain = count - wrote;
     170          15 :                 int to_write = (int)(remain <= INT_MAX ? remain : INT_MAX);
     171             : 
     172          15 :                 just_wrote = BZ2_bzwrite(self->bz_file, (char*)buf, to_write);
     173             : 
     174          15 :                 if (just_wrote < 1) {
     175           0 :                         break;
     176             :                 }
     177             : 
     178          15 :                 wrote += just_wrote;
     179             : 
     180          15 :         } while (wrote < count);
     181             : 
     182          15 :         return wrote;
     183             : }
     184             : 
     185          16 : static int php_bz2iop_close(php_stream *stream, int close_handle)
     186             : {
     187          16 :         struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
     188          16 :         int ret = EOF;
     189             : 
     190          16 :         if (close_handle) {
     191          16 :                 BZ2_bzclose(self->bz_file);
     192             :         }
     193             : 
     194          16 :         if (self->stream) {
     195           7 :                 php_stream_free(self->stream, PHP_STREAM_FREE_CLOSE | (close_handle == 0 ? PHP_STREAM_FREE_PRESERVE_HANDLE : 0));
     196             :         }
     197             : 
     198          16 :         efree(self);
     199             : 
     200          16 :         return ret;
     201             : }
     202             : 
     203          16 : static int php_bz2iop_flush(php_stream *stream)
     204             : {
     205          16 :         struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
     206          16 :         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          16 : 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          16 :         self = emalloc(sizeof(*self));
     227             : 
     228          16 :         self->stream = innerstream;
     229          16 :         if (innerstream) {
     230           7 :                 GC_REFCOUNT(innerstream->res)++;
     231             :         }
     232          16 :         self->bz_file = bz;
     233             : 
     234          16 :         return php_stream_alloc_rel(&php_stream_bz2io_ops, self, 0, mode);
     235             : }
     236             : 
     237          10 : 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          10 :         php_stream *retstream = NULL, *stream = NULL;
     245          10 :         char *path_copy = NULL;
     246          10 :         BZFILE *bz_file = NULL;
     247             : 
     248          10 :         if (strncasecmp("compress.bzip2://", path, 17) == 0) {
     249           0 :                 path += 17;
     250             :         }
     251          10 :         if (mode[0] == '\0' || (mode[0] != 'w' && mode[0] != 'r' && mode[1] != '\0')) {
     252           0 :                 return NULL;
     253             :         }
     254             : 
     255             : #ifdef VIRTUAL_DIR
     256             :         virtual_filepath_ex(path, &path_copy, NULL);
     257             : #else
     258          10 :         path_copy = (char *)path;
     259             : #endif
     260             : 
     261          10 :         if (php_check_open_basedir(path_copy)) {
     262             : #ifdef VIRTUAL_DIR
     263             :                 efree(path_copy);
     264             : #endif
     265           0 :                 return NULL;
     266             :         }
     267             : 
     268             :         /* try and open it directly first */
     269          10 :         bz_file = BZ2_bzopen(path_copy, mode);
     270             : 
     271          10 :         if (opened_path && bz_file) {
     272           0 :                 *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          10 :         if (bz_file == NULL) {
     280             :                 /* that didn't work, so try and get something from the network/wrapper */
     281           1 :                 stream = php_stream_open_wrapper(path, mode, options | STREAM_WILL_CAST, opened_path);
     282             : 
     283           1 :                 if (stream) {
     284             :                         php_socket_t fd;
     285           0 :                         if (SUCCESS == php_stream_cast(stream, PHP_STREAM_AS_FD, (void **) &fd, REPORT_ERRORS)) {
     286           0 :                                 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           1 :                 if (opened_path && !bz_file && mode[0] == 'w') {
     294           0 :                         VCWD_UNLINK((*opened_path)->val);
     295             :                 }
     296             :         }
     297             : 
     298          10 :         if (bz_file) {
     299           9 :                 retstream = _php_stream_bz2open_from_BZFILE(bz_file, mode, stream STREAMS_REL_CC);
     300           9 :                 if (retstream) {
     301           9 :                         return retstream;
     302             :                 }
     303             : 
     304           0 :                 BZ2_bzclose(bz_file);
     305             :         }
     306             : 
     307           1 :         if (stream) {
     308           0 :                 php_stream_close(stream);
     309             :         }
     310             : 
     311           1 :         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       21049 : static PHP_MINIT_FUNCTION(bz2)
     338             : {
     339       21049 :         php_register_url_stream_wrapper("compress.bzip2", &php_stream_bzip2_wrapper);
     340       21049 :         php_stream_filter_register_factory("bzip2.*", &php_bz2_filter_factory);
     341       21049 :         return SUCCESS;
     342             : }
     343             : 
     344       21085 : static PHP_MSHUTDOWN_FUNCTION(bz2)
     345             : {
     346       21085 :         php_unregister_url_stream_wrapper("compress.bzip2");
     347       21085 :         php_stream_filter_unregister_factory("bzip2.*");
     348             : 
     349       21085 :         return SUCCESS;
     350             : }
     351             : 
     352         142 : static PHP_MINFO_FUNCTION(bz2)
     353             : {
     354         142 :         php_info_print_table_start();
     355         142 :         php_info_print_table_row(2, "BZip2 Support", "Enabled");
     356         142 :         php_info_print_table_row(2, "Stream Wrapper support", "compress.bzip2://");
     357         142 :         php_info_print_table_row(2, "Stream Filter support", "bzip2.decompress, bzip2.compress");
     358         142 :         php_info_print_table_row(2, "BZip2 Version", (char *) BZ2_bzlibVersion());
     359         142 :         php_info_print_table_end();
     360         142 : }
     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          16 : static PHP_FUNCTION(bzread)
     365             : {
     366             :         zval *bz;
     367          16 :         zend_long len = 1024;
     368             :         php_stream *stream;
     369             :         zend_string *data;
     370             : 
     371          16 :         if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "r|l", &bz, &len)) {
     372           2 :                 RETURN_FALSE;
     373             :         }
     374             : 
     375          14 :         php_stream_from_zval(stream, bz);
     376             : 
     377          13 :         if ((len + 1) < 1) {
     378           1 :                 php_error_docref(NULL, E_WARNING, "length may not be negative");
     379           1 :                 RETURN_FALSE;
     380             :         }
     381          24 :         data = zend_string_alloc(len, 0);
     382          12 :         data->len = php_stream_read(stream, data->val, data->len);
     383          12 :         data->val[data->len] = '\0';
     384             : 
     385          12 :         RETURN_NEW_STR(data);
     386             : }
     387             : /* }}} */
     388             : 
     389             : /* {{{ proto resource bzopen(string|int file|fp, string mode)
     390             :    Opens a new BZip2 stream */
     391          37 : 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          37 :         php_stream *stream = NULL;
     399             : 
     400          37 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "zs", &file, &mode, &mode_len) == FAILURE) {
     401           1 :                 return;
     402             :         }
     403             : 
     404          36 :         if (mode_len != 1 || (mode[0] != 'r' && mode[0] != 'w')) {
     405           3 :                 php_error_docref(NULL, E_WARNING, "'%s' is not a valid mode for bzopen(). Only 'w' and 'r' are supported.", mode);
     406           3 :                 RETURN_FALSE;
     407             :         }
     408             : 
     409             :         /* If it's not a resource its a string containing the filename to open */
     410          66 :         if (Z_TYPE_P(file) == IS_STRING) {
     411          12 :                 if (Z_STRLEN_P(file) == 0) {
     412           2 :                         php_error_docref(NULL, E_WARNING, "filename cannot be empty");
     413           2 :                         RETURN_FALSE;
     414             :                 }
     415             : 
     416          10 :                 if (CHECK_ZVAL_NULL_PATH(file)) {
     417           0 :                         RETURN_FALSE;
     418             :                 }
     419             : 
     420          10 :                 stream = php_stream_bz2open(NULL, Z_STRVAL_P(file), mode, REPORT_ERRORS, NULL);
     421          42 :         } 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          19 :                 php_stream_from_zval(stream, file);
     427          19 :                 stream_mode_len = strlen(stream->mode);
     428             : 
     429          19 :                 if (stream_mode_len != 1 && !(stream_mode_len == 2 && memchr(stream->mode, 'b', 2))) {
     430           8 :                         php_error_docref(NULL, E_WARNING, "cannot use stream opened in mode '%s'", stream->mode);
     431           8 :                         RETURN_FALSE;
     432          11 :                 } else if (stream_mode_len == 1 && stream->mode[0] != 'r' && stream->mode[0] != 'w' && stream->mode[0] != 'a' && stream->mode[0] != 'x') {
     433           0 :                         php_error_docref(NULL, E_WARNING, "cannot use stream opened in mode '%s'", stream->mode);
     434           0 :                         RETURN_FALSE;
     435             :                 }
     436             : 
     437          11 :                 switch(mode[0]) {
     438             :                         case 'r':
     439             :                                 /* only "r" and "rb" are supported */
     440           6 :                                 if (stream->mode[0] != mode[0] && !(stream_mode_len == 2 && stream->mode[1] != mode[0])) {
     441           3 :                                         php_error_docref(NULL, E_WARNING, "cannot read from a stream opened in write only mode");
     442           3 :                                         RETURN_FALSE;
     443             :                                 }
     444           3 :                                 break;
     445             :                         case 'w':
     446             :                                 /* support only "w"(b), "a"(b), "x"(b) */
     447          10 :                                 if (stream->mode[0] != mode[0] && !(stream_mode_len == 2 && stream->mode[1] != mode[0])
     448           3 :                                         && stream->mode[0] != 'a' && !(stream_mode_len == 2 && stream->mode[1] != 'a')
     449           2 :                                         && stream->mode[0] != 'x' && !(stream_mode_len == 2 && stream->mode[1] != 'x')) {
     450           1 :                                         php_error_docref(NULL, E_WARNING, "cannot write to a stream opened in read only mode");
     451           1 :                                         RETURN_FALSE;
     452             :                                 }
     453             :                                 break;
     454             :                         default:
     455             :                                 /* not reachable */
     456             :                                 break;
     457             :                 }
     458             : 
     459           7 :                 if (FAILURE == php_stream_cast(stream, PHP_STREAM_AS_FD, (void *) &fd, REPORT_ERRORS)) {
     460           0 :                         RETURN_FALSE;
     461             :                 }
     462             : 
     463           7 :                 bz = BZ2_bzdopen((int)fd, mode);
     464             : 
     465           7 :                 stream = php_stream_bz2open_from_BZFILE(bz, mode, stream);
     466             :         } else {
     467           2 :                 php_error_docref(NULL, E_WARNING, "first parameter has to be string or file-resource");
     468           2 :                 RETURN_FALSE;
     469             :         }
     470             : 
     471          17 :         if (stream) {
     472          16 :                 php_stream_to_zval(stream, return_value);
     473             :         } else {
     474           1 :                 RETURN_FALSE;
     475             :         }
     476             : }
     477             : /* }}} */
     478             : 
     479             : /* {{{ proto int bzerrno(resource bz)
     480             :    Returns the error number */
     481           7 : static PHP_FUNCTION(bzerrno)
     482             : {
     483           7 :         php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRNO);
     484           7 : }
     485             : /* }}} */
     486             : 
     487             : /* {{{ proto string bzerrstr(resource bz)
     488             :    Returns the error string */
     489           7 : static PHP_FUNCTION(bzerrstr)
     490             : {
     491           7 :         php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRSTR);
     492           7 : }
     493             : /* }}} */
     494             : 
     495             : /* {{{ proto array bzerror(resource bz)
     496             :    Returns the error number and error string in an associative array */
     497           7 : static PHP_FUNCTION(bzerror)
     498             : {
     499           7 :         php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRBOTH);
     500           7 : }
     501             : /* }}} */
     502             : 
     503             : /* {{{ proto string bzcompress(string source [, int blocksize100k [, int workfactor]])
     504             :    Compresses a string into BZip2 encoded data */
     505           9 : static PHP_FUNCTION(bzcompress)
     506             : {
     507             :         char             *source;          /* Source data to compress */
     508           9 :         zend_long              zblock_size = 0; /* Optional block size to use */
     509           9 :         zend_long              zwork_factor = 0;/* Optional work factor to use */
     510           9 :         zend_string      *dest = NULL;     /* Destination to place the compressed data into */
     511             :         int               error,           /* Error Container */
     512           9 :                                           block_size  = 4, /* Block size for compression algorithm */
     513           9 :                                           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           9 :         argc = ZEND_NUM_ARGS();
     519             : 
     520           9 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|ll", &source, &source_len, &zblock_size, &zwork_factor) == FAILURE) {
     521           1 :                 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           8 :         dest_len = (unsigned int) (source_len + (0.01 * source_len) + 600);
     529             : 
     530             :         /* Allocate the destination buffer */
     531          16 :         dest = zend_string_alloc(dest_len, 0);
     532             : 
     533             :         /* Handle the optional arguments */
     534           8 :         if (argc > 1) {
     535           6 :                 block_size = zblock_size;
     536             :         }
     537             : 
     538           8 :         if (argc > 2) {
     539           5 :                 work_factor = zwork_factor;
     540             :         }
     541             : 
     542           8 :         error = BZ2_bzBuffToBuffCompress(dest->val, &dest_len, source, source_len, block_size, 0, work_factor);
     543           8 :         if (error != BZ_OK) {
     544             :                 zend_string_free(dest);
     545           4 :                 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           4 :                 dest->len = dest_len;
     550           4 :                 dest->val[dest->len] = '\0';
     551           4 :                 RETURN_NEW_STR(dest);
     552             :         }
     553             : }
     554             : /* }}} */
     555             : 
     556             : /* {{{ proto string bzdecompress(string source [, int small])
     557             :    Decompresses BZip2 compressed data */
     558          11 : static PHP_FUNCTION(bzdecompress)
     559             : {
     560             :         char *source, *dest;
     561             :         size_t source_len;
     562             :         int error;
     563          11 :         zend_long small = 0;
     564             : #if defined(PHP_WIN32)
     565             :         unsigned __int64 size = 0;
     566             : #else
     567          11 :         unsigned long long size = 0;
     568             : #endif
     569             :         bz_stream bzs;
     570             : 
     571          11 :         if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &source, &source_len, &small)) {
     572           2 :                 RETURN_FALSE;
     573             :         }
     574             : 
     575           9 :         bzs.bzalloc = NULL;
     576           9 :         bzs.bzfree = NULL;
     577             : 
     578           9 :         if (BZ2_bzDecompressInit(&bzs, 0, (int)small) != BZ_OK) {
     579           2 :                 RETURN_FALSE;
     580             :         }
     581             : 
     582           7 :         bzs.next_in = source;
     583           7 :         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           7 :         bzs.avail_out = source_len * 2;
     587           7 :         bzs.next_out = dest = emalloc(bzs.avail_out + 1);
     588             : 
     589          14 :         while ((error = BZ2_bzDecompress(&bzs)) == BZ_OK && bzs.avail_in > 0) {
     590             :                 /* compression is better then 2:1, need to allocate more memory */
     591           0 :                 bzs.avail_out = source_len;
     592           0 :                 size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
     593           0 :                 dest = safe_erealloc(dest, 1, bzs.avail_out+1, (size_t) size );
     594           0 :                 bzs.next_out = dest + size;
     595             :         }
     596             : 
     597          11 :         if (error == BZ_STREAM_END || error == BZ_OK) {
     598           4 :                 size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
     599           4 :                 dest = safe_erealloc(dest, 1, (size_t) size, 1);
     600           4 :                 dest[size] = '\0';
     601           8 :                 RETVAL_STRINGL(dest, (int) size);
     602           4 :                 efree(dest);
     603             :         } else { /* real error */
     604           3 :                 efree(dest);
     605           3 :                 RETVAL_LONG(error);
     606             :         }
     607             : 
     608           7 :         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          21 : 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          21 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &bzp) == FAILURE) {
     623           0 :                 return;
     624             :         }
     625             : 
     626          21 :         php_stream_from_zval(stream, bzp);
     627             : 
     628          18 :         if (!php_stream_is(stream, PHP_STREAM_IS_BZIP2)) {
     629           0 :                 RETURN_FALSE;
     630             :         }
     631             : 
     632          18 :         self = (struct php_bz2_stream_data_t *) stream->abstract;
     633             : 
     634             :         /* Fetch the error information */
     635          18 :         errstr = BZ2_bzerror(self->bz_file, &errnum);
     636             : 
     637             :         /* Determine what to return */
     638          18 :         switch (opt) {
     639             :                 case PHP_BZ_ERRNO:
     640           6 :                         RETURN_LONG(errnum);
     641             :                         break;
     642             :                 case PHP_BZ_ERRSTR:
     643          12 :                         RETURN_STRING((char*)errstr);
     644             :                         break;
     645             :                 case PHP_BZ_ERRBOTH:
     646           6 :                         array_init(return_value);
     647             : 
     648           6 :                         add_assoc_long  (return_value, "errno",  errnum);
     649           6 :                         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             :  */

Generated by: LCOV version 1.10

Generated at Sat, 27 Jun 2015 09:41:07 +0000 (3 days ago)

Copyright © 2005-2015 The PHP Group
All rights reserved.