Annotation of embedaddon/php/ext/bz2/bz2.c, revision 1.1.1.3

1.1       misho       1: /*
                      2:   +----------------------------------------------------------------------+
                      3:   | PHP Version 5                                                        |
                      4:   +----------------------------------------------------------------------+
1.1.1.3 ! misho       5:   | Copyright (c) 1997-2013 The PHP Group                                |
1.1       misho       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:  
1.1.1.2   misho      19: /* $Id$ */
1.1       misho      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: 
1.1.1.2   misho     231:        if (php_check_open_basedir(path_copy TSRMLS_CC)) {
1.1       misho     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 */
1.1.1.2   misho     245:                stream = php_stream_open_wrapper(path, mode, options | STREAM_WILL_CAST, opened_path);
1.1       misho     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:        Z_TYPE_P(return_value) = IS_STRING;
                    356: }
                    357: /* }}} */
                    358: 
                    359: /* {{{ proto resource bzopen(string|int file|fp, string mode)
                    360:    Opens a new BZip2 stream */
                    361: static PHP_FUNCTION(bzopen)
                    362: {
                    363:        zval    **file;   /* The file to open */
                    364:        char     *mode;   /* The mode to open the stream with */
                    365:        int      mode_len;
                    366: 
                    367:        BZFILE   *bz;     /* The compressed file stream */
                    368:        php_stream *stream = NULL;
                    369:        
                    370:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zs", &file, &mode, &mode_len) == FAILURE) {
                    371:                return;
                    372:        }
                    373: 
                    374:        if (mode_len != 1 || (mode[0] != 'r' && mode[0] != 'w')) {
                    375:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid mode for bzopen(). Only 'w' and 'r' are supported.", mode);
                    376:                RETURN_FALSE;
                    377:        }
                    378: 
                    379:        /* If it's not a resource its a string containing the filename to open */
                    380:        if (Z_TYPE_PP(file) == IS_STRING) {
                    381:                if (Z_STRLEN_PP(file) == 0) {
                    382:                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "filename cannot be empty");
                    383:                        RETURN_FALSE;
                    384:                }
1.1.1.2   misho     385:                
                    386:                if (CHECK_ZVAL_NULL_PATH(*file)) {
                    387:                        RETURN_FALSE;
                    388:                }
1.1       misho     389: 
                    390:                stream = php_stream_bz2open(NULL,
                    391:                                                                        Z_STRVAL_PP(file), 
                    392:                                                                        mode, 
1.1.1.2   misho     393:                                                                        REPORT_ERRORS, 
1.1       misho     394:                                                                        NULL);
                    395:        } else if (Z_TYPE_PP(file) == IS_RESOURCE) {
                    396:                /* If it is a resource, than its a stream resource */
                    397:                int fd;
                    398:                int stream_mode_len;
                    399: 
                    400:                php_stream_from_zval(stream, file);
                    401:                stream_mode_len = strlen(stream->mode);
                    402:                
                    403:                if (stream_mode_len != 1 && !(stream_mode_len == 2 && memchr(stream->mode, 'b', 2))) {
                    404:                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot use stream opened in mode '%s'", stream->mode);
                    405:                        RETURN_FALSE;
                    406:                } else if (stream_mode_len == 1 && stream->mode[0] != 'r' && stream->mode[0] != 'w' && stream->mode[0] != 'a' && stream->mode[0] != 'x') {
                    407:                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot use stream opened in mode '%s'", stream->mode);
                    408:                        RETURN_FALSE;
                    409:                }
                    410: 
                    411:                switch(mode[0]) {
                    412:                        case 'r':
                    413:                                /* only "r" and "rb" are supported */
                    414:                                if (stream->mode[0] != mode[0] && !(stream_mode_len == 2 && stream->mode[1] != mode[0])) {
                    415:                                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot read from a stream opened in write only mode");
                    416:                                        RETURN_FALSE;
                    417:                                }
                    418:                                break;
                    419:                        case 'w':
                    420:                                /* support only "w"(b), "a"(b), "x"(b) */
                    421:                                if (stream->mode[0] != mode[0] && !(stream_mode_len == 2 && stream->mode[1] != mode[0])
                    422:                                        && stream->mode[0] != 'a' && !(stream_mode_len == 2 && stream->mode[1] != 'a')
                    423:                                        && stream->mode[0] != 'x' && !(stream_mode_len == 2 && stream->mode[1] != 'x')) {
                    424:                                        php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot write to a stream opened in read only mode");
                    425:                                        RETURN_FALSE;
                    426:                                }
                    427:                                break;
                    428:                        default:
                    429:                                /* not reachable */
                    430:                                break;
                    431:                }
                    432: 
                    433:                if (FAILURE == php_stream_cast(stream, PHP_STREAM_AS_FD, (void *) &fd, REPORT_ERRORS)) {
                    434:                        RETURN_FALSE;
                    435:                }
                    436:                
                    437:                bz = BZ2_bzdopen(fd, mode);
                    438: 
                    439:                stream = php_stream_bz2open_from_BZFILE(bz, mode, stream);
                    440:        } else {
                    441:                php_error_docref(NULL TSRMLS_CC, E_WARNING, "first parameter has to be string or file-resource");
                    442:                RETURN_FALSE;
                    443:        }
                    444: 
                    445:        if (stream) {
                    446:                php_stream_to_zval(stream, return_value);
                    447:        } else {
                    448:                RETURN_FALSE;
                    449:        }
                    450: }
                    451: /* }}} */
                    452: 
                    453: /* {{{ proto int bzerrno(resource bz)
                    454:    Returns the error number */
                    455: static PHP_FUNCTION(bzerrno)
                    456: {
                    457:        php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRNO);
                    458: }
                    459: /* }}} */
                    460: 
                    461: /* {{{ proto string bzerrstr(resource bz)
                    462:    Returns the error string */
                    463: static PHP_FUNCTION(bzerrstr)
                    464: {
                    465:        php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRSTR);
                    466: }
                    467: /* }}} */
                    468: 
                    469: /* {{{ proto array bzerror(resource bz)
                    470:    Returns the error number and error string in an associative array */
                    471: static PHP_FUNCTION(bzerror)
                    472: {
                    473:        php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRBOTH);
                    474: }
                    475: /* }}} */
                    476: 
                    477: /* {{{ proto string bzcompress(string source [, int blocksize100k [, int workfactor]])
                    478:    Compresses a string into BZip2 encoded data */
                    479: static PHP_FUNCTION(bzcompress)
                    480: {
                    481:        char             *source;          /* Source data to compress */
                    482:        long              zblock_size = 0; /* Optional block size to use */
                    483:        long              zwork_factor = 0;/* Optional work factor to use */
                    484:        char             *dest = NULL;     /* Destination to place the compressed data into */
                    485:        int               error,           /* Error Container */
                    486:                                          block_size  = 4, /* Block size for compression algorithm */
                    487:                                          work_factor = 0, /* Work factor for compression algorithm */
                    488:                                          argc;            /* Argument count */
                    489:        int               source_len;      /* Length of the source data */
                    490:        unsigned int      dest_len;        /* Length of the destination buffer */ 
                    491: 
                    492:        argc = ZEND_NUM_ARGS();
                    493: 
                    494:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &source, &source_len, &zblock_size, &zwork_factor) == FAILURE) {
                    495:                return;
                    496:        }
                    497: 
                    498:        /* Assign them to easy to use variables, dest_len is initially the length of the data
                    499:           + .01 x length of data + 600 which is the largest size the results of the compression 
                    500:           could possibly be, at least that's what the libbz2 docs say (thanks to jeremy@nirvani.net 
                    501:           for pointing this out).  */
                    502:        dest_len   = (unsigned int) (source_len + (0.01 * source_len) + 600);
                    503:        
                    504:        /* Allocate the destination buffer */
                    505:        dest = emalloc(dest_len + 1);
                    506:        
                    507:        /* Handle the optional arguments */
                    508:        if (argc > 1) {
                    509:                block_size = zblock_size;
                    510:        }
                    511:        
                    512:        if (argc > 2) {
                    513:                work_factor = zwork_factor;
                    514:        }
                    515: 
                    516:        error = BZ2_bzBuffToBuffCompress(dest, &dest_len, source, source_len, block_size, 0, work_factor);
                    517:        if (error != BZ_OK) {
                    518:                efree(dest);
                    519:                RETURN_LONG(error);
                    520:        } else {
1.1.1.3 ! misho     521:                /* Copy the buffer, we have perhaps allocate a lot more than we need,
1.1       misho     522:                   so we erealloc() the buffer to the proper size */
                    523:                dest = erealloc(dest, dest_len + 1);
                    524:                dest[dest_len] = 0;
                    525:                RETURN_STRINGL(dest, dest_len, 0);
                    526:        }
                    527: }
                    528: /* }}} */
                    529: 
                    530: /* {{{ proto string bzdecompress(string source [, int small])
                    531:    Decompresses BZip2 compressed data */
                    532: static PHP_FUNCTION(bzdecompress)
                    533: {
                    534:        char *source, *dest;
                    535:        int source_len, error;
                    536:        long small = 0;
                    537: #if defined(PHP_WIN32)
                    538:        unsigned __int64 size = 0;
                    539: #else
                    540:        unsigned long long size = 0;
                    541: #endif
                    542:        bz_stream bzs;
                    543: 
                    544:        if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &source, &source_len, &small)) {
                    545:                RETURN_FALSE;
                    546:        }
                    547: 
                    548:        bzs.bzalloc = NULL;
                    549:        bzs.bzfree = NULL;
                    550: 
                    551:        if (BZ2_bzDecompressInit(&bzs, 0, small) != BZ_OK) {
                    552:                RETURN_FALSE;
                    553:        }
                    554: 
                    555:        bzs.next_in = source;
                    556:        bzs.avail_in = source_len;
                    557: 
                    558:        /* in most cases bz2 offers at least 2:1 compression, so we use that as our base */
                    559:        bzs.avail_out = source_len * 2;
                    560:        bzs.next_out = dest = emalloc(bzs.avail_out + 1);
                    561:        
                    562:        while ((error = BZ2_bzDecompress(&bzs)) == BZ_OK && bzs.avail_in > 0) {
                    563:                /* compression is better then 2:1, need to allocate more memory */
                    564:                bzs.avail_out = source_len;
                    565:                size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
                    566:                dest = safe_erealloc(dest, 1, bzs.avail_out+1, (size_t) size );
                    567:                bzs.next_out = dest + size;
                    568:        }
                    569: 
                    570:        if (error == BZ_STREAM_END || error == BZ_OK) {
                    571:                size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
                    572:                dest = safe_erealloc(dest, 1, (size_t) size, 1);
                    573:                dest[size] = '\0';
                    574:                RETVAL_STRINGL(dest, (int) size, 0);
                    575:        } else { /* real error */
                    576:                efree(dest);
                    577:                RETVAL_LONG(error);
                    578:        }
                    579: 
                    580:        BZ2_bzDecompressEnd(&bzs);
                    581: }
                    582: /* }}} */
                    583: 
                    584: /* {{{ php_bz2_error()
                    585:    The central error handling interface, does the work for bzerrno, bzerrstr and bzerror */
                    586: static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int opt)
                    587: { 
                    588:        zval         *bzp;     /* BZip2 Resource Pointer */
                    589:        php_stream   *stream;
                    590:        const char   *errstr;  /* Error string */
                    591:        int           errnum;  /* Error number */
                    592:        struct php_bz2_stream_data_t *self;
                    593:        
                    594:        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &bzp) == FAILURE) {
                    595:                return;
                    596:        }
                    597: 
                    598:        php_stream_from_zval(stream, &bzp);
                    599: 
                    600:        if (!php_stream_is(stream, PHP_STREAM_IS_BZIP2)) {
                    601:                RETURN_FALSE;
                    602:        }
                    603: 
                    604:        self = (struct php_bz2_stream_data_t *) stream->abstract;
                    605:        
                    606:        /* Fetch the error information */
                    607:        errstr = BZ2_bzerror(self->bz_file, &errnum);
                    608:        
                    609:        /* Determine what to return */
                    610:        switch (opt) {
                    611:                case PHP_BZ_ERRNO:
                    612:                        RETURN_LONG(errnum);
                    613:                        break;
                    614:                case PHP_BZ_ERRSTR:
                    615:                        RETURN_STRING((char*)errstr, 1);
                    616:                        break;
                    617:                case PHP_BZ_ERRBOTH:
                    618:                        array_init(return_value);
                    619:                
                    620:                        add_assoc_long  (return_value, "errno",  errnum);
                    621:                        add_assoc_string(return_value, "errstr", (char*)errstr, 1);
                    622:                        break;
                    623:        }
                    624: }
                    625: /* }}} */
                    626: 
                    627: #endif
                    628: 
                    629: /*
                    630:  * Local variables:
                    631:  * tab-width: 4
                    632:  * c-basic-offset: 4
                    633:  * End:
                    634:  * vim600: fdm=marker
                    635:  * vim: noet sw=4 ts=4
                    636:  */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>