#ifdef HAVE_CONFIG_H

#include <config.h>

#include "php.h"

#include "SAPI.h"

#include "php_ini.h"

#include "ext/standard/info.h"

#include "ext/standard/file.h"

#include "php_zlib.h"

#include "zlib_arginfo.h"

#undef gzopen

#undef gzseek

#undef gztell

ZEND_DECLARE_MODULE_GLOBALS(zlib)

zend_class_entry *inflate_context_ce;

static zend_object_handlers inflate_context_object_handlers;

#define inflate_context_from_obj(obj) ZEND_CONTAINER_OF(obj, php_zlib_context, std)

#define Z_INFLATE_CONTEXT_P(zv) inflate_context_from_obj(Z_OBJ_P(zv))

static zend_object *inflate_context_create_object(zend_class_entry *class_type) {

php_zlib_context *intern = zend_object_alloc(sizeof(php_zlib_context), class_type);

zend_object_std_init(&intern->std, class_type);

object_properties_init(&intern->std, class_type);

return &intern->std;

}

static zend_function *inflate_context_get_constructor(zend_object *object) {

zend_throw_error(NULL, "Cannot directly construct InflateContext, use inflate_init() instead");

return NULL;

}

static void inflate_context_free_obj(zend_object *object)

{

php_zlib_context *intern = inflate_context_from_obj(object);

if (intern->inflateDict) {

efree(intern->inflateDict);

}

inflateEnd(&intern->Z);

zend_object_std_dtor(&intern->std);

}

zend_class_entry *deflate_context_ce;

static zend_object_handlers deflate_context_object_handlers;

#define deflate_context_from_obj(obj) ZEND_CONTAINER_OF(obj, php_zlib_context, std)

#define Z_DEFLATE_CONTEXT_P(zv) deflate_context_from_obj(Z_OBJ_P(zv))

static zend_object *deflate_context_create_object(zend_class_entry *class_type) {

php_zlib_context *intern = zend_object_alloc(sizeof(php_zlib_context), class_type);

zend_object_std_init(&intern->std, class_type);

object_properties_init(&intern->std, class_type);

return &intern->std;

}

static zend_function *deflate_context_get_constructor(zend_object *object) {

zend_throw_error(NULL, "Cannot directly construct DeflateContext, use deflate_init() instead");

return NULL;

}

static void deflate_context_free_obj(zend_object *object)

{

php_zlib_context *intern = deflate_context_from_obj(object);

deflateEnd(&intern->Z);

zend_object_std_dtor(&intern->std);

}

static voidpf php_zlib_alloc(voidpf opaque, uInt items, uInt size)

{

return (voidpf)safe_emalloc(items, size, 0);

}

static void php_zlib_free(voidpf opaque, voidpf address)

{

efree((void*)address);

}

static zend_result php_zlib_output_conflict_check(const char *handler_name, size_t handler_name_len)

{

if (php_output_get_level() > 0) {

if (php_output_handler_conflict(handler_name, handler_name_len, ZEND_STRL(PHP_ZLIB_OUTPUT_HANDLER_NAME))

|| php_output_handler_conflict(handler_name, handler_name_len, ZEND_STRL("ob_gzhandler"))

|| php_output_handler_conflict(handler_name, handler_name_len, ZEND_STRL("mb_output_handler"))

|| php_output_handler_conflict(handler_name, handler_name_len, ZEND_STRL("URL-Rewriter"))) {

return FAILURE;

}

}

return SUCCESS;

}

static int php_zlib_output_encoding(void)

{

zval *enc;

if (!ZLIBG(compression_coding)) {

if ((Z_TYPE(PG(http_globals)[TRACK_VARS_SERVER]) == IS_ARRAY || zend_is_auto_global(ZSTR_KNOWN(ZEND_STR_AUTOGLOBAL_SERVER))) &&

(enc = zend_hash_str_find(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "HTTP_ACCEPT_ENCODING", sizeof("HTTP_ACCEPT_ENCODING") - 1))) {

convert_to_string(enc);

if (strstr(Z_STRVAL_P(enc), "gzip")) {

ZLIBG(compression_coding) = PHP_ZLIB_ENCODING_GZIP;

} else if (strstr(Z_STRVAL_P(enc), "deflate")) {

ZLIBG(compression_coding) = PHP_ZLIB_ENCODING_DEFLATE;

}

}

}

return ZLIBG(compression_coding);

}

static zend_result php_zlib_output_handler_ex(php_zlib_context *ctx, php_output_context *output_context)

{

int flags = Z_SYNC_FLUSH;

if (output_context->op & PHP_OUTPUT_HANDLER_START) {

/* start up */

if (Z_OK != deflateInit2(&ctx->Z, ZLIBG(output_compression_level), Z_DEFLATED, ZLIBG(compression_coding), MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY)) {

return FAILURE;

}

}

if (output_context->op & PHP_OUTPUT_HANDLER_CLEAN) {

/* free buffers */

deflateEnd(&ctx->Z);

if (output_context->op & PHP_OUTPUT_HANDLER_FINAL) {

/* discard */

return SUCCESS;

} else {

/* restart */

if (Z_OK != deflateInit2(&ctx->Z, ZLIBG(output_compression_level), Z_DEFLATED, ZLIBG(compression_coding), MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY)) {

return FAILURE;

}

ctx->buffer.used = 0;

}

} else {

if (output_context->in.used) {

/* append input */

if (ctx->buffer.free < output_context->in.used) {

if (!(ctx->buffer.aptr = erealloc_recoverable(ctx->buffer.data, ctx->buffer.used + ctx->buffer.free + output_context->in.used))) {

deflateEnd(&ctx->Z);

return FAILURE;

}

ctx->buffer.data = ctx->buffer.aptr;

ctx->buffer.free += output_context->in.used;

}

memcpy(ctx->buffer.data + ctx->buffer.used, output_context->in.data, output_context->in.used);

ctx->buffer.free -= output_context->in.used;

ctx->buffer.used += output_context->in.used;

}

output_context->out.size = PHP_ZLIB_BUFFER_SIZE_GUESS(output_context->in.used);

output_context->out.data = emalloc(output_context->out.size);

output_context->out.free = 1;

output_context->out.used = 0;

ctx->Z.avail_in = ctx->buffer.used;

ctx->Z.next_in = (Bytef *) ctx->buffer.data;

ctx->Z.avail_out = output_context->out.size;

ctx->Z.next_out = (Bytef *) output_context->out.data;

if (output_context->op & PHP_OUTPUT_HANDLER_FINAL) {

flags = Z_FINISH;

} else if (output_context->op & PHP_OUTPUT_HANDLER_FLUSH) {

flags = Z_FULL_FLUSH;

}

switch (deflate(&ctx->Z, flags)) {

case Z_OK:

if (flags == Z_FINISH) {

deflateEnd(&ctx->Z);

return FAILURE;

}

ZEND_FALLTHROUGH;

case Z_STREAM_END:

if (ctx->Z.avail_in) {

memmove(ctx->buffer.data, ctx->buffer.data + ctx->buffer.used - ctx->Z.avail_in, ctx->Z.avail_in);

}

ctx->buffer.free += ctx->buffer.used - ctx->Z.avail_in;

ctx->buffer.used = ctx->Z.avail_in;

output_context->out.used = output_context->out.size - ctx->Z.avail_out;

break;

default:

deflateEnd(&ctx->Z);

return FAILURE;

}

if (output_context->op & PHP_OUTPUT_HANDLER_FINAL) {

deflateEnd(&ctx->Z);

}

}

return SUCCESS;

}

static zend_result php_zlib_output_handler(void **handler_context, php_output_context *output_context)

{

php_zlib_context *ctx = *(php_zlib_context **) handler_context;

if (!php_zlib_output_encoding()) {

/* "Vary: Accept-Encoding" header sent along uncompressed content breaks caching in MSIE,

if ((output_context->op & PHP_OUTPUT_HANDLER_START)

&& (output_context->op != (PHP_OUTPUT_HANDLER_START|PHP_OUTPUT_HANDLER_CLEAN|PHP_OUTPUT_HANDLER_FINAL))

) {

sapi_add_header_ex(ZEND_STRL("Vary: Accept-Encoding"), 1, 0);

}

return FAILURE;

}

if (SUCCESS != php_zlib_output_handler_ex(ctx, output_context)) {

return FAILURE;

}

if (!(output_context->op & PHP_OUTPUT_HANDLER_CLEAN) || ((output_context->op & PHP_OUTPUT_HANDLER_START) && !(output_context->op & PHP_OUTPUT_HANDLER_FINAL))) {

int flags;

if (SUCCESS == php_output_handler_hook(PHP_OUTPUT_HANDLER_HOOK_GET_FLAGS, &flags)) {

/* only run this once */

if (!(flags & PHP_OUTPUT_HANDLER_STARTED)) {

if (SG(headers_sent) || !ZLIBG(output_compression)) {

deflateEnd(&ctx->Z);

return FAILURE;

}

switch (ZLIBG(compression_coding)) {

case PHP_ZLIB_ENCODING_GZIP:

sapi_add_header_ex(ZEND_STRL("Content-Encoding: gzip"), 1, 1);

break;

case PHP_ZLIB_ENCODING_DEFLATE:

sapi_add_header_ex(ZEND_STRL("Content-Encoding: deflate"), 1, 1);

break;

default:

deflateEnd(&ctx->Z);

return FAILURE;

}

sapi_add_header_ex(ZEND_STRL("Vary: Accept-Encoding"), 1, 0);

php_output_handler_hook(PHP_OUTPUT_HANDLER_HOOK_IMMUTABLE, NULL);

}

}

}

return SUCCESS;

}

static php_zlib_context *php_zlib_output_handler_context_init(void)

{

php_zlib_context *ctx = (php_zlib_context *) ecalloc(1, sizeof(php_zlib_context));

ctx->Z.zalloc = php_zlib_alloc;

ctx->Z.zfree = php_zlib_free;

return ctx;

}

static void php_zlib_output_handler_context_dtor(void *opaq)

{

php_zlib_context *ctx = (php_zlib_context *) opaq;

if (ctx) {

if (ctx->buffer.data) {

efree(ctx->buffer.data);

}

efree(ctx);

}

}

static php_output_handler *php_zlib_output_handler_init(const char *handler_name, size_t handler_name_len, size_t chunk_size, int flags)

{

php_output_handler *h = NULL;

if (!ZLIBG(output_compression)) {

ZLIBG(output_compression) = chunk_size ? chunk_size : PHP_OUTPUT_HANDLER_DEFAULT_SIZE;

}

ZLIBG(handler_registered) = 1;

if ((h = php_output_handler_create_internal(handler_name, handler_name_len, php_zlib_output_handler, chunk_size, flags))) {

php_output_handler_set_context(h, php_zlib_output_handler_context_init(), php_zlib_output_handler_context_dtor);

}

return h;

}

static void php_zlib_output_compression_start(void)

{

zval zoh;

php_output_handler *h;

switch (ZLIBG(output_compression)) {

case 0:

break;

case 1:

ZLIBG(output_compression) = PHP_OUTPUT_HANDLER_DEFAULT_SIZE;

ZEND_FALLTHROUGH;

default:

if ( php_zlib_output_encoding() &&

(h = php_zlib_output_handler_init(ZEND_STRL(PHP_ZLIB_OUTPUT_HANDLER_NAME), ZLIBG(output_compression), PHP_OUTPUT_HANDLER_STDFLAGS)) &&

(SUCCESS == php_output_handler_start(h))) {

if (ZLIBG(output_handler) && *ZLIBG(output_handler)) {

ZVAL_STRING(&zoh, ZLIBG(output_handler));

php_output_start_user(&zoh, ZLIBG(output_compression), PHP_OUTPUT_HANDLER_STDFLAGS);

zval_ptr_dtor(&zoh);

}

}

break;

}

}

static zend_string *php_zlib_encode(const char *in_buf, size_t in_len, int encoding, int level)

{

int status;

z_stream Z;

zend_string *out;

memset(&Z, 0, sizeof(z_stream));

Z.zalloc = php_zlib_alloc;

Z.zfree = php_zlib_free;

if (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, encoding, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) {

out = zend_string_alloc(PHP_ZLIB_BUFFER_SIZE_GUESS(in_len), 0);

Z.next_in = (Bytef *) in_buf;

Z.next_out = (Bytef *) ZSTR_VAL(out);

Z.avail_in = in_len;

Z.avail_out = ZSTR_LEN(out);

status = deflate(&Z, Z_FINISH);

deflateEnd(&Z);

if (Z_STREAM_END == status) {

/* size buffer down to actual length */

out = zend_string_truncate(out, Z.total_out, 0);

ZSTR_VAL(out)[ZSTR_LEN(out)] = '\0';

return out;

} else {

zend_string_efree(out);

}

}

php_error_docref(NULL, E_WARNING, "%s", zError(status));

return NULL;

}

static inline int php_zlib_inflate_rounds(z_stream *Z, size_t max, char **buf, size_t *len)

{

int status, round = 0;

php_zlib_buffer buffer = {NULL, NULL, 0, 0, 0};

*buf = NULL;

*len = 0;

buffer.size = (max && (max < Z->avail_in)) ? max : Z->avail_in;

do {

if ((max && (max <= buffer.used)) || !(buffer.aptr = erealloc_recoverable(buffer.data, buffer.size))) {

status = Z_MEM_ERROR;

} else {

buffer.data = buffer.aptr;

Z->avail_out = buffer.free = buffer.size - buffer.used;

Z->next_out = (Bytef *) buffer.data + buffer.used;

#if 0

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);

status = inflate(Z, Z_NO_FLUSH);

buffer.used += buffer.free - Z->avail_out;

buffer.free = Z->avail_out;

#if 0

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);

buffer.size += (buffer.size >> 3) + 1;

}

} while ((Z_BUF_ERROR == status || (Z_OK == status && Z->avail_in)) && ++round < 100);

if (status == Z_STREAM_END) {

buffer.data = erealloc(buffer.data, buffer.used + 1);

buffer.data[buffer.used] = '\0';

*buf = buffer.data;

*len = buffer.used;

} else {

if (buffer.data) {

efree(buffer.data);

}

/* HACK: See zlib/examples/zpipe.c inf() function for explanation. */

/* This works as long as this function is not used for streaming. Required to catch very short invalid data. */

status = (status == Z_OK) ? Z_DATA_ERROR : status;

}

return status;

}

static int php_zlib_decode(const char *in_buf, size_t in_len, char **out_buf, size_t *out_len, int encoding, size_t max_len)

{

int status = Z_DATA_ERROR;

z_stream Z;

memset(&Z, 0, sizeof(z_stream));

Z.zalloc = php_zlib_alloc;

Z.zfree = php_zlib_free;

if (in_len) {

retry_raw_inflate:

status = inflateInit2(&Z, encoding);

if (Z_OK == status) {

Z.next_in = (Bytef *) in_buf;

Z.avail_in = in_len + 1; /* NOTE: data must be zero terminated */

switch (status = php_zlib_inflate_rounds(&Z, max_len, out_buf, out_len)) {

case Z_STREAM_END:

inflateEnd(&Z);

return SUCCESS;

case Z_DATA_ERROR:

/* raw deflated data? */

if (PHP_ZLIB_ENCODING_ANY == encoding) {

inflateEnd(&Z);

encoding = PHP_ZLIB_ENCODING_RAW;

goto retry_raw_inflate;

}

}

inflateEnd(&Z);

}

}

*out_buf = NULL;

*out_len = 0;

php_error_docref(NULL, E_WARNING, "%s", zError(status));

return FAILURE;

}

static void php_zlib_cleanup_ob_gzhandler_mess(void)

{

if (ZLIBG(ob_gzhandler)) {

deflateEnd(&(ZLIBG(ob_gzhandler)->Z));

php_zlib_output_handler_context_dtor(ZLIBG(ob_gzhandler));

ZLIBG(ob_gzhandler) = NULL;

}

}

PHP_FUNCTION(ob_gzhandler)

{

char *in_str;

size_t in_len;

zend_long flags = 0;

php_output_context ctx = {0};

int encoding;

/*

if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "sl", &in_str, &in_len, &flags)) {

RETURN_THROWS();

}

if (!(encoding = php_zlib_output_encoding())) {

RETURN_FALSE;

}

if (flags & PHP_OUTPUT_HANDLER_START) {

switch (encoding) {

case PHP_ZLIB_ENCODING_GZIP:

sapi_add_header_ex(ZEND_STRL("Content-Encoding: gzip"), 1, 1);

break;

case PHP_ZLIB_ENCODING_DEFLATE:

sapi_add_header_ex(ZEND_STRL("Content-Encoding: deflate"), 1, 1);

break;

}

sapi_add_header_ex(ZEND_STRL("Vary: Accept-Encoding"), 1, 0);

}

if (!ZLIBG(ob_gzhandler)) {

ZLIBG(ob_gzhandler) = php_zlib_output_handler_context_init();

}

ctx.op = flags;

ctx.in.data = in_str;

ctx.in.used = in_len;

zend_result rv = php_zlib_output_handler_ex(ZLIBG(ob_gzhandler), &ctx);

if (SUCCESS != rv) {

if (ctx.out.data && ctx.out.free) {

efree(ctx.out.data);

}

php_zlib_cleanup_ob_gzhandler_mess();

RETURN_FALSE;

}

if (ctx.out.data) {

RETVAL_STRINGL(ctx.out.data, ctx.out.used);

if (ctx.out.free) {

efree(ctx.out.data);

}

} else {

RETVAL_EMPTY_STRING();

}

}

PHP_FUNCTION(zlib_get_coding_type)

{

ZEND_PARSE_PARAMETERS_NONE();

switch (ZLIBG(compression_coding)) {

case PHP_ZLIB_ENCODING_GZIP:

RETURN_STRINGL("gzip", sizeof("gzip") - 1);

case PHP_ZLIB_ENCODING_DEFLATE:

RETURN_STRINGL("deflate", sizeof("deflate") - 1);

default:

RETURN_FALSE;

}

}

PHP_FUNCTION(gzfile)

{

char *filename;

size_t filename_len;

int flags = REPORT_ERRORS;

char buf[8192] = {0};

int i = 0;

bool use_include_path = false;

php_stream *stream;

if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "p|b", &filename, &filename_len, &use_include_path)) {

RETURN_THROWS();

}

if (use_include_path) {

flags |= USE_PATH;

}

/* using a stream here is a bit more efficient (resource wise) than php_gzopen_wrapper */

stream = php_stream_gzopen(NULL, filename, "rb", flags, NULL, php_stream_context_from_zval(NULL, false) STREAMS_CC);

if (!stream) {

/* Error reporting is already done by stream code */

RETURN_FALSE;

}

/* Initialize return array */

array_init(return_value);

zend_hash_real_init_packed(Z_ARRVAL_P(return_value));

/* Now loop through the file and do the magic quotes thing if needed */

memset(buf, 0, sizeof(buf));

while (php_stream_gets(stream, buf, sizeof(buf) - 1) != NULL) {

add_index_string(return_value, i++, buf);

}

php_stream_close(stream);

}

PHP_FUNCTION(gzopen)

{

char *filename;

char *mode;

size_t filename_len, mode_len;

int flags = REPORT_ERRORS;

php_stream *stream;

bool use_include_path = false;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "ps|b", &filename, &filename_len, &mode, &mode_len, &use_include_path) == FAILURE) {

RETURN_THROWS();

}

if (use_include_path) {

flags |= USE_PATH;

}

stream = php_stream_gzopen(NULL, filename, mode, flags, NULL, php_stream_context_from_zval(NULL, false) STREAMS_CC);

if (!stream) {

RETURN_FALSE;

}

php_stream_to_zval(stream, return_value);

}

PHP_FUNCTION(readgzfile)

{

char *filename;

size_t filename_len;

int flags = REPORT_ERRORS;

php_stream *stream;

size_t size;

bool use_include_path = false;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "p|b", &filename, &filename_len, &use_include_path) == FAILURE) {

RETURN_THROWS();

}

if (use_include_path) {

flags |= USE_PATH;

}

stream = php_stream_gzopen(NULL, filename, "rb", flags, NULL, php_stream_context_from_zval(NULL, false) STREAMS_CC);

if (!stream) {

RETURN_FALSE;

}

size = php_stream_passthru(stream);

php_stream_close(stream);

RETURN_LONG(size);

}

#define PHP_ZLIB_ENCODE_FUNC(name, default_encoding) \

PHP_FUNCTION(name) \

{ \

zend_string *in, *out; \

zend_long level = -1; \

zend_long encoding = default_encoding; \

if (default_encoding) { \

if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "S|ll", &in, &level, &encoding)) { \

RETURN_THROWS(); \

} \

} else { \

if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Sl|l", &in, &encoding, &level)) { \

RETURN_THROWS(); \

} \

} \

if (level < -1 || level > 9) { \

zend_argument_value_error(default_encoding ? 2 : 3, "must be between -1 and 9"); \

RETURN_THROWS(); \

} \

switch (encoding) { \

case PHP_ZLIB_ENCODING_RAW: \

case PHP_ZLIB_ENCODING_GZIP: \

case PHP_ZLIB_ENCODING_DEFLATE: \

break; \

default: \

zend_argument_value_error(default_encoding ? 3 : 2, "must be one of ZLIB_ENCODING_RAW, ZLIB_ENCODING_GZIP, or ZLIB_ENCODING_DEFLATE"); \

RETURN_THROWS(); \

} \

if ((out = php_zlib_encode(ZSTR_VAL(in), ZSTR_LEN(in), encoding, level)) == NULL) { \

RETURN_FALSE; \

} \

RETURN_STR(out); \

}

#define PHP_ZLIB_DECODE_FUNC(name, encoding) \

PHP_FUNCTION(name) \

{ \

char *in_buf, *out_buf; \

size_t in_len; \

size_t out_len; \

zend_long max_len = 0; \

if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &in_buf, &in_len, &max_len)) { \

RETURN_THROWS(); \

} \

if (max_len < 0) { \

zend_argument_value_error(2, "must be greater than or equal to 0"); \

RETURN_THROWS(); \

} \

if (SUCCESS != php_zlib_decode(in_buf, in_len, &out_buf, &out_len, encoding, max_len)) { \

RETURN_FALSE; \

} \

RETVAL_STRINGL(out_buf, out_len); \

efree(out_buf); \

}

PHP_ZLIB_ENCODE_FUNC(zlib_encode, 0);

PHP_ZLIB_DECODE_FUNC(zlib_decode, PHP_ZLIB_ENCODING_ANY);

PHP_ZLIB_ENCODE_FUNC(gzdeflate, PHP_ZLIB_ENCODING_RAW);

PHP_ZLIB_ENCODE_FUNC(gzencode, PHP_ZLIB_ENCODING_GZIP);

PHP_ZLIB_ENCODE_FUNC(gzcompress, PHP_ZLIB_ENCODING_DEFLATE);

PHP_ZLIB_DECODE_FUNC(gzinflate, PHP_ZLIB_ENCODING_RAW);

PHP_ZLIB_DECODE_FUNC(gzdecode, PHP_ZLIB_ENCODING_GZIP);

PHP_ZLIB_DECODE_FUNC(gzuncompress, PHP_ZLIB_ENCODING_DEFLATE);

static bool zlib_create_dictionary_string(HashTable *options, char **dict, size_t *dictlen) {

zval *option_buffer;

if (options && (option_buffer = zend_hash_str_find(options, ZEND_STRL("dictionary"))) != NULL) {

ZVAL_DEINDIRECT(option_buffer);

ZVAL_DEREF(option_buffer);

switch (Z_TYPE_P(option_buffer)) {

case IS_STRING: {

zend_string *str = Z_STR_P(option_buffer);

*dict = emalloc(ZSTR_LEN(str));

memcpy(*dict, ZSTR_VAL(str), ZSTR_LEN(str));

*dictlen = ZSTR_LEN(str);

return true;

}

case IS_ARRAY: {

HashTable *dictionary = Z_ARR_P(option_buffer);

bool result = true;

if (zend_hash_num_elements(dictionary) > 0) {

zend_string **strings = safe_emalloc(zend_hash_num_elements(dictionary), sizeof(zend_string *), 0);

size_t total = 0;

zval *cur;

ZEND_HASH_FOREACH_VAL(dictionary, cur) {

zend_string *string = zval_try_get_string(cur);

if (string == NULL) {

result = false;

break;

}

*dictlen += ZSTR_LEN(string) + 1;

strings[total++] = string;

if (ZSTR_LEN(string) == 0) {

result = false;

zend_argument_value_error(2, "must not contain empty strings");

break;

}

if (zend_str_has_nul_byte(string)) {

result = false;

zend_argument_value_error(2, "must not contain strings with null bytes");

break;

}

} ZEND_HASH_FOREACH_END();

char *dictptr = emalloc(*dictlen);

*dict = dictptr;

for (size_t i = 0; i < total; i++) {

zend_string *string = strings[i];

dictptr = zend_mempcpy(dictptr, ZSTR_VAL(string), ZSTR_LEN(string));

*dictptr++ = 0;

zend_string_release(string);

}

efree(strings);

if (!result) {

efree(*dict);

*dict = NULL;

}

}

return result;

}

default:

zend_argument_type_error(2, "must be of type zero-terminated string or array, %s given", zend_zval_value_name(option_buffer));

return false;

}

}

return true;

}

ZEND_ATTRIBUTE_NONNULL static bool zlib_get_long_option(HashTable *options, const char *option_name, size_t option_name_len, zend_long *value)

{

bool failed = false;

zval *option_buffer = zend_hash_str_find(options, option_name, option_name_len);

if (!option_buffer) {

return true;

}

/* The |H ZPP specifier may leave HashTable entries wrapped in IS_INDIRECT. */

ZVAL_DEINDIRECT(option_buffer);

*value = zval_try_get_long(option_buffer, &failed);

if (UNEXPECTED(failed)) {

zend_argument_type_error(

2,

"the value for option \"%.*s\" must be of type int, %s given",

(int) option_name_len, option_name, zend_zval_value_name(option_buffer)

);

return false;

}

return true;

}

PHP_FUNCTION(inflate_init)

{

php_zlib_context *ctx;

zend_long encoding, window = 15;

char *dict = NULL;

size_t dictlen = 0;

HashTable *options = (HashTable *) &zend_empty_array;

if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "l|H", &encoding, &options)) {

RETURN_THROWS();

}

if (!zlib_get_long_option(options, ZEND_STRL("window"), &window)) {

RETURN_THROWS();

}

if (window < 8 || window > 15) {

zend_value_error("zlib window size (logarithm) (" ZEND_LONG_FMT ") must be within 8..15", window);

RETURN_THROWS();

}

switch (encoding) {

case PHP_ZLIB_ENCODING_RAW:

case PHP_ZLIB_ENCODING_GZIP:

case PHP_ZLIB_ENCODING_DEFLATE:

break;

default:

zend_argument_value_error(1, "must be one of ZLIB_ENCODING_RAW, ZLIB_ENCODING_GZIP, or ZLIB_ENCODING_DEFLATE");

RETURN_THROWS();

}

if (!zlib_create_dictionary_string(options, &dict, &dictlen)) {

RETURN_THROWS();

}

object_init_ex(return_value, inflate_context_ce);

ctx = Z_INFLATE_CONTEXT_P(return_value);

ctx->Z.zalloc = php_zlib_alloc;

ctx->Z.zfree = php_zlib_free;

ctx->inflateDict = dict;

ctx->inflateDictlen = dictlen;

ctx->status = Z_OK;

if (encoding < 0) {

encoding += 15 - window;

} else {

encoding -= 15 - window;

}

if (inflateInit2(&ctx->Z, encoding) != Z_OK) {

/* dict is stored in the ctx in the object and will thus be freed by zval_ptr_dtor(). */

zval_ptr_dtor(return_value);

php_error_docref(NULL, E_WARNING, "Failed allocating zlib.inflate context");

RETURN_FALSE;

}

if (encoding == PHP_ZLIB_ENCODING_RAW && dictlen > 0) {

switch (inflateSetDictionary(&ctx->Z, (Bytef *) ctx->inflateDict, ctx->inflateDictlen)) {

case Z_OK:

efree(ctx->inflateDict);

ctx->inflateDict = NULL;

break;

case Z_DATA_ERROR:

php_error_docref(NULL, E_WARNING, "Dictionary does not match expected dictionary (incorrect adler32 hash)");

efree(ctx->inflateDict);

ctx->inflateDict = NULL;

break;

default: ZEND_UNREACHABLE();

}

}

}

PHP_FUNCTION(inflate_add)

{

zend_string *out;

char *in_buf;

size_t in_len, buffer_used = 0, CHUNK_SIZE = 8192;

zval *res;

php_zlib_context *ctx;

zend_long flush_type = Z_SYNC_FLUSH;

int status;

if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "Os|l", &res, inflate_context_ce, &in_buf, &in_len, &flush_type)) {

RETURN_THROWS();

}

ctx = Z_INFLATE_CONTEXT_P(res);

switch (flush_type) {

case Z_NO_FLUSH:

case Z_PARTIAL_FLUSH:

case Z_SYNC_FLUSH:

case Z_FULL_FLUSH:

case Z_BLOCK:

case Z_FINISH:

break;

default:

zend_argument_value_error(3, "must be one of ZLIB_NO_FLUSH, ZLIB_PARTIAL_FLUSH, ZLIB_SYNC_FLUSH, ZLIB_FULL_FLUSH, ZLIB_BLOCK, or ZLIB_FINISH");

RETURN_THROWS();

}

/* Lazy-resetting the zlib stream so ctx->total_in remains available until the next inflate_add() call. */

if (ctx->status == Z_STREAM_END)

{

ctx->status = Z_OK;

inflateReset(&ctx->Z);

}

if (in_len <= 0 && flush_type != Z_FINISH) {

RETURN_EMPTY_STRING();

}

out = zend_string_alloc((in_len > CHUNK_SIZE) ? in_len : CHUNK_SIZE, 0);

ctx->Z.next_in = (Bytef *) in_buf;

ctx->Z.next_out = (Bytef *) ZSTR_VAL(out);

ctx->Z.avail_in = in_len;

ctx->Z.avail_out = ZSTR_LEN(out);

do {

status = inflate(&ctx->Z, flush_type);