projects / m6w6 / ext-http / blob
? search:


a8d3ec0e048c6a6e96f97d5c3bdc3e1186734c03
[m6w6/ext-http] / http_encoding_api.c
1 /*
2 +----------------------------------------------------------------------+
3 | PECL :: http |
4 +----------------------------------------------------------------------+
5 | This source file is subject to version 3.0 of the PHP license, that |
6 | is bundled with this package in the file LICENSE, and is available |
7 | through the world-wide-web at http://www.php.net/license/3_0.txt. |
8 | If you did not receive a copy of the PHP license and are unable to |
9 | obtain it through the world-wide-web, please send a note to |
10 | license@php.net so we can mail you a copy immediately. |
11 +----------------------------------------------------------------------+
12 | Copyright (c) 2004-2005 Michael Wallner <mike@php.net> |
13 +----------------------------------------------------------------------+
14 */
15
16 /* $Id$ */
17
18 #ifdef HAVE_CONFIG_H
19 # include "config.h"
20 #endif
21 #include "php.h"
22
23 #include "php_http_encoding_api.h"
24 #include "php_http.h"
25 #include "php_http_api.h"
26
27 ZEND_EXTERN_MODULE_GLOBALS(http);
28
29 /* {{{ char *http_encoding_dechunk(char *, size_t, char **, size_t *) */
30 PHP_HTTP_API const char *_http_encoding_dechunk(const char *encoded, size_t encoded_len, char **decoded, size_t *decoded_len TSRMLS_DC)
31 {
32 const char *e_ptr;
33 char *d_ptr;
34 long rest;
35
36 *decoded_len = 0;
37 *decoded = ecalloc(1, encoded_len);
38 d_ptr = *decoded;
39 e_ptr = encoded;
40
41 while ((rest = encoded + encoded_len - e_ptr) > 0) {
42 long chunk_len = 0;
43 int EOL_len = 0, eol_mismatch = 0;
44 char *n_ptr;
45
46 chunk_len = strtol(e_ptr, &n_ptr, 16);
47
48 /* check if:
49 * - we could not read in chunk size
50 * - we got a negative chunk size
51 * - chunk size is greater then remaining size
52 * - chunk size is not followed by (CR)LF|NUL
53 */
54 if ( (n_ptr == e_ptr) || (chunk_len < 0) || (chunk_len > rest) ||
55 (*n_ptr && (eol_mismatch = (n_ptr != http_locate_eol(e_ptr, &EOL_len))))) {
56 /* don't fail on apperently not encoded data */
57 if (e_ptr == encoded) {
58 memcpy(*decoded, encoded, encoded_len);
59 *decoded_len = encoded_len;
60 return encoded + encoded_len;
61 } else {
62 efree(*decoded);
63 if (eol_mismatch) {
64 if (EOL_len == 2) {
65 http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Invalid character (expected 0x0D 0x0A; got: 0x%X 0x%X)", *n_ptr, *(n_ptr + 1));
66 } else {
67 http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Invalid character (expected 0x0A; got: 0x%X)", *n_ptr);
68 }
69 } else {
70 char *error = estrndup(n_ptr, strcspn(n_ptr, "\r\n "));
71 http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Invalid chunk size: '%s' at pos %d", error, n_ptr - encoded);
72 efree(error);
73 }
74 return NULL;
75 }
76 } else {
77 e_ptr = n_ptr;
78 }
79
80 /* reached the end */
81 if (!chunk_len) {
82 break;
83 }
84
85 memcpy(d_ptr, e_ptr += EOL_len, chunk_len);
86 d_ptr += chunk_len;
87 e_ptr += chunk_len + EOL_len;
88 *decoded_len += chunk_len;
89 }
90
91 return e_ptr;
92 }
93 /* }}} */
94
95 #ifdef HTTP_HAVE_ZLIB
96 #include <zlib.h>
97
98 /* max count of uncompress trials, alloc_size <<= 2 for each try */
99 #define HTTP_GZMAXTRY 10
100 /* safe padding */
101 #define HTTP_GZSAFPAD 10
102 /* add 1% extra space in case we need to encode widely differing (binary) data */
103 #define HTTP_GZBUFLEN(l) (l + (l / 100) + HTTP_GZSAFPAD)
104
105 static const char http_gzencode_header[] = {
106 (const char) 0x1f, // fixed value
107 (const char) 0x8b, // fixed value
108 (const char) Z_DEFLATED, // compression algorithm
109 (const char) 0, // none of the possible flags defined by the GZIP "RFC"
110 (const char) 0, // no MTIME available (4 bytes)
111 (const char) 0, // =*=
112 (const char) 0, // =*=
113 (const char) 0, // =*=
114 (const char) 0, // two possible flag values for 9 compression levels? o_O
115 (const char) 0x03 // assume *nix OS
116 };
117
118 inline void http_init_gzencode_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr)
119 {
120 Z->zalloc = Z_NULL;
121 Z->zfree = Z_NULL;
122 Z->opaque = Z_NULL;
123
124 Z->next_in = (Bytef *) data;
125 Z->avail_in = data_len;
126 Z->avail_out = HTTP_GZBUFLEN(data_len) + HTTP_GZSAFPAD - 1;
127
128 *buf_ptr = emalloc(HTTP_GZBUFLEN(data_len) + sizeof(http_gzencode_header) + HTTP_GZSAFPAD);
129 memcpy(*buf_ptr, http_gzencode_header, sizeof(http_gzencode_header));
130
131 Z->next_out = *buf_ptr + sizeof(http_gzencode_header);
132 }
133
134 inline void http_init_deflate_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr)
135 {
136 Z->zalloc = Z_NULL;
137 Z->zfree = Z_NULL;
138 Z->opaque = Z_NULL;
139
140 Z->data_type = Z_UNKNOWN;
141 Z->next_in = (Bytef *) data;
142 Z->avail_in = data_len;
143 Z->avail_out = HTTP_GZBUFLEN(data_len) - 1;
144 Z->next_out = emalloc(HTTP_GZBUFLEN(data_len));
145
146 *buf_ptr = Z->next_out;
147 }
148
149 inline void http_init_uncompress_buffer(size_t data_len, char **buf_ptr, size_t *buf_len, int iteration)
150 {
151 if (!iteration) {
152 *buf_len = data_len * 2;
153 *buf_ptr = emalloc(*buf_len + 1);
154 } else {
155 *buf_len <<= 2;
156 *buf_ptr = erealloc(*buf_ptr, *buf_len + 1);
157 }
158 }
159
160 inline void http_init_inflate_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr, size_t *buf_len, int iteration)
161 {
162 Z->zalloc = Z_NULL;
163 Z->zfree = Z_NULL;
164
165 http_init_uncompress_buffer(data_len, buf_ptr, buf_len, iteration);
166
167 Z->next_in = (Bytef *) data;
168 Z->avail_in = data_len;
169 Z->avail_out = *buf_len;
170 Z->next_out = *buf_ptr;
171 }
172
173 inline size_t http_finish_buffer(size_t buf_len, char **buf_ptr)
174 {
175 (*buf_ptr)[buf_len] = '\0';
176 return buf_len;
177 }
178
179 inline size_t http_finish_gzencode_buffer(z_stream *Z, const char *data, size_t data_len, char **buf_ptr)
180 {
181 unsigned long crc;
182 char *trailer;
183
184 crc = crc32(0L, Z_NULL, 0);
185 crc = crc32(crc, (const Bytef *) data, data_len);
186
187 trailer = *buf_ptr + sizeof(http_gzencode_header) + Z->total_out;
188
189 /* LSB */
190 trailer[0] = (char) (crc & 0xFF);
191 trailer[1] = (char) ((crc >> 8) & 0xFF);
192 trailer[2] = (char) ((crc >> 16) & 0xFF);
193 trailer[3] = (char) ((crc >> 24) & 0xFF);
194 trailer[4] = (char) ((Z->total_in) & 0xFF);
195 trailer[5] = (char) ((Z->total_in >> 8) & 0xFF);
196 trailer[6] = (char) ((Z->total_in >> 16) & 0xFF);
197 trailer[7] = (char) ((Z->total_in >> 24) & 0xFF);
198
199 return http_finish_buffer(Z->total_out + sizeof(http_gzencode_header) + 8, buf_ptr);
200 }
201
202 inline STATUS http_verify_gzencode_buffer(const char *data, size_t data_len, const char **encoded, size_t *encoded_len, int error_level TSRMLS_DC)
203 {
204 size_t offset = sizeof(http_gzencode_header);
205
206 if (data_len < offset) {
207 goto really_bad_gzip_header;
208 }
209
210 if (data[0] != (const char) 0x1F || data[1] != (const char) 0x8B) {
211 http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "Unrecognized GZIP header start: 0x%02X 0x%02X", (int) data[0], (int) (data[1] & 0xFF));
212 return FAILURE;
213 }
214
215 if (data[2] != (const char) Z_DEFLATED) {
216 http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "Unrecognized compression format (%d)", (int) (data[2] & 0xFF));
217 /* still try to decode */
218 }
219 if ((data[3] & 0x4) == 0x4) {
220 if (data_len < offset + 2) {
221 goto really_bad_gzip_header;
222 }
223 /* there are extra fields, the length follows the common header as 2 bytes LSB */
224 offset += (unsigned) ((data[offset] & 0xFF));
225 offset += 1;
226 offset += (unsigned) ((data[offset] & 0xFF) << 8);
227 offset += 1;
228 }
229 if ((data[3] & 0x8) == 0x8) {
230 if (data_len <= offset) {
231 goto really_bad_gzip_header;
232 }
233 /* there's a file name */
234 offset += strlen(&data[offset]) + 1 /*NUL*/;
235 }
236 if ((data[3] & 0x10) == 0x10) {
237 if (data_len <= offset) {
238 goto really_bad_gzip_header;
239 }
240 /* there's a comment */
241 offset += strlen(&data[offset]) + 1 /* NUL */;
242 }
243 if ((data[3] & 0x2) == 0x2) {
244 /* there's a CRC16 of the header */
245 offset += 2;
246 if (data_len <= offset) {
247 goto really_bad_gzip_header;
248 } else {
249 unsigned long crc, cmp;
250
251 cmp = (unsigned) ((data[offset-2] & 0xFF));
252 cmp += (unsigned) ((data[offset-1] & 0xFF) << 8);
253
254 crc = crc32(0L, Z_NULL, 0);
255 crc = crc32(crc, data, sizeof(http_gzencode_header));
256
257 if (cmp != (crc & 0xFFFF)) {
258 http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "GZIP headers CRC checksums so not match (%lu, %lu)", cmp, crc & 0xFFFF);
259 return FAILURE;
260 }
261 }
262 }
263
264 if (encoded) {
265 *encoded = data + offset;
266 }
267 if (encoded_len) {
268 *encoded_len = data_len - offset - 8 /* size of the assumed GZIP footer */;
269 }
270
271 return SUCCESS;
272
273 really_bad_gzip_header:
274 http_error(error_level TSRMLS_CC, HTTP_E_ENCODING, "Missing or truncated GZIP header");
275 return FAILURE;
276 }
277
278 inline STATUS http_verify_gzdecode_buffer(const char *data, size_t data_len, const char *decoded, size_t decoded_len, int error_level TSRMLS_DC)
279 {
280 STATUS status = SUCCESS;
281 unsigned long len, cmp, crc;
282
283 crc = crc32(0L, Z_NULL, 0);
284 crc = crc32(crc, (const Bytef *) decoded, decoded_len);
285
286 cmp = (unsigned) ((data[data_len-8] & 0xFF));
287 cmp += (unsigned) ((data[data_len-7] & 0xFF) << 8);
288 cmp += (unsigned) ((data[data_len-6] & 0xFF) << 16);
289 cmp += (unsigned) ((data[data_len-5] & 0xFF) << 24);
290 len = (unsigned) ((data[data_len-4] & 0xFF));
291 len += (unsigned) ((data[data_len-3] & 0xFF) << 8);
292 len += (unsigned) ((data[data_len-2] & 0xFF) << 16);
293 len += (unsigned) ((data[data_len-1] & 0xFF) << 24);
294
295 if (cmp != crc) {
296 http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "Could not verify data integrity: CRC checksums do not match (%lu, %lu)", cmp, crc);
297 status = FAILURE;
298 }
299 if (len != decoded_len) {
300 http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "Could not verify data integrity: data sizes do not match (%lu, %lu)", len, decoded_len);
301 status = FAILURE;
302 }
303 return status;
304 }
305
306 PHP_HTTP_API STATUS _http_encoding_gzencode(int level, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC)
307 {
308 z_stream Z;
309 STATUS status = Z_OK;
310
311 http_init_gzencode_buffer(&Z, data, data_len, encoded);
312
313 if ( (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) &&
314 (Z_STREAM_END == (status = deflate(&Z, Z_FINISH))) &&
315 (Z_OK == (status = deflateEnd(&Z)))) {
316 *encoded_len = http_finish_gzencode_buffer(&Z, data, data_len, encoded);
317 return SUCCESS;
318 }
319
320 efree(*encoded);
321 http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not gzencode data: %s", zError(status));
322 return FAILURE;
323 }
324
325 PHP_HTTP_API STATUS _http_encoding_deflate(int level, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC)
326 {
327 z_stream Z;
328 STATUS status = Z_OK;
329
330 http_init_deflate_buffer(&Z, data, data_len, encoded);
331
332 if ( (Z_OK == (status = deflateInit2(&Z, level, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY))) &&
333 (Z_STREAM_END == (status = deflate(&Z, Z_FINISH))) &&
334 (Z_OK == (status = deflateEnd(&Z)))) {
335 *encoded_len = http_finish_buffer(Z.total_out, encoded);
336 return SUCCESS;
337 }
338
339 efree(encoded);
340 http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not deflate data: %s", zError(status));
341 return FAILURE;
342 }
343
344 PHP_HTTP_API STATUS _http_encoding_compress(int level, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC)
345 {
346 STATUS status;
347
348 *encoded = emalloc(*encoded_len = HTTP_GZBUFLEN(data_len));
349
350 if (Z_OK == (status = compress2(*encoded, encoded_len, data, data_len, level))) {
351 http_finish_buffer(*encoded_len, encoded);
352 return SUCCESS;
353 }
354
355 efree(encoded);
356 http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not compress data: %s", zError(status));
357 return FAILURE;
358 }
359
360 PHP_HTTP_API STATUS _http_encoding_gzdecode(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC)
361 {
362 const char *encoded;
363 size_t encoded_len;
364
365 if ( (SUCCESS == http_verify_gzencode_buffer(data, data_len, &encoded, &encoded_len, HE_NOTICE)) &&
366 (SUCCESS == http_encoding_inflate(encoded, encoded_len, decoded, decoded_len))) {
367 http_verify_gzdecode_buffer(data, data_len, *decoded, *decoded_len, HE_NOTICE);
368 return SUCCESS;
369 }
370
371 return FAILURE;
372 }
373
374 PHP_HTTP_API STATUS _http_encoding_inflate(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC)
375 {
376 int max = 0;
377 STATUS status;
378 z_stream Z;
379
380 do {
381 http_init_inflate_buffer(&Z, data, data_len, decoded, decoded_len, max++);
382 if (Z_OK == (status = inflateInit2(&Z, -MAX_WBITS))) {
383 if (Z_STREAM_END == (status = inflate(&Z, Z_FINISH))) {
384 if (Z_OK == (status = inflateEnd(&Z))) {
385 *decoded_len = http_finish_buffer(Z.total_out, decoded);
386 return SUCCESS;
387 }
388 }
389 }
390 } while (max < HTTP_GZMAXTRY && status == Z_BUF_ERROR);
391
392 efree(*decoded);
393 http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not inflate data: %s", zError(status));
394 return FAILURE;
395 }
396
397 PHP_HTTP_API STATUS _http_encoding_uncompress(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC)
398 {
399 int max = 0;
400 STATUS status;
401
402 do {
403 http_init_uncompress_buffer(data_len, decoded, decoded_len, max++);
404 if (Z_OK == (status = uncompress(*decoded, decoded_len, data, data_len))) {
405 http_finish_buffer(*decoded_len, decoded);
406 return SUCCESS;
407 }
408 } while (max < HTTP_GZMAXTRY && status == Z_BUF_ERROR);
409
410 efree(*decoded);
411 http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not uncompress data: %s", zError(status));
412 return FAILURE;
413 }
414
415 #endif /* HTTP_HAVE_ZLIB */
416
417 /*
418 * Local variables:
419 * tab-width: 4
420 * c-basic-offset: 4
421 * End:
422 * vim600: noet sw=4 ts=4 fdm=marker
423 * vim<600: noet sw=4 ts=4
424 */
425
Extended HTTP Support