1 : /*
2 : +----------------------------------------------------------------------+
3 : | PHP Version 6 |
4 : +----------------------------------------------------------------------+
5 : | Copyright (c) 1997-2009 The PHP Group |
6 : +----------------------------------------------------------------------+
7 : | This source file is subject to version 3.01 of the PHP license, |
8 : | that is bundled with this package in the file LICENSE, and is |
9 : | available through the world-wide-web at the following url: |
10 : | http://www.php.net/license/3_01.txt |
11 : | If you did not receive a copy of the PHP license and are unable to |
12 : | obtain it through the world-wide-web, please send a note to |
13 : | license@php.net so we can mail you a copy immediately. |
14 : +----------------------------------------------------------------------+
15 : | Author: Sterling Hughes <sterling@php.net> |
16 : +----------------------------------------------------------------------+
17 : */
18 :
19 : /* $Id: bz2.c 280599 2009-05-15 17:27:56Z kalle $ */
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 : /* }}} */
89 :
90 : static const zend_function_entry bz2_functions[] = {
91 : PHP_FE(bzopen, arginfo_bzopen)
92 : PHP_FE(bzread, arginfo_bzread)
93 : PHP_FALIAS(bzwrite, fwrite, NULL)
94 : PHP_FALIAS(bzflush, fflush, NULL)
95 : PHP_FALIAS(bzclose, fclose, NULL)
96 : PHP_FE(bzerrno, arginfo_bzerrno)
97 : PHP_FE(bzerrstr, arginfo_bzerrstr)
98 : PHP_FE(bzerror, arginfo_bzerror)
99 : PHP_FE(bzcompress, arginfo_bzcompress)
100 : PHP_FE(bzdecompress, arginfo_bzdecompress)
101 : {NULL, NULL, NULL}
102 : };
103 :
104 : zend_module_entry bz2_module_entry = {
105 : STANDARD_MODULE_HEADER,
106 : "bz2",
107 : bz2_functions,
108 : PHP_MINIT(bz2),
109 : PHP_MSHUTDOWN(bz2),
110 : NULL,
111 : NULL,
112 : PHP_MINFO(bz2),
113 : NO_VERSION_YET,
114 : STANDARD_MODULE_PROPERTIES
115 : };
116 :
117 : #ifdef COMPILE_DL_BZ2
118 : ZEND_GET_MODULE(bz2)
119 : #endif
120 :
121 : struct php_bz2_stream_data_t {
122 : BZFILE *bz_file;
123 : php_stream *stream;
124 : };
125 :
126 : /* {{{ BZip2 stream implementation */
127 :
128 : static size_t php_bz2iop_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
129 8 : {
130 8 : struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *) stream->abstract;
131 : size_t ret;
132 :
133 8 : ret = BZ2_bzread(self->bz_file, buf, count);
134 :
135 8 : if (ret == 0) {
136 2 : stream->eof = 1;
137 : }
138 :
139 8 : return ret;
140 : }
141 :
142 : static size_t php_bz2iop_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
143 14 : {
144 14 : struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *) stream->abstract;
145 :
146 14 : return BZ2_bzwrite(self->bz_file, (char*)buf, count);
147 : }
148 :
149 : static int php_bz2iop_close(php_stream *stream, int close_handle TSRMLS_DC)
150 14 : {
151 14 : struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
152 14 : int ret = EOF;
153 :
154 14 : if (close_handle) {
155 14 : BZ2_bzclose(self->bz_file);
156 : }
157 :
158 14 : if (self->stream) {
159 7 : php_stream_free(self->stream, PHP_STREAM_FREE_CLOSE | (close_handle == 0 ? PHP_STREAM_FREE_PRESERVE_HANDLE : 0));
160 : }
161 :
162 14 : efree(self);
163 :
164 14 : return ret;
165 : }
166 :
167 : static int php_bz2iop_flush(php_stream *stream TSRMLS_DC)
168 14 : {
169 14 : struct php_bz2_stream_data_t *self = (struct php_bz2_stream_data_t *)stream->abstract;
170 14 : return BZ2_bzflush(self->bz_file);
171 : }
172 : /* }}} */
173 :
174 : php_stream_ops php_stream_bz2io_ops = {
175 : php_bz2iop_write, php_bz2iop_read,
176 : php_bz2iop_close, php_bz2iop_flush,
177 : "BZip2",
178 : NULL, /* seek */
179 : NULL, /* cast */
180 : NULL, /* stat */
181 : NULL /* set_option */
182 : };
183 :
184 : /* {{{ Bzip2 stream openers */
185 : PHP_BZ2_API php_stream *_php_stream_bz2open_from_BZFILE(BZFILE *bz,
186 : char *mode, php_stream *innerstream STREAMS_DC TSRMLS_DC)
187 14 : {
188 : struct php_bz2_stream_data_t *self;
189 :
190 14 : self = emalloc(sizeof(*self));
191 :
192 14 : self->stream = innerstream;
193 14 : self->bz_file = bz;
194 :
195 14 : return php_stream_alloc_rel(&php_stream_bz2io_ops, self, 0, mode);
196 : }
197 :
198 : PHP_BZ2_API php_stream *_php_stream_bz2open(php_stream_wrapper *wrapper,
199 : char *path,
200 : char *mode,
201 : int options,
202 : char **opened_path,
203 : php_stream_context *context STREAMS_DC TSRMLS_DC)
204 8 : {
205 8 : php_stream *retstream = NULL, *stream = NULL;
206 8 : char *path_copy = NULL;
207 8 : BZFILE *bz_file = NULL;
208 :
209 8 : if (strncasecmp("compress.bzip2://", path, 17) == 0) {
210 0 : path += 17;
211 : }
212 8 : if (mode[0] == '\0' || (mode[0] != 'w' && mode[0] != 'r' && mode[1] != '\0')) {
213 0 : return NULL;
214 : }
215 :
216 : #ifdef VIRTUAL_DIR
217 : virtual_filepath_ex(path, &path_copy, NULL TSRMLS_CC);
218 : #else
219 8 : path_copy = path;
220 : #endif
221 :
222 8 : if (php_check_open_basedir(path_copy TSRMLS_CC)) {
223 0 : return NULL;
224 : }
225 :
226 : /* try and open it directly first */
227 8 : bz_file = BZ2_bzopen(path_copy, mode);
228 :
229 8 : if (opened_path && bz_file) {
230 0 : *opened_path = estrdup(path_copy);
231 : }
232 8 : path_copy = NULL;
233 :
234 8 : if (bz_file == NULL) {
235 : /* that didn't work, so try and get something from the network/wrapper */
236 1 : stream = php_stream_open_wrapper(path, mode, options | STREAM_WILL_CAST | ENFORCE_SAFE_MODE, opened_path);
237 :
238 1 : if (stream) {
239 : int fd;
240 0 : if (SUCCESS == php_stream_cast(stream, PHP_STREAM_AS_FD, (void **) &fd, REPORT_ERRORS)) {
241 0 : bz_file = BZ2_bzdopen(fd, mode);
242 : }
243 : }
244 :
245 : /* remove the file created by php_stream_open_wrapper(), it is not needed since BZ2 functions
246 : * failed.
247 : */
248 1 : if (opened_path && !bz_file && mode[0] == 'w') {
249 0 : VCWD_UNLINK(*opened_path);
250 : }
251 : }
252 :
253 8 : if (bz_file) {
254 7 : retstream = _php_stream_bz2open_from_BZFILE(bz_file, mode, stream STREAMS_REL_CC TSRMLS_CC);
255 7 : if (retstream) {
256 7 : return retstream;
257 : }
258 :
259 0 : BZ2_bzclose(bz_file);
260 : }
261 :
262 1 : if (stream) {
263 0 : php_stream_close(stream);
264 : }
265 :
266 1 : return NULL;
267 : }
268 :
269 : /* }}} */
270 :
271 : static php_stream_wrapper_ops bzip2_stream_wops = {
272 : _php_stream_bz2open,
273 : NULL, /* close */
274 : NULL, /* fstat */
275 : NULL, /* stat */
276 : NULL, /* opendir */
277 : "BZip2",
278 : NULL, /* unlink */
279 : NULL, /* rename */
280 : NULL, /* mkdir */
281 : NULL /* rmdir */
282 : };
283 :
284 : static php_stream_wrapper php_stream_bzip2_wrapper = {
285 : &bzip2_stream_wops,
286 : NULL,
287 : 0 /* is_url */
288 : };
289 :
290 : static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int);
291 :
292 : static PHP_MINIT_FUNCTION(bz2)
293 17007 : {
294 17007 : php_register_url_stream_wrapper("compress.bzip2", &php_stream_bzip2_wrapper TSRMLS_CC);
295 17007 : php_stream_filter_register_factory("bzip2.*", &php_bz2_filter_factory TSRMLS_CC);
296 17007 : return SUCCESS;
297 : }
298 :
299 : static PHP_MSHUTDOWN_FUNCTION(bz2)
300 17039 : {
301 17039 : php_unregister_url_stream_wrapper("compress.bzip2" TSRMLS_CC);
302 17039 : php_stream_filter_unregister_factory("bzip2.*" TSRMLS_CC);
303 :
304 17039 : return SUCCESS;
305 : }
306 :
307 : static PHP_MINFO_FUNCTION(bz2)
308 43 : {
309 43 : php_info_print_table_start();
310 43 : php_info_print_table_row(2, "BZip2 Support", "Enabled");
311 43 : php_info_print_table_row(2, "Stream Wrapper support", "compress.bz2://");
312 43 : php_info_print_table_row(2, "Stream Filter support", "bzip2.decompress, bzip2.compress");
313 43 : php_info_print_table_row(2, "BZip2 Version", (char *) BZ2_bzlibVersion());
314 43 : php_info_print_table_end();
315 43 : }
316 :
317 : /* {{{ proto string bzread(resource bz[, int length]) U
318 : Reads up to length bytes from a BZip2 stream, or 1024 bytes if length is not specified */
319 : static PHP_FUNCTION(bzread)
320 14 : {
321 : zval *bz;
322 14 : long len = 1024;
323 : php_stream *stream;
324 :
325 14 : if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &bz, &len)) {
326 2 : RETURN_FALSE;
327 : }
328 :
329 12 : php_stream_from_zval(stream, &bz);
330 :
331 11 : if ((len + 1) < 1) {
332 1 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "length may not be negative");
333 1 : RETURN_FALSE;
334 : }
335 :
336 10 : if (stream->readbuf_type == IS_UNICODE) {
337 0 : int buflen = len;
338 0 : UChar *buf = php_stream_read_unicode_chars(stream, &buflen);
339 :
340 0 : if (!buf) {
341 : /* For BC */
342 0 : RETURN_EMPTY_UNICODE();
343 : }
344 :
345 0 : RETURN_UNICODEL(buf, buflen, 0);
346 : } else { /* IS_STRING */
347 10 : char *buf = emalloc(len + 1);
348 10 : int buflen = php_stream_read(stream, buf, len);
349 :
350 10 : if (!buflen) {
351 5 : efree(buf);
352 5 : RETURN_EMPTY_STRING();
353 : }
354 5 : buf[buflen] = 0;
355 5 : RETURN_STRINGL(buf, buflen, 0);
356 : }
357 : }
358 : /* }}} */
359 :
360 : /* {{{ proto resource bzopen(string|int file|fp, string mode) U
361 : Opens a new BZip2 stream */
362 : static PHP_FUNCTION(bzopen)
363 35 : {
364 : zval **file; /* The file to open */
365 : char *mode; /* The mode to open the stream with */
366 : int mode_len;
367 : BZFILE *bz; /* The compressed file stream */
368 35 : php_stream *stream = NULL;
369 :
370 35 : if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zs", &file, &mode, &mode_len) == FAILURE) {
371 1 : return;
372 : }
373 :
374 34 : if (mode_len != 1 || (mode[0] != 'r' && mode[0] != 'w')) {
375 3 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "'%s' is not a valid mode for bzopen(). Only 'w' and 'r' are supported", mode);
376 3 : RETURN_FALSE;
377 : }
378 :
379 : /* If it's not a resource its a string containing the filename to open */
380 31 : if (Z_TYPE_PP(file) != IS_RESOURCE) {
381 : char *filename;
382 : int filename_len;
383 :
384 12 : if (FAILURE == php_stream_path_param_encode(file, &filename, &filename_len, REPORT_ERRORS, FG(default_context))) {
385 0 : RETURN_FALSE;
386 : }
387 :
388 12 : if (filename_len == 0) {
389 4 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "filename cannot be empty");
390 4 : RETURN_FALSE;
391 : }
392 :
393 8 : stream = php_stream_bz2open(NULL, filename, mode, REPORT_ERRORS, NULL);
394 : } else {
395 : /* If it is a resource, than its a stream resource */
396 : int fd;
397 : int stream_mode_len;
398 :
399 19 : php_stream_from_zval(stream, file);
400 19 : stream_mode_len = strlen(stream->mode);
401 :
402 19 : if (stream_mode_len != 1 && !(stream_mode_len == 2 && memchr(stream->mode, 'b', 2))) {
403 8 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot use stream opened in mode '%s'", stream->mode);
404 8 : RETURN_FALSE;
405 11 : } else if (stream_mode_len == 1 && stream->mode[0] != 'r' && stream->mode[0] != 'w' && stream->mode[0] != 'a' && stream->mode[0] != 'x') {
406 0 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot use stream opened in mode '%s'", stream->mode);
407 0 : RETURN_FALSE;
408 : }
409 :
410 11 : switch(mode[0]) {
411 : case 'r':
412 : /* only "r" and "rb" are supported */
413 6 : if (stream->mode[0] != mode[0] && !(stream_mode_len == 2 && stream->mode[1] != mode[0])) {
414 3 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot read from a stream opened in write only mode");
415 3 : RETURN_FALSE;
416 : }
417 3 : break;
418 : case 'w':
419 : /* support only "w"(b), "a"(b), "x"(b) */
420 5 : if (stream->mode[0] != mode[0] && !(stream_mode_len == 2 && stream->mode[1] != mode[0])
421 : && stream->mode[0] != 'a' && !(stream_mode_len == 2 && stream->mode[1] != 'a')
422 : && stream->mode[0] != 'x' && !(stream_mode_len == 2 && stream->mode[1] != 'x')) {
423 1 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot write to a stream opened in read only mode");
424 1 : RETURN_FALSE;
425 : }
426 : break;
427 : default:
428 : /* not reachable */
429 : break;
430 : }
431 :
432 : /* If the stream is filtered, it'll fail here because it's not castable */
433 7 : if (FAILURE == php_stream_cast(stream, PHP_STREAM_AS_FD, (void *) &fd, REPORT_ERRORS)) {
434 0 : RETURN_FALSE;
435 : }
436 :
437 7 : bz = BZ2_bzdopen(fd, mode);
438 :
439 7 : stream = php_stream_bz2open_from_BZFILE(bz, mode, stream);
440 : }
441 :
442 15 : if (stream) {
443 14 : php_stream_to_zval(stream, return_value);
444 : } else {
445 1 : RETURN_FALSE;
446 : }
447 : }
448 : /* }}} */
449 :
450 : /* {{{ proto int bzerrno(resource bz) U
451 : Returns the error number */
452 : static PHP_FUNCTION(bzerrno)
453 7 : {
454 7 : php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRNO);
455 7 : }
456 : /* }}} */
457 :
458 : /* {{{ proto string bzerrstr(resource bz) U
459 : Returns the error string */
460 : static PHP_FUNCTION(bzerrstr)
461 7 : {
462 7 : php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRSTR);
463 7 : }
464 : /* }}} */
465 :
466 : /* {{{ proto array bzerror(resource bz) U
467 : Returns the error number and error string in an associative array */
468 : static PHP_FUNCTION(bzerror)
469 7 : {
470 7 : php_bz2_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, PHP_BZ_ERRBOTH);
471 7 : }
472 : /* }}} */
473 :
474 : /* {{{ proto string bzcompress(string source [, int blocksize100k [, int workfactor]]) U
475 : Compresses a string into BZip2 encoded data */
476 : static PHP_FUNCTION(bzcompress)
477 9 : {
478 : zstr source; /* String to compress */
479 : int source_len;
480 : zend_uchar source_type;
481 9 : long block_size = 4, /* Block size for compression algorithm */
482 9 : work_factor = 0; /* Work factor for compression algorithm */
483 9 : char *dest = NULL; /* Destination to place the compressed data into */
484 9 : int dest_len = 0;
485 : int error; /* Error Container */
486 :
487 9 : if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "t|ll", &source, &source_len, &source_type, &block_size, &work_factor) == FAILURE) {
488 1 : return;
489 : }
490 :
491 : /* Malloc dest to dest_len which is the length of the 101% the length of the data plus 600 bytes
492 : * This is the largest size the results of the compression could possibly be,
493 : * at least that's what the libbz2 docs say (thanks to jeremy@nirvani.net for pointing this out).
494 : */
495 8 : dest_len = (int) (source_len + (0.01 * source_len) + 600);
496 :
497 : /* Allocate the destination buffer */
498 8 : dest = emalloc(dest_len + 1);
499 :
500 8 : if (source_type == IS_UNICODE) {
501 7 : source.s = zend_unicode_to_ascii(source.u, source_len TSRMLS_CC);
502 7 : if (!source.s) {
503 0 : php_error_docref(NULL TSRMLS_CC, E_WARNING, "Binary or ASCII-Unicode string expected, non-ASCII-Unicode string received");
504 0 : RETURN_FALSE;
505 : }
506 : }
507 :
508 8 : error = BZ2_bzBuffToBuffCompress(dest, &dest_len, source.s, source_len, block_size, 0, work_factor);
509 8 : if (error != BZ_OK) {
510 4 : efree(dest);
511 4 : RETVAL_LONG(error);
512 : } else {
513 4 : if (dest_len < source_len) {
514 : /* Normal case, but it means we over alloc'd */
515 0 : dest = erealloc(dest, dest_len + 1);
516 : } /* else it's not worth a realloc */
517 :
518 4 : dest[dest_len] = 0;
519 4 : RETVAL_STRINGL(dest, dest_len, 0);
520 : }
521 :
522 8 : if (source_type == IS_UNICODE) {
523 7 : efree(source.s);
524 : }
525 : }
526 : /* }}} */
527 :
528 : /* {{{ proto string bzdecompress(string source [, int small]) U
529 : Decompresses BZip2 compressed data */
530 : static PHP_FUNCTION(bzdecompress)
531 11 : {
532 : char *source, *dest;
533 : int source_len, error;
534 11 : long small = 0;
535 : #if defined(PHP_WIN32)
536 : unsigned __int64 size = 0;
537 : #else
538 11 : unsigned long long size = 0;
539 : #endif
540 : bz_stream bzs;
541 :
542 11 : if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|l", &source, &source_len, &small)) {
543 2 : RETURN_FALSE;
544 : }
545 :
546 9 : bzs.bzalloc = NULL;
547 9 : bzs.bzfree = NULL;
548 :
549 9 : if (BZ2_bzDecompressInit(&bzs, 0, small) != BZ_OK) {
550 2 : RETURN_FALSE;
551 : }
552 :
553 7 : bzs.next_in = source;
554 7 : bzs.avail_in = source_len;
555 :
556 : /* in most cases bz2 offers at least 2:1 compression, so we use that as our base */
557 7 : bzs.avail_out = source_len * 2;
558 7 : bzs.next_out = dest = emalloc(bzs.avail_out + 1);
559 :
560 14 : while ((error = BZ2_bzDecompress(&bzs)) == BZ_OK && bzs.avail_in > 0) {
561 : /* compression is better then 2:1, need to allocate more memory */
562 0 : bzs.avail_out = source_len;
563 0 : size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
564 0 : dest = erealloc(dest, (size_t) (size + bzs.avail_out + 1));
565 0 : bzs.next_out = dest + size;
566 : }
567 :
568 11 : if (error == BZ_STREAM_END || error == BZ_OK) {
569 4 : size = (bzs.total_out_hi32 * (unsigned int) -1) + bzs.total_out_lo32;
570 4 : dest = erealloc(dest, (size_t) (size + 1));
571 4 : dest[size] = '\0';
572 4 : RETVAL_STRINGL(dest, (int) size, 0);
573 : } else { /* real error */
574 3 : efree(dest);
575 3 : RETVAL_LONG(error);
576 : }
577 :
578 7 : BZ2_bzDecompressEnd(&bzs);
579 : }
580 : /* }}} */
581 :
582 : /* {{{ php_bz2_error()
583 : The central error handling interface, does the work for bzerrno, bzerrstr and bzerror */
584 : static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int opt)
585 21 : {
586 : zval *zstream; /* BZip2 Resource Pointer */
587 : php_stream *stream;
588 : const char *errstr; /* Error string */
589 : int errnum; /* Error number */
590 : struct php_bz2_stream_data_t *self;
591 :
592 21 : if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstream) == FAILURE) {
593 0 : return;
594 : }
595 :
596 21 : php_stream_from_zval(stream, &zstream);
597 :
598 18 : if (!php_stream_is(stream, PHP_STREAM_IS_BZIP2)) {
599 0 : RETURN_FALSE;
600 : }
601 :
602 18 : self = (struct php_bz2_stream_data_t *) stream->abstract;
603 :
604 : /* Fetch the error information */
605 18 : errstr = BZ2_bzerror(self->bz_file, &errnum);
606 :
607 : /* Determine what to return */
608 18 : switch (opt) {
609 : case PHP_BZ_ERRNO:
610 6 : RETURN_LONG(errnum);
611 : break;
612 : case PHP_BZ_ERRSTR:
613 6 : RETURN_RT_STRING((char*)errstr, ZSTR_DUPLICATE);
614 : break;
615 : case PHP_BZ_ERRBOTH:
616 6 : array_init(return_value);
617 :
618 6 : add_ascii_assoc_long (return_value, "errno", errnum);
619 6 : add_ascii_assoc_rt_string(return_value, "errstr", (char*)errstr, ZSTR_DUPLICATE);
620 : break;
621 : }
622 : }
623 : /* }}} */
624 :
625 : #endif
626 :
627 : /*
628 : * Local variables:
629 : * tab-width: 4
630 : * c-basic-offset: 4
631 : * End:
632 : * vim600: fdm=marker
633 : * vim: noet sw=4 ts=4
634 : */
|
