/*
- +----------------------------------------------------------------------+
- | PECL :: http |
- +----------------------------------------------------------------------+
- | This source file is subject to version 3.0 of the PHP license, that |
- | is bundled with this package in the file LICENSE, and is available |
- | through the world-wide-web at http://www.php.net/license/3_0.txt. |
- | If you did not receive a copy of the PHP license and are unable to |
- | obtain it through the world-wide-web, please send a note to |
- | license@php.net so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- | Copyright (c) 2004-2005 Michael Wallner <mike@php.net> |
- +----------------------------------------------------------------------+
+ +--------------------------------------------------------------------+
+ | PECL :: http |
+ +--------------------------------------------------------------------+
+ | Redistribution and use in source and binary forms, with or without |
+ | modification, are permitted provided that the conditions mentioned |
+ | in the accompanying LICENSE file are met. |
+ +--------------------------------------------------------------------+
+ | Copyright (c) 2004-2005, Michael Wallner <mike@php.net> |
+ +--------------------------------------------------------------------+
*/
/* $Id$ */
*buf_ptr = emalloc(HTTP_ENCODING_BUFLEN(data_len) + sizeof(http_encoding_gzip_header) + HTTP_ENCODING_SAFPAD);
memcpy(*buf_ptr, http_encoding_gzip_header, sizeof(http_encoding_gzip_header));
- Z->next_out = *buf_ptr + sizeof(http_encoding_gzip_header);
+ Z->next_out = (Bytef *) *buf_ptr + sizeof(http_encoding_gzip_header);
}
inline void http_init_deflate_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr)
Z->avail_out = HTTP_ENCODING_BUFLEN(data_len) - 1;
Z->next_out = emalloc(HTTP_ENCODING_BUFLEN(data_len));
- *buf_ptr = Z->next_out;
+ *buf_ptr = (char *) Z->next_out;
}
inline void http_init_uncompress_buffer(size_t data_len, char **buf_ptr, size_t *buf_len, int *iteration)
*buf_ptr = emalloc(*buf_len + 1);
} else {
size_t new_len = *buf_len << 2;
- char *new_ptr = erealloc(*buf_ptr, new_len + 1);
+ char *new_ptr = erealloc_recoverable(*buf_ptr, new_len + 1);
if (new_ptr) {
*buf_ptr = new_ptr;
*buf_len = new_len;
} else {
- *iteration = INT_MAX;
+ *iteration = INT_MAX-1; /* avoid integer overflow on increment op */
}
}
}
Z->next_in = (Bytef *) data;
Z->avail_in = data_len;
Z->avail_out = *buf_len;
- Z->next_out = *buf_ptr;
+ Z->next_out = (Bytef *) *buf_ptr;
}
inline size_t http_finish_buffer(size_t buf_len, char **buf_ptr)
cmp += (unsigned) ((data[offset-1] & 0xFF) << 8);
crc = crc32(0L, Z_NULL, 0);
- crc = crc32(crc, data, sizeof(http_encoding_gzip_header));
+ crc = crc32(crc, (const Bytef *) data, sizeof(http_encoding_gzip_header));
if (cmp != (crc & 0xFFFF)) {
http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "GZIP headers CRC checksums so not match (%lu, %lu)", cmp, crc & 0xFFFF);
*encoded = emalloc(*encoded_len = HTTP_ENCODING_BUFLEN(data_len));
- if (Z_OK == (status = compress2(*encoded, encoded_len, data, data_len, level))) {
+ if (Z_OK == (status = compress2((Bytef *) *encoded, (uLongf *) encoded_len, (const Bytef *) data, data_len, level))) {
http_finish_buffer(*encoded_len, encoded);
return SUCCESS;
}
do {
http_init_uncompress_buffer(data_len, decoded, decoded_len, &max);
- if (Z_OK == (status = uncompress(*decoded, decoded_len, data, data_len))) {
+ if (Z_OK == (status = uncompress((Bytef *) *decoded, (uLongf *) decoded_len, (const Bytef *) data, data_len))) {
http_finish_buffer(*decoded_len, decoded);
return SUCCESS;
}
s->Z.next_in = (Bytef *) data;
s->Z.avail_in = data_len;
- s->Z.next_out = *encoded;
+ s->Z.next_out = (Bytef *) *encoded;
s->Z.avail_out = *encoded_len;
status = deflate(&s->Z, Z_SYNC_FLUSH);
if (Z_OK != status && Z_STREAM_END != status) {
- HTTP_GZSTREAM_ERROR(status, *encoded);
+ HTTP_ENCODING_STREAM_ERROR(status, *encoded);
}
*encoded_len -= s->Z.avail_out;
*encoded_len = 1024;
*encoded = emalloc(*encoded_len);
- s->Z.next_out = *encoded;
+ s->Z.next_out = (Bytef *) *encoded;
s->Z.avail_out = *encoded_len;
if (Z_STREAM_END != (status = deflate(&s->Z, Z_FINISH)) || Z_OK != (status = deflateEnd(&s->Z))) {
HTTP_ENCODING_STREAM_ERROR(status, *encoded);
}
- fprintf(stderr, "Needed %d bytes\n", *encoded_len - s->Z.avail_out);
-
*encoded_len -= s->Z.avail_out;
if (s->gzip) {
if (s->Z.avail_out < 8) {
PHP_HTTP_API zend_bool _http_encoding_response_start(size_t content_length TSRMLS_DC)
{
- if (php_ob_handler_used("ob_gzhandler" TSRMLS_DC)||php_ob_handler_used("zlib output compression" TSRMLS_DC)) {
+ if ( php_ob_handler_used("ob_gzhandler" TSRMLS_CC) ||
+ php_ob_handler_used("zlib output compression" TSRMLS_CC)) {
HTTP_G(send).gzip_encoding = 0;
} else {
if (!HTTP_G(send).gzip_encoding) {
/* emit a content-length header */
if (content_length) {
- char *cl;
- spprintf(&cl, 0, "Content-Length: %lu", (unsigned long) content_length);
- http_send_header_string(cl);
- efree(cl);
+ char cl_header_str[128];
+ size_t cl_header_len;
+ cl_header_len = snprintf(cl_header_str, lenof(cl_header_str), "Content-Length: %lu", (unsigned long) content_length);
+ http_send_header_string_ex(cl_header_str, cl_header_len, 1);
}
} else {
#ifndef HTTP_HAVE_ZLIB
+ HTTP_G(send).gzip_encoding = 0;
php_start_ob_buffer_named("ob_gzhandler", 0, 0 TSRMLS_CC);
#else
HashTable *selected;
add_next_index_stringl(&zsupported, "gzip", lenof("gzip"), 1);
add_next_index_stringl(&zsupported, "deflate", lenof("deflate"), 1);
+ HTTP_G(send).gzip_encoding = 0;
+
if (selected = http_negotiate_encoding(&zsupported)) {
STATUS hs = FAILURE;
char *encoding = NULL;
}
if (SUCCESS == hs) {
http_send_header_string("Vary: Accept-Encoding");
- } else {
- HTTP_G(send).gzip_encoding = 0;
}
}
}
zval_dtor(&zsupported);
- return 1;
+ return HTTP_G(send).gzip_encoding;
#endif
}
}
projects / m6w6 / ext-http / blobdiff