git.m6w6.name Git - m6w6/ext-http/blob - http_encoding_api.c

   1 /*
   2     +--------------------------------------------------------------------+
   3     | PECL :: http                                                       |
   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-2005, Michael Wallner <mike@php.net>            |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13 /* $Id$ */
  14
  15 #ifdef HAVE_CONFIG_H
  16 #       include "config.h"
  17 #endif
  18
  19 #define HTTP_WANT_ZLIB
  20 #include "php_http.h"
  21
  22 #include "php_http_api.h"
  23 #include "php_http_encoding_api.h"
  24 #include "php_http_send_api.h"
  25 #include "php_http_headers_api.h"
  26
  27 ZEND_EXTERN_MODULE_GLOBALS(http);
  28
  29 #ifdef HTTP_HAVE_ZLIB
  30 PHP_MINIT_FUNCTION(http_encoding)
  31 {
  32         HTTP_LONG_CONSTANT("HTTP_DEFLATE_LEVEL_DEF", HTTP_DEFLATE_LEVEL_DEF);
  33         HTTP_LONG_CONSTANT("HTTP_DEFLATE_LEVEL_MIN", HTTP_DEFLATE_LEVEL_MIN);
  34         HTTP_LONG_CONSTANT("HTTP_DEFLATE_LEVEL_MAX", HTTP_DEFLATE_LEVEL_MAX);
  35         HTTP_LONG_CONSTANT("HTTP_DEFLATE_TYPE_ZLIB", HTTP_DEFLATE_TYPE_ZLIB);
  36         HTTP_LONG_CONSTANT("HTTP_DEFLATE_TYPE_GZIP", HTTP_DEFLATE_TYPE_GZIP);
  37         HTTP_LONG_CONSTANT("HTTP_DEFLATE_TYPE_RAW", HTTP_DEFLATE_TYPE_RAW);
  38         HTTP_LONG_CONSTANT("HTTP_DEFLATE_STRATEGY_DEF", HTTP_DEFLATE_STRATEGY_DEF);
  39         HTTP_LONG_CONSTANT("HTTP_DEFLATE_STRATEGY_FILT", HTTP_DEFLATE_STRATEGY_FILT);
  40         HTTP_LONG_CONSTANT("HTTP_DEFLATE_STRATEGY_HUFF", HTTP_DEFLATE_STRATEGY_HUFF);
  41         HTTP_LONG_CONSTANT("HTTP_DEFLATE_STRATEGY_RLE", HTTP_DEFLATE_STRATEGY_RLE);
  42         HTTP_LONG_CONSTANT("HTTP_DEFLATE_STRATEGY_FIXED", HTTP_DEFLATE_STRATEGY_FIXED);
  43         return SUCCESS;
  44 }
  45 #endif
  46
  47 static inline int eol_match(char **line, int *eol_len)
  48 {
  49         char *ptr = *line;
  50
  51         while (0x20 == *ptr) ++ptr;
  52
  53         if (ptr == http_locate_eol(*line, eol_len)) {
  54                 *line = ptr;
  55                 return 1;
  56         } else {
  57                 return 0;
  58         }
  59 }
  60
  61 /* {{{ char *http_encoding_dechunk(char *, size_t, char **, size_t *) */
  62 PHP_HTTP_API const char *_http_encoding_dechunk(const char *encoded, size_t encoded_len, char **decoded, size_t *decoded_len TSRMLS_DC)
  63 {
  64         int eol_len = 0;
  65         char *n_ptr = NULL;
  66         const char *e_ptr = encoded;
  67
  68         *decoded_len = 0;
  69         *decoded = ecalloc(1, encoded_len);
  70
  71         while ((encoded + encoded_len - e_ptr) > 0) {
  72                 ulong chunk_len = 0, rest;
  73
  74                 chunk_len = strtoul(e_ptr, &n_ptr, 16);
  75
  76                 /* we could not read in chunk size */
  77                 if (n_ptr == e_ptr) {
  78                         /*
  79                          * if this is the first turn and there doesn't seem to be a chunk
  80                          * size at the begining of the body, do not fail on apparently
  81                          * not encoded data and return a copy
  82                          */
  83                         if (e_ptr == encoded) {
  84                                 http_error(HE_NOTICE, HTTP_E_ENCODING, "Data does not seem to be chunked encoded");
  85                                 memcpy(*decoded, encoded, encoded_len);
  86                                 *decoded_len = encoded_len;
  87                                 return encoded + encoded_len;
  88                         } else {
  89                                 efree(*decoded);
  90                                 http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Expected chunk size at pos %tu of %zu but got trash", n_ptr - encoded, encoded_len);
  91                                 return NULL;
  92                         }
  93                 }
  94
  95                 /* reached the end */
  96                 if (!chunk_len) {
  97                         /* move over '0' chunked encoding terminator */
  98                         while (*e_ptr == '0') ++e_ptr;
  99                         break;
 100                 }
 101
 102                 /* there should be CRLF after the chunk size, but we'll ignore SP+ too */
 103                 if (*n_ptr && !eol_match(&n_ptr, &eol_len)) {
 104                         if (eol_len == 2) {
 105                                 http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Expected CRLF at pos %tu of %zu but got 0x%02X 0x%02X", n_ptr - encoded, encoded_len, *n_ptr, *(n_ptr + 1));
 106                         } else {
 107                                 http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Expected LF at pos %tu of %zu but got 0x%02X", n_ptr - encoded, encoded_len, *n_ptr);
 108                         }
 109                 }
 110                 n_ptr += eol_len;
 111
 112                 /* chunk size pretends more data than we actually got, so it's probably a truncated message */
 113                 if (chunk_len > (rest = encoded + encoded_len - n_ptr)) {
 114                         http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Truncated message: chunk size %lu exceeds remaining data size %lu at pos %tu of %zu", chunk_len, rest, n_ptr - encoded, encoded_len);
 115                         chunk_len = rest;
 116                 }
 117
 118                 /* copy the chunk */
 119                 memcpy(*decoded + *decoded_len, n_ptr, chunk_len);
 120                 *decoded_len += chunk_len;
 121
 122                 if (chunk_len == rest) {
 123                         e_ptr = n_ptr + chunk_len;
 124                         break;
 125                 } else {
 126                         /* advance to next chunk */
 127                         e_ptr = n_ptr + chunk_len + eol_len;
 128                 }
 129         }
 130
 131         return e_ptr;
 132 }
 133 /* }}} */
 134
 135 #ifdef HTTP_HAVE_ZLIB
 136
 137 #define HTTP_DEFLATE_LEVEL_SET(flags, level) \
 138         switch (flags & 0xf) \
 139         { \
 140                 default: \
 141                         if ((flags & 0xf) < 10) { \
 142                                 level = flags & 0xf; \
 143                                 break; \
 144                         } \
 145                 case HTTP_DEFLATE_LEVEL_DEF: \
 146                         level = Z_DEFAULT_COMPRESSION; \
 147                 break; \
 148         }
 149
 150 #define HTTP_DEFLATE_WBITS_SET(flags, wbits) \
 151         switch (flags & 0xf0) \
 152         { \
 153                 case HTTP_DEFLATE_TYPE_GZIP: \
 154                         wbits = HTTP_WINDOW_BITS_GZIP; \
 155                 break; \
 156                 case HTTP_DEFLATE_TYPE_RAW: \
 157                         wbits = HTTP_WINDOW_BITS_RAW; \
 158                 break; \
 159                 default: \
 160                         wbits = HTTP_WINDOW_BITS_ZLIB; \
 161                 break; \
 162         }
 163
 164 #define HTTP_INFLATE_WBITS_SET(flags, wbits) \
 165         if (flags & HTTP_INFLATE_TYPE_RAW) { \
 166                 wbits = HTTP_WINDOW_BITS_RAW; \
 167         } else { \
 168                 wbits = HTTP_WINDOW_BITS_ANY; \
 169         }
 170
 171 #define HTTP_DEFLATE_STRATEGY_SET(flags, strategy) \
 172         switch (flags & 0xf00) \
 173         { \
 174                 case HTTP_DEFLATE_STRATEGY_FILT: \
 175                         strategy = Z_FILTERED; \
 176                 break; \
 177                 case HTTP_DEFLATE_STRATEGY_HUFF: \
 178                         strategy = Z_HUFFMAN_ONLY; \
 179                 break; \
 180                 case HTTP_DEFLATE_STRATEGY_RLE: \
 181                         strategy = Z_RLE; \
 182                 break; \
 183                 case HTTP_DEFLATE_STRATEGY_FIXED: \
 184                         strategy = Z_FIXED; \
 185                 break; \
 186                 default: \
 187                         strategy = Z_DEFAULT_STRATEGY; \
 188                 break; \
 189         }
 190
 191 #define HTTP_WINDOW_BITS_ZLIB   0x0000000f
 192 #define HTTP_WINDOW_BITS_GZIP   0x0000001f
 193 #define HTTP_WINDOW_BITS_ANY    0x0000002f
 194 #define HTTP_WINDOW_BITS_RAW    -0x000000f
 195
 196 STATUS _http_encoding_deflate(int flags, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC)
 197 {
 198         int status, level, wbits, strategy;
 199         z_stream Z;
 200
 201         HTTP_DEFLATE_LEVEL_SET(flags, level);
 202         HTTP_DEFLATE_WBITS_SET(flags, wbits);
 203         HTTP_DEFLATE_STRATEGY_SET(flags, strategy);
 204
 205         memset(&Z, 0, sizeof(z_stream));
 206         *encoded = NULL;
 207         *encoded_len = 0;
 208
 209         status = deflateInit2(&Z, level, Z_DEFLATED, wbits, MAX_MEM_LEVEL, strategy);
 210         if (Z_OK == status) {
 211                 *encoded_len = HTTP_ENCODING_BUFLEN(data_len);
 212                 *encoded = emalloc(*encoded_len);
 213
 214                 Z.next_in = (Bytef *) data;
 215                 Z.next_out = (Bytef *) *encoded;
 216                 Z.avail_in = data_len;
 217                 Z.avail_out = *encoded_len;
 218
 219                 status = deflate(&Z, Z_FINISH);
 220                 if (Z_STREAM_END == status) {
 221                         /* size buffer down to actual length */
 222                         *encoded = erealloc(*encoded, Z.total_out + 1);
 223                         (*encoded)[*encoded_len = Z.total_out] = '\0';
 224                         deflateEnd(&Z);
 225                         return SUCCESS;
 226                 } else {
 227                         STR_SET(*encoded, NULL);
 228                         *encoded_len = 0;
 229                 }
 230         }
 231
 232         http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not deflate data: %s (%s)", zError(status), Z.msg);
 233         deflateEnd(&Z);
 234         return FAILURE;
 235 }
 236
 237 STATUS _http_encoding_inflate(const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC)
 238 {
 239         int status, max = 0, wbits = HTTP_WINDOW_BITS_ANY;
 240         z_stream Z;
 241         phpstr buffer;
 242
 243         memset(&Z, 0, sizeof(z_stream));
 244         *decoded = NULL;
 245         *decoded_len = 0;
 246
 247         phpstr_init_ex(&buffer, data_len << 2, PHPSTR_INIT_PREALLOC);
 248         buffer.size = data_len;
 249
 250 retry_inflate:
 251         status = inflateInit2(&Z, wbits);
 252         if (Z_OK == status) {
 253                 Z.next_in = (Bytef *) data;
 254                 Z.avail_in = data_len;
 255
 256                 do {
 257                         phpstr_resize(&buffer, data_len);
 258
 259                         do {
 260                                 Z.next_out = buffer.data + (buffer.used += Z.total_out);
 261                                 Z.avail_out = (buffer.free -= Z.total_out);
 262                                 status = inflate(&Z, Z_NO_FLUSH);
 263                         } while (Z_OK == status);
 264
 265                 } while (Z_BUF_ERROR == status && ++max < HTTP_ENCODING_MAXTRY);
 266
 267                 if (Z_DATA_ERROR == status && HTTP_WINDOW_BITS_ANY == wbits) {
 268                         /* raw deflated data? */
 269                         inflateEnd(&Z);
 270                         wbits = HTTP_WINDOW_BITS_RAW;
 271                         goto retry_inflate;
 272                 }
 273
 274                 if (Z_STREAM_END == status) {
 275                         *decoded = erealloc(buffer.data, (buffer.used += Z.total_out) + 1);
 276                         (*decoded)[*decoded_len = buffer.used] = '\0';
 277                         inflateEnd(&Z);
 278                         return SUCCESS;
 279                 } else {
 280                         phpstr_dtor(&buffer);
 281                 }
 282         }
 283
 284         http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not inflate data: %s (%s)", zError(status), Z.msg);
 285         inflateEnd(&Z);
 286         return FAILURE;
 287 }
 288
 289
 290 http_encoding_stream *_http_encoding_deflate_stream_init(http_encoding_stream *s, int flags TSRMLS_DC)
 291 {
 292         int status, level, wbits, strategy, free_stream;
 293
 294         if ((free_stream = !s)) {
 295                 s = pemalloc(sizeof(http_encoding_stream), (flags & HTTP_ENCODING_STREAM_PERSISTENT));
 296         }
 297         memset(s, 0, sizeof(http_encoding_stream));
 298         s->flags = flags;
 299
 300         HTTP_DEFLATE_LEVEL_SET(flags, level);
 301         HTTP_DEFLATE_WBITS_SET(flags, wbits);
 302         HTTP_DEFLATE_STRATEGY_SET(flags, strategy);
 303
 304         if (Z_OK == (status = deflateInit2(&s->stream, level, Z_DEFLATED, wbits, MAX_MEM_LEVEL, strategy))) {
 305                 int p = (flags & HTTP_ENCODING_STREAM_PERSISTENT) ? PHPSTR_INIT_PERSISTENT:0;
 306
 307                 if ((s->stream.opaque = phpstr_init_ex(NULL, 0x8000, p))) {
 308                         return s;
 309                 }
 310                 deflateEnd(&s->stream);
 311                 status = Z_MEM_ERROR;
 312         }
 313
 314         http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to initialize deflate encoding stream: %s", zError(status));
 315         if (free_stream) {
 316                 efree(s);
 317         }
 318         return NULL;
 319 }
 320
 321 http_encoding_stream *_http_encoding_inflate_stream_init(http_encoding_stream *s, int flags TSRMLS_DC)
 322 {
 323         int status, wbits, free_stream;
 324
 325         if ((free_stream = !s)) {
 326                 s = emalloc(sizeof(http_encoding_stream));
 327         }
 328         memset(s, 0, sizeof(http_encoding_stream));
 329         s->flags = flags;
 330
 331         HTTP_INFLATE_WBITS_SET(flags, wbits);
 332
 333         if (Z_OK == (status = inflateInit2(&s->stream, wbits))) {
 334                 int p = (flags & HTTP_ENCODING_STREAM_PERSISTENT) ? PHPSTR_INIT_PERSISTENT:0;
 335
 336                 if ((s->stream.opaque = phpstr_init_ex(NULL, 0x8000, p))) {
 337                         return s;
 338                 }
 339                 inflateEnd(&s->stream);
 340                 status = Z_MEM_ERROR;
 341         }
 342
 343         http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to initialize inflate stream: %s", zError(status));
 344         if (free_stream) {
 345                 efree(s);
 346         }
 347         return NULL;
 348 }
 349
 350 STATUS _http_encoding_deflate_stream_update(http_encoding_stream *s, const char *data, size_t data_len, char **encoded, size_t *encoded_len TSRMLS_DC)
 351 {
 352         int status;
 353
 354         /* append input to our buffer */
 355         phpstr_append(PHPSTR(s->stream.opaque), data, data_len);
 356
 357         s->stream.next_in = PHPSTR_VAL(s->stream.opaque);
 358         s->stream.avail_in = PHPSTR_LEN(s->stream.opaque);
 359
 360         /* deflate */
 361         s->stream.avail_out = *encoded_len = HTTP_ENCODING_BUFLEN(data_len);
 362         s->stream.next_out = *encoded = emalloc(*encoded_len);
 363
 364         switch (status = deflate(&s->stream, Z_NO_FLUSH))
 365         {
 366                 case Z_OK:
 367                 case Z_STREAM_END:
 368                         /* cut processed chunk off the buffer */
 369                         phpstr_cut(PHPSTR(s->stream.opaque), 0, data_len - s->stream.avail_in);
 370
 371                         /* size buffer down to actual size */
 372                         *encoded_len -= s->stream.avail_out;
 373                         *encoded = erealloc(*encoded, *encoded_len + 1);
 374                         (*encoded)[*encoded_len] = '\0';
 375                         return SUCCESS;
 376                 break;
 377         }
 378
 379         STR_SET(*encoded, NULL);
 380         *encoded_len = 0;
 381         http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to update deflate stream: %s", zError(status));
 382         return FAILURE;
 383 }
 384
 385 STATUS _http_encoding_inflate_stream_update(http_encoding_stream *s, const char *data, size_t data_len, char **decoded, size_t *decoded_len TSRMLS_DC)
 386 {
 387         int status, max = 0;
 388
 389         /* append input to buffer */
 390         phpstr_append(PHPSTR(s->stream.opaque), data, data_len);
 391
 392         /* for realloc() */
 393         *decoded = NULL;
 394         *decoded_len = data_len << 1;
 395
 396         /* inflate */
 397         do {
 398                 *decoded_len <<= 1;
 399                 *decoded = erealloc(*decoded, *decoded_len);
 400
 401 retry_raw_inflate:
 402                 s->stream.next_in = PHPSTR_VAL(s->stream.opaque);
 403                 s->stream.avail_in = PHPSTR_LEN(s->stream.opaque);
 404
 405                 s->stream.next_out = *decoded;
 406                 s->stream.avail_out = *decoded_len;
 407
 408                 switch (status = inflate(&s->stream, Z_NO_FLUSH))
 409                 {
 410                         case Z_OK:
 411                         case Z_STREAM_END:
 412                                 /* cut off */
 413                                 phpstr_cut(PHPSTR(s->stream.opaque), 0, data_len - s->stream.avail_in);
 414
 415                                 /* size down */
 416                                 *decoded_len -= s->stream.avail_out;
 417                                 *decoded = erealloc(*decoded, *decoded_len + 1);
 418                                 (*decoded)[*decoded_len] = '\0';
 419                                 return SUCCESS;
 420                         break;
 421
 422                         case Z_DATA_ERROR:
 423                                 /* raw deflated data ? */
 424                                 if (!(s->flags & HTTP_INFLATE_TYPE_RAW) && !s->stream.total_out) {
 425                                         inflateEnd(&s->stream);
 426                                         s->flags |= HTTP_INFLATE_TYPE_RAW;
 427                                         inflateInit2(&s->stream, HTTP_WINDOW_BITS_RAW);
 428                                         goto retry_raw_inflate;
 429                                 }
 430                         break;
 431                 }
 432         } while (Z_BUF_ERROR == status && ++max < HTTP_ENCODING_MAXTRY);
 433
 434         STR_SET(*decoded, NULL);
 435         *decoded_len = 0;
 436         http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Could not update inflate stream: %s", zError(status));
 437         return FAILURE;
 438 }
 439
 440 STATUS _http_encoding_deflate_stream_finish(http_encoding_stream *s, char **encoded, size_t *encoded_len TSRMLS_DC)
 441 {
 442         int status;
 443
 444         /* deflate remaining input */
 445         s->stream.next_in = PHPSTR_VAL(s->stream.opaque);
 446         s->stream.avail_in = PHPSTR_LEN(s->stream.opaque);
 447
 448         s->stream.avail_out = *encoded_len = 0x800;
 449         s->stream.next_out = *encoded = emalloc(*encoded_len);
 450
 451         do {
 452                 status = deflate(&s->stream, Z_FINISH);
 453         } while (Z_OK == status);
 454
 455         if (Z_STREAM_END == status) {
 456                 /* cut processed intp off */
 457                 phpstr_cut(PHPSTR(s->stream.opaque), 0, PHPSTR_LEN(s->stream.opaque) - s->stream.avail_in);
 458
 459                 /* size down */
 460                 *encoded_len -= s->stream.avail_out;
 461                 *encoded = erealloc(*encoded, *encoded_len + 1);
 462                 (*encoded)[*encoded_len] = '\0';
 463                 return SUCCESS;
 464         }
 465
 466         STR_SET(*encoded, NULL);
 467         *encoded_len = 0;
 468         http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to finish deflate stream: %s", zError(status));
 469         return FAILURE;
 470 }
 471
 472 STATUS _http_encoding_inflate_stream_finish(http_encoding_stream *s, char **decoded, size_t *decoded_len TSRMLS_DC)
 473 {
 474         int status;
 475
 476         /* inflate remaining input */
 477         s->stream.next_in = PHPSTR_VAL(s->stream.opaque);
 478         s->stream.avail_in = PHPSTR_LEN(s->stream.opaque);
 479
 480         s->stream.avail_out = *decoded_len = s->stream.avail_in << 2;
 481         s->stream.next_out = *decoded = emalloc(*decoded_len);
 482
 483         if (Z_STREAM_END == (status = inflate(&s->stream, Z_FINISH))) {
 484                 /* cut processed input off */
 485                 phpstr_cut(PHPSTR(s->stream.opaque), 0, PHPSTR_LEN(s->stream.opaque) - s->stream.avail_in);
 486
 487                 /* size down */
 488                 *decoded_len -= s->stream.avail_out;
 489                 *decoded = erealloc(*decoded, *decoded_len + 1);
 490                 (*decoded)[*decoded_len] = '\0';
 491                 return SUCCESS;
 492         }
 493
 494         STR_SET(*decoded, NULL);
 495         *decoded_len = 0;
 496         http_error_ex(HE_WARNING, HTTP_E_ENCODING, "Failed to finish inflate stream: %s", zError(status));
 497         return FAILURE;
 498 }
 499
 500 void _http_encoding_deflate_stream_dtor(http_encoding_stream *s TSRMLS_DC)
 501 {
 502         if (s) {
 503                 if (s->stream.opaque) {
 504                         phpstr_free((phpstr **) &s->stream.opaque);
 505                 }
 506                 deflateEnd(&s->stream);
 507         }
 508 }
 509
 510 void _http_encoding_inflate_stream_dtor(http_encoding_stream *s TSRMLS_DC)
 511 {
 512         if (s) {
 513                 if (s->stream.opaque) {
 514                         phpstr_free((phpstr **) &s->stream.opaque);
 515                 }
 516                 inflateEnd(&s->stream);
 517         }
 518 }
 519
 520 void _http_encoding_deflate_stream_free(http_encoding_stream **s TSRMLS_DC)
 521 {
 522         if (s) {
 523                 http_encoding_deflate_stream_dtor(*s);
 524                 if (*s) {
 525                         pefree(*s, (*s)->flags & HTTP_ENCODING_STREAM_PERSISTENT);
 526                 }
 527                 *s = NULL;
 528         }
 529 }
 530
 531 void _http_encoding_inflate_stream_free(http_encoding_stream **s TSRMLS_DC)
 532 {
 533         if (s) {
 534                 http_encoding_inflate_stream_dtor(*s);
 535                 if (*s) {
 536                         pefree(*s, (*s)->flags & HTTP_ENCODING_STREAM_PERSISTENT);
 537                 }
 538                 *s = NULL;
 539         }
 540 }
 541
 542 static const char http_encoding_gzip_header[] = {
 543         (const char) 0x1f,                      // fixed value
 544         (const char) 0x8b,                      // fixed value
 545         (const char) Z_DEFLATED,        // compression algorithm
 546         (const char) 0,                         // none of the possible flags defined by the GZIP "RFC"
 547         (const char) 0,                         // MTIME
 548         (const char) 0,                         // =*=
 549         (const char) 0,                         // =*=
 550         (const char) 0,                         // =*=
 551         (const char) 0,                         // two possible flag values for 9 compression levels? o_O
 552 #ifdef PHP_WIN32
 553         (const char) 0x0b                       // OS_CODE
 554 #else
 555         (const char) 0x03                       // OS_CODE
 556 #endif
 557 };
 558
 559 PHP_HTTP_API STATUS _http_encoding_gzencode_verify(const char *data, size_t data_len, const char **encoded, size_t *encoded_len, int error_level TSRMLS_DC)
 560 {
 561         size_t offset = sizeof(http_encoding_gzip_header);
 562
 563         if (data_len < offset) {
 564                 goto really_bad_gzip_header;
 565         }
 566
 567         if (data[0] != (const char) 0x1F || data[1] != (const char) 0x8B) {
 568                 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));
 569                 return FAILURE;
 570         }
 571
 572         if (data[2] != (const char) Z_DEFLATED) {
 573                 http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "Unrecognized compression format (%d)", (int) (data[2] & 0xFF));
 574                 /* still try to decode */
 575         }
 576         if ((data[3] & 0x4) == 0x4) {
 577                 if (data_len < offset + 2) {
 578                         goto really_bad_gzip_header;
 579                 }
 580                 /* there are extra fields, the length follows the common header as 2 bytes LSB */
 581                 offset += (unsigned) ((data[offset] & 0xFF));
 582                 offset += 1;
 583                 offset += (unsigned) ((data[offset] & 0xFF) << 8);
 584                 offset += 1;
 585         }
 586         if ((data[3] & 0x8) == 0x8) {
 587                 if (data_len <= offset) {
 588                         goto really_bad_gzip_header;
 589                 }
 590                 /* there's a file name */
 591                 offset += strlen(&data[offset]) + 1 /*NUL*/;
 592         }
 593         if ((data[3] & 0x10) == 0x10) {
 594                 if (data_len <= offset) {
 595                         goto really_bad_gzip_header;
 596                 }
 597                 /* there's a comment */
 598                 offset += strlen(&data[offset]) + 1 /* NUL */;
 599         }
 600         if ((data[3] & 0x2) == 0x2) {
 601                 /* there's a CRC16 of the header */
 602                 offset += 2;
 603                 if (data_len <= offset) {
 604                         goto really_bad_gzip_header;
 605                 } else {
 606                         ulong crc, cmp;
 607
 608                         cmp =  (unsigned) ((data[offset-2] & 0xFF));
 609                         cmp += (unsigned) ((data[offset-1] & 0xFF) << 8);
 610
 611                         crc = crc32(0L, Z_NULL, 0);
 612                         crc = crc32(crc, (const Bytef *) data, sizeof(http_encoding_gzip_header));
 613
 614                         if (cmp != (crc & 0xFFFF)) {
 615                                 http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "GZIP headers CRC checksums so not match (%lu, %lu)", cmp, crc & 0xFFFF);
 616                                 return FAILURE;
 617                         }
 618                 }
 619         }
 620
 621         if (data_len < offset + 8) {
 622                 http_error(error_level TSRMLS_CC, HTTP_E_ENCODING, "Missing or truncated GZIP footer");
 623                 return FAILURE;
 624         }
 625
 626         if (encoded) {
 627                 *encoded = data + offset;
 628         }
 629         if (encoded_len) {
 630                 *encoded_len = data_len - offset - 8 /* size of the assumed GZIP footer */;
 631         }
 632
 633         return SUCCESS;
 634
 635 really_bad_gzip_header:
 636         http_error(error_level TSRMLS_CC, HTTP_E_ENCODING, "Missing or truncated GZIP header");
 637         return FAILURE;
 638 }
 639
 640 PHP_HTTP_API STATUS _http_encoding_gzdecode_verify(const char *data, size_t data_len, const char *decoded, size_t decoded_len, int error_level TSRMLS_DC)
 641 {
 642         STATUS status = SUCCESS;
 643         ulong len, cmp, crc;
 644
 645         crc = crc32(0L, Z_NULL, 0);
 646         crc = crc32(crc, (const Bytef *) decoded, decoded_len);
 647
 648         cmp  = (unsigned) ((data[data_len-8] & 0xFF));
 649         cmp += (unsigned) ((data[data_len-7] & 0xFF) << 8);
 650         cmp += (unsigned) ((data[data_len-6] & 0xFF) << 16);
 651         cmp += (unsigned) ((data[data_len-5] & 0xFF) << 24);
 652         len  = (unsigned) ((data[data_len-4] & 0xFF));
 653         len += (unsigned) ((data[data_len-3] & 0xFF) << 8);
 654         len += (unsigned) ((data[data_len-2] & 0xFF) << 16);
 655         len += (unsigned) ((data[data_len-1] & 0xFF) << 24);
 656
 657         if (cmp != crc) {
 658                 http_error_ex(error_level TSRMLS_CC, HTTP_E_ENCODING, "Could not verify data integrity: CRC checksums do not match (%lu, %lu)", cmp, crc);
 659                 status = FAILURE;
 660         }
 661         if (len != decoded_len) {
 662                 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);
 663                 status = FAILURE;
 664         }
 665         return status;
 666 }
 667
 668 #endif /* HTTP_HAVE_ZLIB */
 669
 670 PHP_HTTP_API zend_bool _http_encoding_response_start(size_t content_length TSRMLS_DC)
 671 {
 672         if (    php_ob_handler_used("ob_gzhandler" TSRMLS_CC) ||
 673                         php_ob_handler_used("zlib output compression" TSRMLS_CC)) {
 674                 HTTP_G(send).gzip_encoding = 0;
 675         } else {
 676                 if (!HTTP_G(send).gzip_encoding) {
 677                         /* emit a content-length header */
 678                         if (content_length) {
 679                                 char cl_header_str[128];
 680                                 size_t cl_header_len;
 681                                 cl_header_len = snprintf(cl_header_str, lenof(cl_header_str), "Content-Length: %zu", content_length);
 682                                 http_send_header_string_ex(cl_header_str, cl_header_len, 1);
 683                         }
 684                 } else {
 685 #ifndef HTTP_HAVE_ZLIB
 686                         HTTP_G(send).gzip_encoding = 0;
 687                         php_start_ob_buffer_named("ob_gzhandler", 0, 0 TSRMLS_CC);
 688 #else
 689                         HashTable *selected;
 690                         zval zsupported;
 691
 692                         INIT_PZVAL(&zsupported);
 693                         array_init(&zsupported);
 694                         add_next_index_stringl(&zsupported, "gzip", lenof("gzip"), 1);
 695                         add_next_index_stringl(&zsupported, "x-gzip", lenof("x-gzip"), 1);
 696                         add_next_index_stringl(&zsupported, "deflate", lenof("deflate"), 1);
 697
 698                         HTTP_G(send).gzip_encoding = 0;
 699
 700                         if ((selected = http_negotiate_encoding(&zsupported))) {
 701                                 STATUS hs = FAILURE;
 702                                 char *encoding = NULL;
 703                                 ulong idx;
 704
 705                                 if (HASH_KEY_IS_STRING == zend_hash_get_current_key(selected, &encoding, &idx, 0) && encoding) {
 706                                         if (!strcmp(encoding, "gzip") || !strcmp(encoding, "x-gzip")) {
 707                                                 if (SUCCESS == (hs = http_send_header_string("Content-Encoding: gzip"))) {
 708                                                         HTTP_G(send).gzip_encoding = HTTP_ENCODING_GZIP;
 709                                                 }
 710                                         } else if (!strcmp(encoding, "deflate")) {
 711                                                 if (SUCCESS == (hs = http_send_header_string("Content-Encoding: deflate"))) {
 712                                                         HTTP_G(send).gzip_encoding = HTTP_ENCODING_DEFLATE;
 713                                                 }
 714                                         }
 715                                         if (SUCCESS == hs) {
 716                                                 http_send_header_string("Vary: Accept-Encoding");
 717                                         }
 718                                 }
 719
 720                                 zend_hash_destroy(selected);
 721                                 FREE_HASHTABLE(selected);
 722                         }
 723
 724                         zval_dtor(&zsupported);
 725                         return HTTP_G(send).gzip_encoding;
 726 #endif
 727                 }
 728         }
 729         return 0;
 730 }
 731
 732 /*
 733  * Local variables:
 734  * tab-width: 4
 735  * c-basic-offset: 4
 736  * End:
 737  * vim600: noet sw=4 ts=4 fdm=marker
 738  * vim<600: noet sw=4 ts=4
 739  */
 740