1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
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 | Authors: Sara Golemon (pollita@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 /* {{{ data structure */
29
30 enum strm_status {
31 PHP_BZ2_UNITIALIZED,
32 PHP_BZ2_RUNNING,
33 PHP_BZ2_FINISHED
34 };
35
36 typedef struct _php_bz2_filter_data {
37 int persistent;
38 bz_stream strm;
39 char *inbuf;
40 size_t inbuf_len;
41 char *outbuf;
42 size_t outbuf_len;
43
44 /* Decompress options */
45 enum strm_status status;
46 unsigned int small_footprint : 1;
47 unsigned int expect_concatenated : 1;
48 } php_bz2_filter_data;
49
50 /* }}} */
51
52 /* {{{ Memory management wrappers */
53
php_bz2_alloc(void * opaque,int items,int size)54 static void *php_bz2_alloc(void *opaque, int items, int size)
55 {
56 return (void *)safe_pemalloc(items, size, 0, ((php_bz2_filter_data*)opaque)->persistent);
57 }
58
php_bz2_free(void * opaque,void * address)59 static void php_bz2_free(void *opaque, void *address)
60 {
61 pefree((void *)address, ((php_bz2_filter_data*)opaque)->persistent);
62 }
63 /* }}} */
64
65 /* {{{ bzip2.decompress filter implementation */
66
php_bz2_decompress_filter(php_stream * stream,php_stream_filter * thisfilter,php_stream_bucket_brigade * buckets_in,php_stream_bucket_brigade * buckets_out,size_t * bytes_consumed,int flags TSRMLS_DC)67 static php_stream_filter_status_t php_bz2_decompress_filter(
68 php_stream *stream,
69 php_stream_filter *thisfilter,
70 php_stream_bucket_brigade *buckets_in,
71 php_stream_bucket_brigade *buckets_out,
72 size_t *bytes_consumed,
73 int flags
74 TSRMLS_DC)
75 {
76 php_bz2_filter_data *data;
77 php_stream_bucket *bucket;
78 size_t consumed = 0;
79 int status;
80 php_stream_filter_status_t exit_status = PSFS_FEED_ME;
81 bz_stream *streamp;
82
83 if (!thisfilter || !thisfilter->abstract) {
84 /* Should never happen */
85 return PSFS_ERR_FATAL;
86 }
87
88 data = (php_bz2_filter_data *)(thisfilter->abstract);
89 streamp = &(data->strm);
90
91 while (buckets_in->head) {
92 size_t bin = 0, desired;
93
94 bucket = php_stream_bucket_make_writeable(buckets_in->head TSRMLS_CC);
95 while (bin < bucket->buflen) {
96 if (data->status == PHP_BZ2_UNITIALIZED) {
97 status = BZ2_bzDecompressInit(streamp, 0, data->small_footprint);
98
99 if (BZ_OK != status) {
100 php_stream_bucket_delref(bucket TSRMLS_CC);
101 return PSFS_ERR_FATAL;
102 }
103
104 data->status = PHP_BZ2_RUNNING;
105 }
106
107 if (data->status != PHP_BZ2_RUNNING) {
108 consumed += bucket->buflen;
109 break;
110 }
111
112 desired = bucket->buflen - bin;
113 if (desired > data->inbuf_len) {
114 desired = data->inbuf_len;
115 }
116 memcpy(data->strm.next_in, bucket->buf + bin, desired);
117 data->strm.avail_in = desired;
118
119 status = BZ2_bzDecompress(&(data->strm));
120
121 if (status == BZ_STREAM_END) {
122 BZ2_bzDecompressEnd(&(data->strm));
123 if (data->expect_concatenated) {
124 data->status = PHP_BZ2_UNITIALIZED;
125 } else {
126 data->status = PHP_BZ2_FINISHED;
127 }
128 } else if (status != BZ_OK) {
129 /* Something bad happened */
130 php_stream_bucket_delref(bucket TSRMLS_CC);
131 return PSFS_ERR_FATAL;
132 }
133 desired -= data->strm.avail_in; /* desired becomes what we consumed this round through */
134 data->strm.next_in = data->inbuf;
135 data->strm.avail_in = 0;
136 consumed += desired;
137 bin += desired;
138
139 if (data->strm.avail_out < data->outbuf_len) {
140 php_stream_bucket *out_bucket;
141 size_t bucketlen = data->outbuf_len - data->strm.avail_out;
142 out_bucket = php_stream_bucket_new(stream, estrndup(data->outbuf, bucketlen), bucketlen, 1, 0 TSRMLS_CC);
143 php_stream_bucket_append(buckets_out, out_bucket TSRMLS_CC);
144 data->strm.avail_out = data->outbuf_len;
145 data->strm.next_out = data->outbuf;
146 exit_status = PSFS_PASS_ON;
147 } else if (status == BZ_STREAM_END && data->strm.avail_out >= data->outbuf_len) {
148 /* no more data to decompress, and nothing was spat out */
149 php_stream_bucket_delref(bucket TSRMLS_CC);
150 return PSFS_PASS_ON;
151 }
152 }
153
154 php_stream_bucket_delref(bucket TSRMLS_CC);
155 }
156
157 if ((data->status == PHP_BZ2_RUNNING) && (flags & PSFS_FLAG_FLUSH_CLOSE)) {
158 /* Spit it out! */
159 status = BZ_OK;
160 while (status == BZ_OK) {
161 status = BZ2_bzDecompress(&(data->strm));
162 if (data->strm.avail_out < data->outbuf_len) {
163 size_t bucketlen = data->outbuf_len - data->strm.avail_out;
164
165 bucket = php_stream_bucket_new(stream, estrndup(data->outbuf, bucketlen), bucketlen, 1, 0 TSRMLS_CC);
166 php_stream_bucket_append(buckets_out, bucket TSRMLS_CC);
167 data->strm.avail_out = data->outbuf_len;
168 data->strm.next_out = data->outbuf;
169 exit_status = PSFS_PASS_ON;
170 } else if (status == BZ_OK) {
171 break;
172 }
173 }
174 }
175
176 if (bytes_consumed) {
177 *bytes_consumed = consumed;
178 }
179
180 return exit_status;
181 }
182
php_bz2_decompress_dtor(php_stream_filter * thisfilter TSRMLS_DC)183 static void php_bz2_decompress_dtor(php_stream_filter *thisfilter TSRMLS_DC)
184 {
185 if (thisfilter && thisfilter->abstract) {
186 php_bz2_filter_data *data = thisfilter->abstract;
187 if (data->status == PHP_BZ2_RUNNING) {
188 BZ2_bzDecompressEnd(&(data->strm));
189 }
190 pefree(data->inbuf, data->persistent);
191 pefree(data->outbuf, data->persistent);
192 pefree(data, data->persistent);
193 }
194 }
195
196 static php_stream_filter_ops php_bz2_decompress_ops = {
197 php_bz2_decompress_filter,
198 php_bz2_decompress_dtor,
199 "bzip2.decompress"
200 };
201 /* }}} */
202
203 /* {{{ bzip2.compress filter implementation */
204
php_bz2_compress_filter(php_stream * stream,php_stream_filter * thisfilter,php_stream_bucket_brigade * buckets_in,php_stream_bucket_brigade * buckets_out,size_t * bytes_consumed,int flags TSRMLS_DC)205 static php_stream_filter_status_t php_bz2_compress_filter(
206 php_stream *stream,
207 php_stream_filter *thisfilter,
208 php_stream_bucket_brigade *buckets_in,
209 php_stream_bucket_brigade *buckets_out,
210 size_t *bytes_consumed,
211 int flags
212 TSRMLS_DC)
213 {
214 php_bz2_filter_data *data;
215 php_stream_bucket *bucket;
216 size_t consumed = 0;
217 int status;
218 php_stream_filter_status_t exit_status = PSFS_FEED_ME;
219
220 if (!thisfilter || !thisfilter->abstract) {
221 /* Should never happen */
222 return PSFS_ERR_FATAL;
223 }
224
225 data = (php_bz2_filter_data *)(thisfilter->abstract);
226
227 while (buckets_in->head) {
228 size_t bin = 0, desired;
229
230 bucket = php_stream_bucket_make_writeable(buckets_in->head TSRMLS_CC);
231
232 while (bin < bucket->buflen) {
233 desired = bucket->buflen - bin;
234 if (desired > data->inbuf_len) {
235 desired = data->inbuf_len;
236 }
237 memcpy(data->strm.next_in, bucket->buf + bin, desired);
238 data->strm.avail_in = desired;
239
240 status = BZ2_bzCompress(&(data->strm), flags & PSFS_FLAG_FLUSH_CLOSE ? BZ_FINISH : (flags & PSFS_FLAG_FLUSH_INC ? BZ_FLUSH : BZ_RUN));
241 if (status != BZ_RUN_OK && status != BZ_FLUSH_OK && status != BZ_FINISH_OK) {
242 /* Something bad happened */
243 php_stream_bucket_delref(bucket TSRMLS_CC);
244 return PSFS_ERR_FATAL;
245 }
246 desired -= data->strm.avail_in; /* desired becomes what we consumed this round through */
247 data->strm.next_in = data->inbuf;
248 data->strm.avail_in = 0;
249 consumed += desired;
250 bin += desired;
251
252 if (data->strm.avail_out < data->outbuf_len) {
253 php_stream_bucket *out_bucket;
254 size_t bucketlen = data->outbuf_len - data->strm.avail_out;
255
256 out_bucket = php_stream_bucket_new(stream, estrndup(data->outbuf, bucketlen), bucketlen, 1, 0 TSRMLS_CC);
257 php_stream_bucket_append(buckets_out, out_bucket TSRMLS_CC);
258 data->strm.avail_out = data->outbuf_len;
259 data->strm.next_out = data->outbuf;
260 exit_status = PSFS_PASS_ON;
261 }
262 }
263 php_stream_bucket_delref(bucket TSRMLS_CC);
264 }
265
266 if (flags & PSFS_FLAG_FLUSH_CLOSE) {
267 /* Spit it out! */
268 status = BZ_FINISH_OK;
269 while (status == BZ_FINISH_OK) {
270 status = BZ2_bzCompress(&(data->strm), BZ_FINISH);
271 if (data->strm.avail_out < data->outbuf_len) {
272 size_t bucketlen = data->outbuf_len - data->strm.avail_out;
273
274 bucket = php_stream_bucket_new(stream, estrndup(data->outbuf, bucketlen), bucketlen, 1, 0 TSRMLS_CC);
275 php_stream_bucket_append(buckets_out, bucket TSRMLS_CC);
276 data->strm.avail_out = data->outbuf_len;
277 data->strm.next_out = data->outbuf;
278 exit_status = PSFS_PASS_ON;
279 }
280 }
281 }
282
283 if (bytes_consumed) {
284 *bytes_consumed = consumed;
285 }
286 return exit_status;
287 }
288
php_bz2_compress_dtor(php_stream_filter * thisfilter TSRMLS_DC)289 static void php_bz2_compress_dtor(php_stream_filter *thisfilter TSRMLS_DC)
290 {
291 if (thisfilter && thisfilter->abstract) {
292 php_bz2_filter_data *data = thisfilter->abstract;
293 BZ2_bzCompressEnd(&(data->strm));
294 pefree(data->inbuf, data->persistent);
295 pefree(data->outbuf, data->persistent);
296 pefree(data, data->persistent);
297 }
298 }
299
300 static php_stream_filter_ops php_bz2_compress_ops = {
301 php_bz2_compress_filter,
302 php_bz2_compress_dtor,
303 "bzip2.compress"
304 };
305
306 /* }}} */
307
308 /* {{{ bzip2.* common factory */
309
php_bz2_filter_create(const char * filtername,zval * filterparams,int persistent TSRMLS_DC)310 static php_stream_filter *php_bz2_filter_create(const char *filtername, zval *filterparams, int persistent TSRMLS_DC)
311 {
312 php_stream_filter_ops *fops = NULL;
313 php_bz2_filter_data *data;
314 int status = BZ_OK;
315
316 /* Create this filter */
317 data = pecalloc(1, sizeof(php_bz2_filter_data), persistent);
318 if (!data) {
319 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed allocating %zu bytes", sizeof(php_bz2_filter_data));
320 return NULL;
321 }
322
323 /* Circular reference */
324 data->strm.opaque = (void *) data;
325
326 data->strm.bzalloc = php_bz2_alloc;
327 data->strm.bzfree = php_bz2_free;
328 data->persistent = persistent;
329 data->strm.avail_out = data->outbuf_len = data->inbuf_len = 2048;
330 data->strm.next_in = data->inbuf = (char *) pemalloc(data->inbuf_len, persistent);
331 if (!data->inbuf) {
332 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed allocating %zu bytes", data->inbuf_len);
333 pefree(data, persistent);
334 return NULL;
335 }
336 data->strm.avail_in = 0;
337 data->strm.next_out = data->outbuf = (char *) pemalloc(data->outbuf_len, persistent);
338 if (!data->outbuf) {
339 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed allocating %zu bytes", data->outbuf_len);
340 pefree(data->inbuf, persistent);
341 pefree(data, persistent);
342 return NULL;
343 }
344
345 if (strcasecmp(filtername, "bzip2.decompress") == 0) {
346 data->small_footprint = 0;
347 data->expect_concatenated = 0;
348
349 if (filterparams) {
350 zval **tmpzval = NULL;
351
352 if (Z_TYPE_P(filterparams) == IS_ARRAY || Z_TYPE_P(filterparams) == IS_OBJECT) {
353
354 if (SUCCESS == zend_hash_find(HASH_OF(filterparams), "concatenated", sizeof("concatenated"), (void **) &tmpzval) ) {
355 zval tmp, *tmp2;
356
357 tmp = **tmpzval;
358 zval_copy_ctor(&tmp);
359 tmp2 = &tmp;
360 convert_to_boolean_ex(&tmp2);
361 data->expect_concatenated = Z_LVAL(tmp);
362 tmpzval = NULL;
363 }
364
365 zend_hash_find(HASH_OF(filterparams), "small", sizeof("small"), (void **) &tmpzval);
366 } else {
367 tmpzval = &filterparams;
368 }
369
370 if (tmpzval) {
371 zval tmp, *tmp2;
372
373 tmp = **tmpzval;
374 zval_copy_ctor(&tmp);
375 tmp2 = &tmp;
376 convert_to_boolean_ex(&tmp2);
377 data->small_footprint = Z_LVAL(tmp);
378 }
379 }
380
381 data->status = PHP_BZ2_UNITIALIZED;
382 fops = &php_bz2_decompress_ops;
383 } else if (strcasecmp(filtername, "bzip2.compress") == 0) {
384 int blockSize100k = PHP_BZ2_FILTER_DEFAULT_BLOCKSIZE;
385 int workFactor = PHP_BZ2_FILTER_DEFAULT_WORKFACTOR;
386
387 if (filterparams) {
388 zval **tmpzval;
389
390 if (Z_TYPE_P(filterparams) == IS_ARRAY || Z_TYPE_P(filterparams) == IS_OBJECT) {
391 if (zend_hash_find(HASH_OF(filterparams), "blocks", sizeof("blocks"), (void**) &tmpzval) == SUCCESS) {
392 /* How much memory to allocate (1 - 9) x 100kb */
393 zval tmp;
394
395 tmp = **tmpzval;
396 zval_copy_ctor(&tmp);
397 convert_to_long(&tmp);
398 if (Z_LVAL(tmp) < 1 || Z_LVAL(tmp) > 9) {
399 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid parameter given for number of blocks to allocate. (%ld)", Z_LVAL_PP(tmpzval));
400 } else {
401 blockSize100k = Z_LVAL(tmp);
402 }
403 }
404
405 if (zend_hash_find(HASH_OF(filterparams), "work", sizeof("work"), (void**) &tmpzval) == SUCCESS) {
406 /* Work Factor (0 - 250) */
407 zval tmp;
408
409 tmp = **tmpzval;
410 zval_copy_ctor(&tmp);
411 convert_to_long(&tmp);
412
413 if (Z_LVAL(tmp) < 0 || Z_LVAL(tmp) > 250) {
414 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid parameter given for work factor. (%ld)", Z_LVAL(tmp));
415 } else {
416 workFactor = Z_LVAL(tmp);
417 }
418 }
419 }
420 }
421
422 status = BZ2_bzCompressInit(&(data->strm), blockSize100k, 0, workFactor);
423 fops = &php_bz2_compress_ops;
424 } else {
425 status = BZ_DATA_ERROR;
426 }
427
428 if (status != BZ_OK) {
429 /* Unspecified (probably strm) error, let stream-filter error do its own whining */
430 pefree(data->strm.next_in, persistent);
431 pefree(data->strm.next_out, persistent);
432 pefree(data, persistent);
433 return NULL;
434 }
435
436 return php_stream_filter_alloc(fops, data, persistent);
437 }
438
439 php_stream_filter_factory php_bz2_filter_factory = {
440 php_bz2_filter_create
441 };
442 /* }}} */
443
444 /*
445 * Local variables:
446 * tab-width: 4
447 * c-basic-offset: 4
448 * End:
449 * vim600: sw=4 ts=4 fdm=marker
450 * vim<600: sw=4 ts=4
451 */
452
