2 +--------------------------------------------------------------------+
4 +--------------------------------------------------------------------+
5 | Redistribution and use in source and binary forms, with or without |
6 | modification, are permitted provided that the conditions mentioned |
7 | in the accompanying LICENSE file are met. |
8 +--------------------------------------------------------------------+
9 | Copyright (c) 2004-2014, Michael Wallner <mike@php.net> |
10 +--------------------------------------------------------------------+
13 #include "php_http_api.h"
17 static inline int eol_match(char **line
, int *eol_len
)
21 while (' ' == *ptr
) ++ptr
;
23 if (ptr
== php_http_locate_eol(*line
, eol_len
)) {
31 const char *php_http_encoding_dechunk(const char *encoded
, size_t encoded_len
, char **decoded
, size_t *decoded_len TSRMLS_DC
)
35 const char *e_ptr
= encoded
;
38 *decoded
= ecalloc(1, encoded_len
+ 1);
40 while ((encoded
+ encoded_len
- e_ptr
) > 0) {
41 ulong chunk_len
= 0, rest
;
43 chunk_len
= strtoul(e_ptr
, &n_ptr
, 16);
45 /* we could not read in chunk size */
48 * if this is the first turn and there doesn't seem to be a chunk
49 * size at the begining of the body, do not fail on apparently
50 * not encoded data and return a copy
52 if (e_ptr
== encoded
) {
53 php_error_docref(NULL TSRMLS_CC
, E_NOTICE
, "Data does not seem to be chunked encoded");
54 memcpy(*decoded
, encoded
, encoded_len
);
55 *decoded_len
= encoded_len
;
56 return encoded
+ encoded_len
;
59 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Expected chunk size at pos %tu of %zu but got trash", n_ptr
- encoded
, encoded_len
);
66 /* move over '0' chunked encoding terminator and any new lines */
80 /* there should be CRLF after the chunk size, but we'll ignore SP+ too */
81 if (*n_ptr
&& !eol_match(&n_ptr
, &eol_len
)) {
83 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Expected CRLF at pos %tu of %zu but got 0x%02X 0x%02X", n_ptr
- encoded
, encoded_len
, *n_ptr
, *(n_ptr
+ 1));
85 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Expected LF at pos %tu of %zu but got 0x%02X", n_ptr
- encoded
, encoded_len
, *n_ptr
);
90 /* chunk size pretends more data than we actually got, so it's probably a truncated message */
91 if (chunk_len
> (rest
= encoded
+ encoded_len
- n_ptr
)) {
92 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Truncated message: chunk size %lu exceeds remaining data size %lu at pos %tu of %zu", chunk_len
, rest
, n_ptr
- encoded
, encoded_len
);
97 memcpy(*decoded
+ *decoded_len
, n_ptr
, chunk_len
);
98 *decoded_len
+= chunk_len
;
100 if (chunk_len
== rest
) {
101 e_ptr
= n_ptr
+ chunk_len
;
104 /* advance to next chunk */
105 e_ptr
= n_ptr
+ chunk_len
+ eol_len
;
112 static inline int php_http_inflate_rounds(z_stream
*Z
, int flush
, char **buf
, size_t *len
)
114 int status
= 0, round
= 0;
115 php_http_buffer_t buffer
;
120 php_http_buffer_init_ex(&buffer
, Z
->avail_in
, PHP_HTTP_BUFFER_INIT_PREALLOC
);
123 if (PHP_HTTP_BUFFER_NOMEM
== php_http_buffer_resize_ex(&buffer
, buffer
.size
, 0, 1)) {
124 status
= Z_MEM_ERROR
;
126 Z
->avail_out
= buffer
.free
;
127 Z
->next_out
= (Bytef
*) buffer
.data
+ buffer
.used
;
129 fprintf(stderr
, "\n%3d: %3d PRIOR: size=%7lu,\tfree=%7lu,\tused=%7lu,\tavail_in=%7lu,\tavail_out=%7lu\n", round
, status
, buffer
.size
, buffer
.free
, buffer
.used
, Z
->avail_in
, Z
->avail_out
);
131 status
= inflate(Z
, flush
);
132 php_http_buffer_account(&buffer
, buffer
.free
- Z
->avail_out
);
134 fprintf(stderr
, "%3d: %3d AFTER: size=%7lu,\tfree=%7lu,\tused=%7lu,\tavail_in=%7lu,\tavail_out=%7lu\n", round
, status
, buffer
.size
, buffer
.free
, buffer
.used
, Z
->avail_in
, Z
->avail_out
);
136 PHP_HTTP_INFLATE_BUFFER_SIZE_ALIGN(buffer
.size
);
138 } while ((Z_BUF_ERROR
== status
|| (Z_OK
== status
&& Z
->avail_in
)) && ++round
< PHP_HTTP_INFLATE_ROUNDS
);
140 if (status
== Z_OK
|| status
== Z_STREAM_END
) {
141 php_http_buffer_shrink(&buffer
);
142 php_http_buffer_fix(&buffer
);
146 php_http_buffer_dtor(&buffer
);
152 ZEND_RESULT_CODE
php_http_encoding_deflate(int flags
, const char *data
, size_t data_len
, char **encoded
, size_t *encoded_len TSRMLS_DC
)
154 int status
, level
, wbits
, strategy
;
157 PHP_HTTP_DEFLATE_LEVEL_SET(flags
, level
);
158 PHP_HTTP_DEFLATE_WBITS_SET(flags
, wbits
);
159 PHP_HTTP_DEFLATE_STRATEGY_SET(flags
, strategy
);
161 memset(&Z
, 0, sizeof(z_stream
));
165 status
= deflateInit2(&Z
, level
, Z_DEFLATED
, wbits
, MAX_MEM_LEVEL
, strategy
);
166 if (Z_OK
== status
) {
167 *encoded_len
= PHP_HTTP_DEFLATE_BUFFER_SIZE_GUESS(data_len
);
168 *encoded
= emalloc(*encoded_len
);
170 Z
.next_in
= (Bytef
*) data
;
171 Z
.next_out
= (Bytef
*) *encoded
;
172 Z
.avail_in
= data_len
;
173 Z
.avail_out
= *encoded_len
;
175 status
= deflate(&Z
, Z_FINISH
);
178 if (Z_STREAM_END
== status
) {
179 /* size buffer down to actual length */
180 *encoded
= erealloc(*encoded
, Z
.total_out
+ 1);
181 (*encoded
)[*encoded_len
= Z
.total_out
] = '\0';
184 PTR_SET(*encoded
, NULL
);
189 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Could not deflate data: %s", zError(status
));
193 ZEND_RESULT_CODE
php_http_encoding_inflate(const char *data
, size_t data_len
, char **decoded
, size_t *decoded_len TSRMLS_DC
)
196 int status
, wbits
= PHP_HTTP_WINDOW_BITS_ANY
;
198 memset(&Z
, 0, sizeof(z_stream
));
201 status
= inflateInit2(&Z
, wbits
);
202 if (Z_OK
== status
) {
203 Z
.next_in
= (Bytef
*) data
;
204 Z
.avail_in
= data_len
+ 1; /* include the terminating NULL, see #61287 */
206 switch (status
= php_http_inflate_rounds(&Z
, Z_NO_FLUSH
, decoded
, decoded_len
)) {
212 status
= Z_DATA_ERROR
;
216 /* raw deflated data? */
217 if (PHP_HTTP_WINDOW_BITS_ANY
== wbits
) {
219 wbits
= PHP_HTTP_WINDOW_BITS_RAW
;
220 goto retry_raw_inflate
;
226 if (*decoded_len
&& *decoded
) {
231 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Could not inflate data: %s", zError(status
));
235 php_http_encoding_stream_t
*php_http_encoding_stream_init(php_http_encoding_stream_t
*s
, php_http_encoding_stream_ops_t
*ops
, unsigned flags TSRMLS_DC
)
240 s
= pemalloc(sizeof(*s
), (flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
));
242 memset(s
, 0, sizeof(*s
));
245 TSRMLS_SET_CTX(s
->ts
);
247 if ((s
->ops
= ops
)) {
248 php_http_encoding_stream_t
*ss
= s
->ops
->init(s
);
258 pefree(s
, (flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
));
263 php_http_encoding_stream_t
*php_http_encoding_stream_copy(php_http_encoding_stream_t
*from
, php_http_encoding_stream_t
*to
)
265 TSRMLS_FETCH_FROM_CTX(from
->ts
);
267 if (from
->ops
->copy
) {
268 php_http_encoding_stream_t
*ns
;
271 to
= pemalloc(sizeof(*to
), (from
->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
));
273 memset(to
, 0, sizeof(*to
));
275 to
->flags
= from
->flags
;
277 TSRMLS_SET_CTX(to
->ts
);
279 if ((ns
= to
->ops
->copy(from
, to
))) {
289 ZEND_RESULT_CODE
php_http_encoding_stream_reset(php_http_encoding_stream_t
**s
)
291 php_http_encoding_stream_t
*ss
;
292 if ((*s
)->ops
->dtor
) {
295 if ((ss
= (*s
)->ops
->init(*s
))) {
302 ZEND_RESULT_CODE
php_http_encoding_stream_update(php_http_encoding_stream_t
*s
, const char *in_str
, size_t in_len
, char **out_str
, size_t *out_len
)
304 if (!s
->ops
->update
) {
307 return s
->ops
->update(s
, in_str
, in_len
, out_str
, out_len
);
310 ZEND_RESULT_CODE
php_http_encoding_stream_flush(php_http_encoding_stream_t
*s
, char **out_str
, size_t *out_len
)
312 if (!s
->ops
->flush
) {
317 return s
->ops
->flush(s
, out_str
, out_len
);
320 zend_bool
php_http_encoding_stream_done(php_http_encoding_stream_t
*s
)
325 return s
->ops
->done(s
);
328 ZEND_RESULT_CODE
php_http_encoding_stream_finish(php_http_encoding_stream_t
*s
, char **out_str
, size_t *out_len
)
330 if (!s
->ops
->finish
) {
335 return s
->ops
->finish(s
, out_str
, out_len
);
338 void php_http_encoding_stream_dtor(php_http_encoding_stream_t
*s
)
345 void php_http_encoding_stream_free(php_http_encoding_stream_t
**s
)
348 if ((*s
)->ops
->dtor
) {
351 pefree(*s
, ((*s
)->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
));
357 php_http_buffer_t buffer
;
362 static php_http_encoding_stream_t
*deflate_init(php_http_encoding_stream_t
*s
)
364 int status
, level
, wbits
, strategy
, p
= (s
->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
);
365 z_streamp ctx
= pecalloc(1, sizeof(z_stream
), p
);
366 TSRMLS_FETCH_FROM_CTX(s
->ts
);
368 PHP_HTTP_DEFLATE_LEVEL_SET(s
->flags
, level
);
369 PHP_HTTP_DEFLATE_WBITS_SET(s
->flags
, wbits
);
370 PHP_HTTP_DEFLATE_STRATEGY_SET(s
->flags
, strategy
);
372 if (Z_OK
== (status
= deflateInit2(ctx
, level
, Z_DEFLATED
, wbits
, MAX_MEM_LEVEL
, strategy
))) {
373 if ((ctx
->opaque
= php_http_buffer_init_ex(NULL
, PHP_HTTP_DEFLATE_BUFFER_SIZE
, p
? PHP_HTTP_BUFFER_INIT_PERSISTENT
: 0))) {
378 status
= Z_MEM_ERROR
;
381 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to initialize deflate encoding stream: %s", zError(status
));
385 static php_http_encoding_stream_t
*inflate_init(php_http_encoding_stream_t
*s
)
387 int status
, wbits
, p
= (s
->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
);
388 z_streamp ctx
= pecalloc(1, sizeof(z_stream
), p
);
389 TSRMLS_FETCH_FROM_CTX(s
->ts
);
391 PHP_HTTP_INFLATE_WBITS_SET(s
->flags
, wbits
);
393 if (Z_OK
== (status
= inflateInit2(ctx
, wbits
))) {
394 if ((ctx
->opaque
= php_http_buffer_init_ex(NULL
, PHP_HTTP_DEFLATE_BUFFER_SIZE
, p
? PHP_HTTP_BUFFER_INIT_PERSISTENT
: 0))) {
399 status
= Z_MEM_ERROR
;
402 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to initialize inflate stream: %s", zError(status
));
406 static php_http_encoding_stream_t
*dechunk_init(php_http_encoding_stream_t
*s
)
408 struct dechunk_ctx
*ctx
= pecalloc(1, sizeof(*ctx
), (s
->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
));
410 if (!php_http_buffer_init_ex(&ctx
->buffer
, PHP_HTTP_BUFFER_DEFAULT_SIZE
, (s
->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
) ? PHP_HTTP_BUFFER_INIT_PERSISTENT
: 0)) {
421 static php_http_encoding_stream_t
*deflate_copy(php_http_encoding_stream_t
*from
, php_http_encoding_stream_t
*to
)
423 int status
, p
= to
->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
;
424 z_streamp from_ctx
= from
->ctx
, to_ctx
= pecalloc(1, sizeof(*to_ctx
), p
);
425 TSRMLS_FETCH_FROM_CTX(from
->ts
);
427 if (Z_OK
== (status
= deflateCopy(to_ctx
, from_ctx
))) {
428 if ((to_ctx
->opaque
= php_http_buffer_init_ex(NULL
, PHP_HTTP_DEFLATE_BUFFER_SIZE
, p
? PHP_HTTP_BUFFER_INIT_PERSISTENT
: 0))) {
429 php_http_buffer_append(to_ctx
->opaque
, PHP_HTTP_BUFFER(from_ctx
->opaque
)->data
, PHP_HTTP_BUFFER(from_ctx
->opaque
)->used
);
434 status
= Z_MEM_ERROR
;
436 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to copy deflate encoding stream: %s", zError(status
));
440 static php_http_encoding_stream_t
*inflate_copy(php_http_encoding_stream_t
*from
, php_http_encoding_stream_t
*to
)
442 int status
, p
= from
->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
;
443 z_streamp from_ctx
= from
->ctx
, to_ctx
= pecalloc(1, sizeof(*to_ctx
), p
);
444 TSRMLS_FETCH_FROM_CTX(from
->ts
);
446 if (Z_OK
== (status
= inflateCopy(to_ctx
, from_ctx
))) {
447 if ((to_ctx
->opaque
= php_http_buffer_init_ex(NULL
, PHP_HTTP_DEFLATE_BUFFER_SIZE
, p
? PHP_HTTP_BUFFER_INIT_PERSISTENT
: 0))) {
448 php_http_buffer_append(to_ctx
->opaque
, PHP_HTTP_BUFFER(from_ctx
->opaque
)->data
, PHP_HTTP_BUFFER(from_ctx
->opaque
)->used
);
453 status
= Z_MEM_ERROR
;
455 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to copy inflate encoding stream: %s", zError(status
));
459 static php_http_encoding_stream_t
*dechunk_copy(php_http_encoding_stream_t
*from
, php_http_encoding_stream_t
*to
)
461 int p
= from
->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
;
462 struct dechunk_ctx
*from_ctx
= from
->ctx
, *to_ctx
= pemalloc(sizeof(*to_ctx
), p
);
463 TSRMLS_FETCH_FROM_CTX(from
->ts
);
465 if (php_http_buffer_init_ex(&to_ctx
->buffer
, PHP_HTTP_BUFFER_DEFAULT_SIZE
, p
? PHP_HTTP_BUFFER_INIT_PERSISTENT
: 0)) {
466 to_ctx
->hexlen
= from_ctx
->hexlen
;
467 to_ctx
->zeroed
= from_ctx
->zeroed
;
468 php_http_buffer_append(&to_ctx
->buffer
, from_ctx
->buffer
.data
, from_ctx
->buffer
.used
);
473 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to copy inflate encoding stream: out of memory");
477 static ZEND_RESULT_CODE
deflate_update(php_http_encoding_stream_t
*s
, const char *data
, size_t data_len
, char **encoded
, size_t *encoded_len
)
480 z_streamp ctx
= s
->ctx
;
481 TSRMLS_FETCH_FROM_CTX(s
->ts
);
483 /* append input to our buffer */
484 php_http_buffer_append(PHP_HTTP_BUFFER(ctx
->opaque
), data
, data_len
);
486 ctx
->next_in
= (Bytef
*) PHP_HTTP_BUFFER(ctx
->opaque
)->data
;
487 ctx
->avail_in
= PHP_HTTP_BUFFER(ctx
->opaque
)->used
;
490 *encoded_len
= PHP_HTTP_DEFLATE_BUFFER_SIZE_GUESS(data_len
);
491 *encoded
= emalloc(*encoded_len
);
492 ctx
->avail_out
= *encoded_len
;
493 ctx
->next_out
= (Bytef
*) *encoded
;
495 switch (status
= deflate(ctx
, PHP_HTTP_ENCODING_STREAM_FLUSH_FLAG(s
->flags
))) {
498 /* cut processed chunk off the buffer */
500 php_http_buffer_cut(PHP_HTTP_BUFFER(ctx
->opaque
), 0, PHP_HTTP_BUFFER(ctx
->opaque
)->used
- ctx
->avail_in
);
502 php_http_buffer_reset(PHP_HTTP_BUFFER(ctx
->opaque
));
505 /* size buffer down to actual size */
506 *encoded_len
-= ctx
->avail_out
;
507 *encoded
= erealloc(*encoded
, *encoded_len
+ 1);
508 (*encoded
)[*encoded_len
] = '\0';
512 PTR_SET(*encoded
, NULL
);
514 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to update deflate stream: %s", zError(status
));
518 static ZEND_RESULT_CODE
inflate_update(php_http_encoding_stream_t
*s
, const char *data
, size_t data_len
, char **decoded
, size_t *decoded_len
)
521 z_streamp ctx
= s
->ctx
;
522 TSRMLS_FETCH_FROM_CTX(s
->ts
);
524 /* append input to buffer */
525 php_http_buffer_append(PHP_HTTP_BUFFER(ctx
->opaque
), data
, data_len
);
528 ctx
->next_in
= (Bytef
*) PHP_HTTP_BUFFER(ctx
->opaque
)->data
;
529 ctx
->avail_in
= PHP_HTTP_BUFFER(ctx
->opaque
)->used
;
531 switch (status
= php_http_inflate_rounds(ctx
, PHP_HTTP_ENCODING_STREAM_FLUSH_FLAG(s
->flags
), decoded
, decoded_len
)) {
536 php_http_buffer_cut(PHP_HTTP_BUFFER(ctx
->opaque
), 0, PHP_HTTP_BUFFER(ctx
->opaque
)->used
- ctx
->avail_in
);
538 php_http_buffer_reset(PHP_HTTP_BUFFER(ctx
->opaque
));
543 /* raw deflated data ? */
544 if (!(s
->flags
& PHP_HTTP_INFLATE_TYPE_RAW
) && !ctx
->total_out
) {
546 s
->flags
|= PHP_HTTP_INFLATE_TYPE_RAW
;
547 inflateInit2(ctx
, PHP_HTTP_WINDOW_BITS_RAW
);
548 goto retry_raw_inflate
;
553 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to update inflate stream: %s", zError(status
));
557 static ZEND_RESULT_CODE
dechunk_update(php_http_encoding_stream_t
*s
, const char *data
, size_t data_len
, char **decoded
, size_t *decoded_len
)
559 php_http_buffer_t tmp
;
560 struct dechunk_ctx
*ctx
= s
->ctx
;
561 TSRMLS_FETCH_FROM_CTX(s
->ts
);
564 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Dechunk encoding stream has already reached the end of chunked input");
567 if ((PHP_HTTP_BUFFER_NOMEM
== php_http_buffer_append(&ctx
->buffer
, data
, data_len
)) || !php_http_buffer_fix(&ctx
->buffer
)) {
575 php_http_buffer_init(&tmp
);
577 /* we have data in our buffer */
578 while (ctx
->buffer
.used
) {
580 /* we already know the size of the chunk and are waiting for data */
583 /* not enough data buffered */
584 if (ctx
->buffer
.used
< ctx
->hexlen
) {
587 if (s
->flags
& PHP_HTTP_ENCODING_STREAM_FLUSH_FULL
) {
588 /* flush all data (should only be chunk data) */
589 php_http_buffer_append(&tmp
, ctx
->buffer
.data
, ctx
->buffer
.used
);
590 /* waiting for less data now */
591 ctx
->hexlen
-= ctx
->buffer
.used
;
592 /* no more buffered data */
593 php_http_buffer_reset(&ctx
->buffer
);
597 /* we have too less data and don't need to flush */
603 /* we seem to have all data of the chunk */
605 php_http_buffer_append(&tmp
, ctx
->buffer
.data
, ctx
->hexlen
);
606 /* remove outgoing data from the buffer */
607 php_http_buffer_cut(&ctx
->buffer
, 0, ctx
->hexlen
);
614 /* we don't know the length of the chunk yet */
618 /* ignore preceeding CRLFs (too loose?) */
619 while (off
< ctx
->buffer
.used
&& (
620 ctx
->buffer
.data
[off
] == '\n' ||
621 ctx
->buffer
.data
[off
] == '\r')) {
625 php_http_buffer_cut(&ctx
->buffer
, 0, off
);
628 /* still data there? */
629 if (ctx
->buffer
.used
) {
633 /* we need eol, so we can be sure we have all hex digits */
634 php_http_buffer_fix(&ctx
->buffer
);
635 if ((eolstr
= php_http_locate_bin_eol(ctx
->buffer
.data
, ctx
->buffer
.used
, &eollen
))) {
638 /* read in chunk size */
639 ctx
->hexlen
= strtoul(ctx
->buffer
.data
, &stop
, 16);
641 /* if strtoul() stops at the beginning of the buffered data
642 there's something oddly wrong, i.e. bad input */
643 if (stop
== ctx
->buffer
.data
) {
644 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to parse chunk len from '%.*s'", (int) MIN(16, ctx
->buffer
.used
), ctx
->buffer
.data
);
645 php_http_buffer_dtor(&tmp
);
649 /* cut out <chunk size hex><chunk extension><eol> */
650 php_http_buffer_cut(&ctx
->buffer
, 0, eolstr
+ eollen
- ctx
->buffer
.data
);
651 /* buffer->hexlen is 0 now or contains the size of the next chunk */
655 /* ignore following CRLFs (too loose?) */
656 while (off
< ctx
->buffer
.used
&& (
657 ctx
->buffer
.data
[off
] == '\n' ||
658 ctx
->buffer
.data
[off
] == '\r')) {
662 php_http_buffer_cut(&ctx
->buffer
, 0, off
);
670 /* we have not enough data buffered to read in chunk size */
678 php_http_buffer_fix(&tmp
);
680 *decoded_len
= tmp
.used
;
685 static ZEND_RESULT_CODE
deflate_flush(php_http_encoding_stream_t
*s
, char **encoded
, size_t *encoded_len
)
688 z_streamp ctx
= s
->ctx
;
689 TSRMLS_FETCH_FROM_CTX(s
->ts
);
691 *encoded_len
= PHP_HTTP_DEFLATE_BUFFER_SIZE
;
692 *encoded
= emalloc(*encoded_len
);
696 ctx
->avail_out
= *encoded_len
;
697 ctx
->next_out
= (Bytef
*) *encoded
;
699 switch (status
= deflate(ctx
, Z_FULL_FLUSH
)) {
702 *encoded_len
= PHP_HTTP_DEFLATE_BUFFER_SIZE
- ctx
->avail_out
;
703 *encoded
= erealloc(*encoded
, *encoded_len
+ 1);
704 (*encoded
)[*encoded_len
] = '\0';
708 PTR_SET(*encoded
, NULL
);
710 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to flush deflate stream: %s", zError(status
));
714 static ZEND_RESULT_CODE
dechunk_flush(php_http_encoding_stream_t
*s
, char **decoded
, size_t *decoded_len
)
716 struct dechunk_ctx
*ctx
= s
->ctx
;
719 /* flush all data (should only be chunk data) */
720 php_http_buffer_fix(&ctx
->buffer
);
721 php_http_buffer_data(&ctx
->buffer
, decoded
, decoded_len
);
722 /* waiting for less data now */
723 ctx
->hexlen
-= ctx
->buffer
.used
;
724 /* no more buffered data */
725 php_http_buffer_reset(&ctx
->buffer
);
734 static ZEND_RESULT_CODE
deflate_finish(php_http_encoding_stream_t
*s
, char **encoded
, size_t *encoded_len
)
737 z_streamp ctx
= s
->ctx
;
738 TSRMLS_FETCH_FROM_CTX(s
->ts
);
740 *encoded_len
= PHP_HTTP_DEFLATE_BUFFER_SIZE
;
741 *encoded
= emalloc(*encoded_len
);
743 /* deflate remaining input */
744 ctx
->next_in
= (Bytef
*) PHP_HTTP_BUFFER(ctx
->opaque
)->data
;
745 ctx
->avail_in
= PHP_HTTP_BUFFER(ctx
->opaque
)->used
;
747 ctx
->avail_out
= *encoded_len
;
748 ctx
->next_out
= (Bytef
*) *encoded
;
751 status
= deflate(ctx
, Z_FINISH
);
752 } while (Z_OK
== status
);
754 if (Z_STREAM_END
== status
) {
755 /* cut processed input off */
756 php_http_buffer_cut(PHP_HTTP_BUFFER(ctx
->opaque
), 0, PHP_HTTP_BUFFER(ctx
->opaque
)->used
- ctx
->avail_in
);
759 *encoded_len
-= ctx
->avail_out
;
760 *encoded
= erealloc(*encoded
, *encoded_len
+ 1);
761 (*encoded
)[*encoded_len
] = '\0';
765 PTR_SET(*encoded
, NULL
);
767 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to finish deflate stream: %s", zError(status
));
771 static ZEND_RESULT_CODE
inflate_finish(php_http_encoding_stream_t
*s
, char **decoded
, size_t *decoded_len
)
774 z_streamp ctx
= s
->ctx
;
775 TSRMLS_FETCH_FROM_CTX(s
->ts
);
777 if (!PHP_HTTP_BUFFER(ctx
->opaque
)->used
) {
783 *decoded_len
= (PHP_HTTP_BUFFER(ctx
->opaque
)->used
+ 1) * PHP_HTTP_INFLATE_ROUNDS
;
784 *decoded
= emalloc(*decoded_len
);
786 /* inflate remaining input */
787 ctx
->next_in
= (Bytef
*) PHP_HTTP_BUFFER(ctx
->opaque
)->data
;
788 ctx
->avail_in
= PHP_HTTP_BUFFER(ctx
->opaque
)->used
;
790 ctx
->avail_out
= *decoded_len
;
791 ctx
->next_out
= (Bytef
*) *decoded
;
793 if (Z_STREAM_END
== (status
= inflate(ctx
, Z_FINISH
))) {
794 /* cut processed input off */
795 php_http_buffer_cut(PHP_HTTP_BUFFER(ctx
->opaque
), 0, PHP_HTTP_BUFFER(ctx
->opaque
)->used
- ctx
->avail_in
);
798 *decoded_len
-= ctx
->avail_out
;
799 *decoded
= erealloc(*decoded
, *decoded_len
+ 1);
800 (*decoded
)[*decoded_len
] = '\0';
804 PTR_SET(*decoded
, NULL
);
806 php_error_docref(NULL TSRMLS_CC
, E_WARNING
, "Failed to finish inflate stream: %s", zError(status
));
810 static zend_bool
deflate_done(php_http_encoding_stream_t
*s
)
812 z_streamp ctx
= s
->ctx
;
813 return !ctx
->avail_in
&& !PHP_HTTP_BUFFER(ctx
->opaque
)->used
;
816 static zend_bool
inflate_done(php_http_encoding_stream_t
*s
)
818 z_streamp ctx
= s
->ctx
;
819 return !ctx
->avail_in
&& !PHP_HTTP_BUFFER(ctx
->opaque
)->used
;
822 static zend_bool
dechunk_done(php_http_encoding_stream_t
*s
)
824 return ((struct dechunk_ctx
*) s
->ctx
)->zeroed
;
827 static void deflate_dtor(php_http_encoding_stream_t
*s
)
830 z_streamp ctx
= s
->ctx
;
833 php_http_buffer_free((php_http_buffer_t
**) &ctx
->opaque
);
836 pefree(ctx
, (s
->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
));
841 static void inflate_dtor(php_http_encoding_stream_t
*s
)
844 z_streamp ctx
= s
->ctx
;
847 php_http_buffer_free((php_http_buffer_t
**) &ctx
->opaque
);
850 pefree(ctx
, (s
->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
));
855 static void dechunk_dtor(php_http_encoding_stream_t
*s
)
858 struct dechunk_ctx
*ctx
= s
->ctx
;
860 php_http_buffer_dtor(&ctx
->buffer
);
861 pefree(ctx
, (s
->flags
& PHP_HTTP_ENCODING_STREAM_PERSISTENT
));
866 static php_http_encoding_stream_ops_t php_http_encoding_deflate_ops
= {
876 php_http_encoding_stream_ops_t
*php_http_encoding_stream_get_deflate_ops(void)
878 return &php_http_encoding_deflate_ops
;
881 static php_http_encoding_stream_ops_t php_http_encoding_inflate_ops
= {
891 php_http_encoding_stream_ops_t
*php_http_encoding_stream_get_inflate_ops(void)
893 return &php_http_encoding_inflate_ops
;
896 static php_http_encoding_stream_ops_t php_http_encoding_dechunk_ops
= {
906 php_http_encoding_stream_ops_t
*php_http_encoding_stream_get_dechunk_ops(void)
908 return &php_http_encoding_dechunk_ops
;
911 static zend_object_handlers php_http_encoding_stream_object_handlers
;
913 zend_object_value
php_http_encoding_stream_object_new(zend_class_entry
*ce TSRMLS_DC
)
915 return php_http_encoding_stream_object_new_ex(ce
, NULL
, NULL TSRMLS_CC
);
918 zend_object_value
php_http_encoding_stream_object_new_ex(zend_class_entry
*ce
, php_http_encoding_stream_t
*s
, php_http_encoding_stream_object_t
**ptr TSRMLS_DC
)
920 php_http_encoding_stream_object_t
*o
;
922 o
= ecalloc(1, sizeof(*o
));
923 zend_object_std_init((zend_object
*) o
, ce TSRMLS_CC
);
924 object_properties_init((zend_object
*) o
, ce
);
934 o
->zv
.handle
= zend_objects_store_put((zend_object
*) o
, NULL
, php_http_encoding_stream_object_free
, NULL TSRMLS_CC
);
935 o
->zv
.handlers
= &php_http_encoding_stream_object_handlers
;
940 zend_object_value
php_http_encoding_stream_object_clone(zval
*this_ptr TSRMLS_DC
)
942 zend_object_value new_ov
;
943 php_http_encoding_stream_object_t
*new_obj
= NULL
, *old_obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
945 new_ov
= php_http_encoding_stream_object_new_ex(old_obj
->zo
.ce
, php_http_encoding_stream_copy(old_obj
->stream
, NULL
), &new_obj TSRMLS_CC
);
946 zend_objects_clone_members(&new_obj
->zo
, new_ov
, &old_obj
->zo
, Z_OBJ_HANDLE_P(this_ptr
) TSRMLS_CC
);
951 void php_http_encoding_stream_object_free(void *object TSRMLS_DC
)
953 php_http_encoding_stream_object_t
*o
= (php_http_encoding_stream_object_t
*) object
;
956 php_http_encoding_stream_free(&o
->stream
);
958 zend_object_std_dtor((zend_object
*) o TSRMLS_CC
);
962 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEncodingStream___construct
, 0, 0, 0)
963 ZEND_ARG_INFO(0, flags
)
965 static PHP_METHOD(HttpEncodingStream
, __construct
)
968 php_http_encoding_stream_object_t
*obj
;
969 php_http_encoding_stream_ops_t
*ops
;
971 php_http_expect(SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "|l", &flags
), invalid_arg
, return);
973 obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
976 php_http_throw(bad_method_call
, "http\\Encoding\\Stream cannot be initialized twice", NULL
);
980 if (instanceof_function(obj
->zo
.ce
, php_http_deflate_stream_class_entry TSRMLS_CC
)) {
981 ops
= &php_http_encoding_deflate_ops
;
982 } else if (instanceof_function(obj
->zo
.ce
, php_http_inflate_stream_class_entry TSRMLS_CC
)) {
983 ops
= &php_http_encoding_inflate_ops
;
984 } else if (instanceof_function(obj
->zo
.ce
, php_http_dechunk_stream_class_entry TSRMLS_CC
)) {
985 ops
= &php_http_encoding_dechunk_ops
;
987 php_http_throw(runtime
, "Unknown http\\Encoding\\Stream class '%s'", obj
->zo
.ce
->name
);
991 php_http_expect(obj
->stream
= php_http_encoding_stream_init(obj
->stream
, ops
, flags TSRMLS_CC
), runtime
, return);
994 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEncodingStream_update
, 0, 0, 1)
995 ZEND_ARG_INFO(0, data
)
997 static PHP_METHOD(HttpEncodingStream
, update
)
1002 if (SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &data_str
, &data_len
)) {
1003 php_http_encoding_stream_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1009 if (SUCCESS
== php_http_encoding_stream_update(obj
->stream
, data_str
, data_len
, &encoded_str
, &encoded_len
)) {
1010 RETURN_STRINGL(encoded_str
, encoded_len
, 0);
1016 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEncodingStream_flush
, 0, 0, 0)
1017 ZEND_END_ARG_INFO();
1018 static PHP_METHOD(HttpEncodingStream
, flush
)
1020 if (SUCCESS
== zend_parse_parameters_none()) {
1021 php_http_encoding_stream_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1027 if (SUCCESS
== php_http_encoding_stream_flush(obj
->stream
, &encoded_str
, &encoded_len
)) {
1029 RETURN_STRINGL(encoded_str
, encoded_len
, 0);
1031 RETURN_EMPTY_STRING();
1038 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEncodingStream_done
, 0, 0, 0)
1039 ZEND_END_ARG_INFO();
1040 static PHP_METHOD(HttpEncodingStream
, done
)
1042 if (SUCCESS
== zend_parse_parameters_none()) {
1043 php_http_encoding_stream_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1046 RETURN_BOOL(php_http_encoding_stream_done(obj
->stream
));
1051 ZEND_BEGIN_ARG_INFO_EX(ai_HttpEncodingStream_finish
, 0, 0, 0)
1052 ZEND_END_ARG_INFO();
1053 static PHP_METHOD(HttpEncodingStream
, finish
)
1055 if (SUCCESS
== zend_parse_parameters_none()) {
1056 php_http_encoding_stream_object_t
*obj
= zend_object_store_get_object(getThis() TSRMLS_CC
);
1062 if (SUCCESS
== php_http_encoding_stream_finish(obj
->stream
, &encoded_str
, &encoded_len
)) {
1063 if (SUCCESS
== php_http_encoding_stream_reset(&obj
->stream
)) {
1065 RETURN_STRINGL(encoded_str
, encoded_len
, 0);
1067 RETURN_EMPTY_STRING();
1070 PTR_FREE(encoded_str
);
1077 static zend_function_entry php_http_encoding_stream_methods
[] = {
1078 PHP_ME(HttpEncodingStream
, __construct
, ai_HttpEncodingStream___construct
, ZEND_ACC_PUBLIC
|ZEND_ACC_CTOR
)
1079 PHP_ME(HttpEncodingStream
, update
, ai_HttpEncodingStream_update
, ZEND_ACC_PUBLIC
)
1080 PHP_ME(HttpEncodingStream
, flush
, ai_HttpEncodingStream_flush
, ZEND_ACC_PUBLIC
)
1081 PHP_ME(HttpEncodingStream
, done
, ai_HttpEncodingStream_done
, ZEND_ACC_PUBLIC
)
1082 PHP_ME(HttpEncodingStream
, finish
, ai_HttpEncodingStream_finish
, ZEND_ACC_PUBLIC
)
1083 EMPTY_FUNCTION_ENTRY
1086 ZEND_BEGIN_ARG_INFO_EX(ai_HttpDeflateStream_encode
, 0, 0, 1)
1087 ZEND_ARG_INFO(0, data
)
1088 ZEND_ARG_INFO(0, flags
)
1089 ZEND_END_ARG_INFO();
1090 static PHP_METHOD(HttpDeflateStream
, encode
)
1096 if (SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s|l", &str
, &len
, &flags
)) {
1100 if (SUCCESS
== php_http_encoding_deflate(flags
, str
, len
, &enc_str
, &enc_len TSRMLS_CC
)) {
1101 RETURN_STRINGL(enc_str
, enc_len
, 0);
1107 static zend_function_entry php_http_deflate_stream_methods
[] = {
1108 PHP_ME(HttpDeflateStream
, encode
, ai_HttpDeflateStream_encode
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
1109 EMPTY_FUNCTION_ENTRY
1112 ZEND_BEGIN_ARG_INFO_EX(ai_HttpInflateStream_decode
, 0, 0, 1)
1113 ZEND_ARG_INFO(0, data
)
1114 ZEND_END_ARG_INFO();
1115 static PHP_METHOD(HttpInflateStream
, decode
)
1120 if (SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s", &str
, &len
)) {
1124 if (SUCCESS
== php_http_encoding_inflate(str
, len
, &enc_str
, &enc_len TSRMLS_CC
)) {
1125 RETURN_STRINGL(enc_str
, enc_len
, 0);
1131 static zend_function_entry php_http_inflate_stream_methods
[] = {
1132 PHP_ME(HttpInflateStream
, decode
, ai_HttpInflateStream_decode
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
1133 EMPTY_FUNCTION_ENTRY
1136 ZEND_BEGIN_ARG_INFO_EX(ai_HttpDechunkStream_decode
, 0, 0, 1)
1137 ZEND_ARG_INFO(0, data
)
1138 ZEND_ARG_INFO(1, decoded_len
)
1139 ZEND_END_ARG_INFO();
1140 static PHP_METHOD(HttpDechunkStream
, decode
)
1146 if (SUCCESS
== zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC
, "s|z!", &str
, &len
, &zlen
)) {
1147 const char *end_ptr
;
1151 if ((end_ptr
= php_http_encoding_dechunk(str
, len
, &enc_str
, &enc_len TSRMLS_CC
))) {
1154 ZVAL_LONG(zlen
, str
+ len
- end_ptr
);
1156 RETURN_STRINGL(enc_str
, enc_len
, 0);
1162 static zend_function_entry php_http_dechunk_stream_methods
[] = {
1163 PHP_ME(HttpDechunkStream
, decode
, ai_HttpDechunkStream_decode
, ZEND_ACC_PUBLIC
|ZEND_ACC_STATIC
)
1164 EMPTY_FUNCTION_ENTRY
1167 zend_class_entry
*php_http_encoding_stream_class_entry
;
1168 zend_class_entry
*php_http_deflate_stream_class_entry
;
1169 zend_class_entry
*php_http_inflate_stream_class_entry
;
1170 zend_class_entry
*php_http_dechunk_stream_class_entry
;
1172 PHP_MINIT_FUNCTION(http_encoding
)
1174 zend_class_entry ce
= {0};
1176 INIT_NS_CLASS_ENTRY(ce
, "http\\Encoding", "Stream", php_http_encoding_stream_methods
);
1177 php_http_encoding_stream_class_entry
= zend_register_internal_class(&ce TSRMLS_CC
);
1178 php_http_encoding_stream_class_entry
->ce_flags
|= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS
;
1179 php_http_encoding_stream_class_entry
->create_object
= php_http_encoding_stream_object_new
;
1180 memcpy(&php_http_encoding_stream_object_handlers
, zend_get_std_object_handlers(), sizeof(zend_object_handlers
));
1181 php_http_encoding_stream_object_handlers
.clone_obj
= php_http_encoding_stream_object_clone
;
1183 zend_declare_class_constant_long(php_http_encoding_stream_class_entry
, ZEND_STRL("FLUSH_NONE"), PHP_HTTP_ENCODING_STREAM_FLUSH_NONE TSRMLS_CC
);
1184 zend_declare_class_constant_long(php_http_encoding_stream_class_entry
, ZEND_STRL("FLUSH_SYNC"), PHP_HTTP_ENCODING_STREAM_FLUSH_SYNC TSRMLS_CC
);
1185 zend_declare_class_constant_long(php_http_encoding_stream_class_entry
, ZEND_STRL("FLUSH_FULL"), PHP_HTTP_ENCODING_STREAM_FLUSH_FULL TSRMLS_CC
);
1187 memset(&ce
, 0, sizeof(ce
));
1188 INIT_NS_CLASS_ENTRY(ce
, "http\\Encoding\\Stream", "Deflate", php_http_deflate_stream_methods
);
1189 php_http_deflate_stream_class_entry
= zend_register_internal_class_ex(&ce
, php_http_encoding_stream_class_entry
, NULL TSRMLS_CC
);
1191 zend_declare_class_constant_long(php_http_deflate_stream_class_entry
, ZEND_STRL("TYPE_GZIP"), PHP_HTTP_DEFLATE_TYPE_GZIP TSRMLS_CC
);
1192 zend_declare_class_constant_long(php_http_deflate_stream_class_entry
, ZEND_STRL("TYPE_ZLIB"), PHP_HTTP_DEFLATE_TYPE_ZLIB TSRMLS_CC
);
1193 zend_declare_class_constant_long(php_http_deflate_stream_class_entry
, ZEND_STRL("TYPE_RAW"), PHP_HTTP_DEFLATE_TYPE_RAW TSRMLS_CC
);
1194 zend_declare_class_constant_long(php_http_deflate_stream_class_entry
, ZEND_STRL("LEVEL_DEF"), PHP_HTTP_DEFLATE_LEVEL_DEF TSRMLS_CC
);
1195 zend_declare_class_constant_long(php_http_deflate_stream_class_entry
, ZEND_STRL("LEVEL_MIN"), PHP_HTTP_DEFLATE_LEVEL_MIN TSRMLS_CC
);
1196 zend_declare_class_constant_long(php_http_deflate_stream_class_entry
, ZEND_STRL("LEVEL_MAX"), PHP_HTTP_DEFLATE_LEVEL_MAX TSRMLS_CC
);
1197 zend_declare_class_constant_long(php_http_deflate_stream_class_entry
, ZEND_STRL("STRATEGY_DEF"), PHP_HTTP_DEFLATE_STRATEGY_DEF TSRMLS_CC
);
1198 zend_declare_class_constant_long(php_http_deflate_stream_class_entry
, ZEND_STRL("STRATEGY_FILT"), PHP_HTTP_DEFLATE_STRATEGY_FILT TSRMLS_CC
);
1199 zend_declare_class_constant_long(php_http_deflate_stream_class_entry
, ZEND_STRL("STRATEGY_HUFF"), PHP_HTTP_DEFLATE_STRATEGY_HUFF TSRMLS_CC
);
1200 zend_declare_class_constant_long(php_http_deflate_stream_class_entry
, ZEND_STRL("STRATEGY_RLE"), PHP_HTTP_DEFLATE_STRATEGY_RLE TSRMLS_CC
);
1201 zend_declare_class_constant_long(php_http_deflate_stream_class_entry
, ZEND_STRL("STRATEGY_FIXED"), PHP_HTTP_DEFLATE_STRATEGY_FIXED TSRMLS_CC
);
1203 memset(&ce
, 0, sizeof(ce
));
1204 INIT_NS_CLASS_ENTRY(ce
, "http\\Encoding\\Stream", "Inflate", php_http_inflate_stream_methods
);
1205 php_http_inflate_stream_class_entry
= zend_register_internal_class_ex(&ce
, php_http_encoding_stream_class_entry
, NULL TSRMLS_CC
);
1207 memset(&ce
, 0, sizeof(ce
));
1208 INIT_NS_CLASS_ENTRY(ce
, "http\\Encoding\\Stream", "Dechunk", php_http_dechunk_stream_methods
);
1209 php_http_dechunk_stream_class_entry
= zend_register_internal_class_ex(&ce
, php_http_encoding_stream_class_entry
, NULL TSRMLS_CC
);
1220 * vim600: noet sw=4 ts=4 fdm=marker
1221 * vim<600: noet sw=4 ts=4