Annotation of embedaddon/curl/lib/content_encoding.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2018, Daniel Stenberg, <daniel@haxx.se>, et al.
! 9: *
! 10: * This software is licensed as described in the file COPYING, which
! 11: * you should have received as part of this distribution. The terms
! 12: * are also available at https://curl.haxx.se/docs/copyright.html.
! 13: *
! 14: * You may opt to use, copy, modify, merge, publish, distribute and/or sell
! 15: * copies of the Software, and permit persons to whom the Software is
! 16: * furnished to do so, under the terms of the COPYING file.
! 17: *
! 18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
! 19: * KIND, either express or implied.
! 20: *
! 21: ***************************************************************************/
! 22:
! 23: #include "curl_setup.h"
! 24:
! 25: #include "urldata.h"
! 26: #include <curl/curl.h>
! 27: #include <stddef.h>
! 28:
! 29: #ifdef HAVE_ZLIB_H
! 30: #include <zlib.h>
! 31: #ifdef __SYMBIAN32__
! 32: /* zlib pollutes the namespace with this definition */
! 33: #undef WIN32
! 34: #endif
! 35: #endif
! 36:
! 37: #ifdef HAVE_BROTLI
! 38: #include <brotli/decode.h>
! 39: #endif
! 40:
! 41: #include "sendf.h"
! 42: #include "http.h"
! 43: #include "content_encoding.h"
! 44: #include "strdup.h"
! 45: #include "strcase.h"
! 46: #include "curl_memory.h"
! 47: #include "memdebug.h"
! 48:
! 49: #define CONTENT_ENCODING_DEFAULT "identity"
! 50:
! 51: #ifndef CURL_DISABLE_HTTP
! 52:
! 53: #define DSIZ CURL_MAX_WRITE_SIZE /* buffer size for decompressed data */
! 54:
! 55:
! 56: #ifdef HAVE_LIBZ
! 57:
! 58: /* Comment this out if zlib is always going to be at least ver. 1.2.0.4
! 59: (doing so will reduce code size slightly). */
! 60: #define OLD_ZLIB_SUPPORT 1
! 61:
! 62: #define GZIP_MAGIC_0 0x1f
! 63: #define GZIP_MAGIC_1 0x8b
! 64:
! 65: /* gzip flag byte */
! 66: #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
! 67: #define HEAD_CRC 0x02 /* bit 1 set: header CRC present */
! 68: #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
! 69: #define ORIG_NAME 0x08 /* bit 3 set: original file name present */
! 70: #define COMMENT 0x10 /* bit 4 set: file comment present */
! 71: #define RESERVED 0xE0 /* bits 5..7: reserved */
! 72:
! 73: typedef enum {
! 74: ZLIB_UNINIT, /* uninitialized */
! 75: ZLIB_INIT, /* initialized */
! 76: ZLIB_INFLATING, /* inflating started. */
! 77: ZLIB_EXTERNAL_TRAILER, /* reading external trailer */
! 78: ZLIB_GZIP_HEADER, /* reading gzip header */
! 79: ZLIB_GZIP_INFLATING, /* inflating gzip stream */
! 80: ZLIB_INIT_GZIP /* initialized in transparent gzip mode */
! 81: } zlibInitState;
! 82:
! 83: /* Writer parameters. */
! 84: typedef struct {
! 85: zlibInitState zlib_init; /* zlib init state */
! 86: uInt trailerlen; /* Remaining trailer byte count. */
! 87: z_stream z; /* State structure for zlib. */
! 88: } zlib_params;
! 89:
! 90:
! 91: static voidpf
! 92: zalloc_cb(voidpf opaque, unsigned int items, unsigned int size)
! 93: {
! 94: (void) opaque;
! 95: /* not a typo, keep it calloc() */
! 96: return (voidpf) calloc(items, size);
! 97: }
! 98:
! 99: static void
! 100: zfree_cb(voidpf opaque, voidpf ptr)
! 101: {
! 102: (void) opaque;
! 103: free(ptr);
! 104: }
! 105:
! 106: static CURLcode
! 107: process_zlib_error(struct connectdata *conn, z_stream *z)
! 108: {
! 109: struct Curl_easy *data = conn->data;
! 110: if(z->msg)
! 111: failf(data, "Error while processing content unencoding: %s",
! 112: z->msg);
! 113: else
! 114: failf(data, "Error while processing content unencoding: "
! 115: "Unknown failure within decompression software.");
! 116:
! 117: return CURLE_BAD_CONTENT_ENCODING;
! 118: }
! 119:
! 120: static CURLcode
! 121: exit_zlib(struct connectdata *conn,
! 122: z_stream *z, zlibInitState *zlib_init, CURLcode result)
! 123: {
! 124: if(*zlib_init == ZLIB_GZIP_HEADER)
! 125: Curl_safefree(z->next_in);
! 126:
! 127: if(*zlib_init != ZLIB_UNINIT) {
! 128: if(inflateEnd(z) != Z_OK && result == CURLE_OK)
! 129: result = process_zlib_error(conn, z);
! 130: *zlib_init = ZLIB_UNINIT;
! 131: }
! 132:
! 133: return result;
! 134: }
! 135:
! 136: static CURLcode process_trailer(struct connectdata *conn, zlib_params *zp)
! 137: {
! 138: z_stream *z = &zp->z;
! 139: CURLcode result = CURLE_OK;
! 140: uInt len = z->avail_in < zp->trailerlen? z->avail_in: zp->trailerlen;
! 141:
! 142: /* Consume expected trailer bytes. Terminate stream if exhausted.
! 143: Issue an error if unexpected bytes follow. */
! 144:
! 145: zp->trailerlen -= len;
! 146: z->avail_in -= len;
! 147: z->next_in += len;
! 148: if(z->avail_in)
! 149: result = CURLE_WRITE_ERROR;
! 150: if(result || !zp->trailerlen)
! 151: result = exit_zlib(conn, z, &zp->zlib_init, result);
! 152: else {
! 153: /* Only occurs for gzip with zlib < 1.2.0.4 or raw deflate. */
! 154: zp->zlib_init = ZLIB_EXTERNAL_TRAILER;
! 155: }
! 156: return result;
! 157: }
! 158:
! 159: static CURLcode inflate_stream(struct connectdata *conn,
! 160: contenc_writer *writer, zlibInitState started)
! 161: {
! 162: zlib_params *zp = (zlib_params *) &writer->params;
! 163: z_stream *z = &zp->z; /* zlib state structure */
! 164: uInt nread = z->avail_in;
! 165: Bytef *orig_in = z->next_in;
! 166: bool done = FALSE;
! 167: CURLcode result = CURLE_OK; /* Curl_client_write status */
! 168: char *decomp; /* Put the decompressed data here. */
! 169:
! 170: /* Check state. */
! 171: if(zp->zlib_init != ZLIB_INIT &&
! 172: zp->zlib_init != ZLIB_INFLATING &&
! 173: zp->zlib_init != ZLIB_INIT_GZIP &&
! 174: zp->zlib_init != ZLIB_GZIP_INFLATING)
! 175: return exit_zlib(conn, z, &zp->zlib_init, CURLE_WRITE_ERROR);
! 176:
! 177: /* Dynamically allocate a buffer for decompression because it's uncommonly
! 178: large to hold on the stack */
! 179: decomp = malloc(DSIZ);
! 180: if(decomp == NULL)
! 181: return exit_zlib(conn, z, &zp->zlib_init, CURLE_OUT_OF_MEMORY);
! 182:
! 183: /* because the buffer size is fixed, iteratively decompress and transfer to
! 184: the client via downstream_write function. */
! 185: while(!done) {
! 186: int status; /* zlib status */
! 187: done = TRUE;
! 188:
! 189: /* (re)set buffer for decompressed output for every iteration */
! 190: z->next_out = (Bytef *) decomp;
! 191: z->avail_out = DSIZ;
! 192:
! 193: #ifdef Z_BLOCK
! 194: /* Z_BLOCK is only available in zlib ver. >= 1.2.0.5 */
! 195: status = inflate(z, Z_BLOCK);
! 196: #else
! 197: /* fallback for zlib ver. < 1.2.0.5 */
! 198: status = inflate(z, Z_SYNC_FLUSH);
! 199: #endif
! 200:
! 201: /* Flush output data if some. */
! 202: if(z->avail_out != DSIZ) {
! 203: if(status == Z_OK || status == Z_STREAM_END) {
! 204: zp->zlib_init = started; /* Data started. */
! 205: result = Curl_unencode_write(conn, writer->downstream, decomp,
! 206: DSIZ - z->avail_out);
! 207: if(result) {
! 208: exit_zlib(conn, z, &zp->zlib_init, result);
! 209: break;
! 210: }
! 211: }
! 212: }
! 213:
! 214: /* Dispatch by inflate() status. */
! 215: switch(status) {
! 216: case Z_OK:
! 217: /* Always loop: there may be unflushed latched data in zlib state. */
! 218: done = FALSE;
! 219: break;
! 220: case Z_BUF_ERROR:
! 221: /* No more data to flush: just exit loop. */
! 222: break;
! 223: case Z_STREAM_END:
! 224: result = process_trailer(conn, zp);
! 225: break;
! 226: case Z_DATA_ERROR:
! 227: /* some servers seem to not generate zlib headers, so this is an attempt
! 228: to fix and continue anyway */
! 229: if(zp->zlib_init == ZLIB_INIT) {
! 230: /* Do not use inflateReset2(): only available since zlib 1.2.3.4. */
! 231: (void) inflateEnd(z); /* don't care about the return code */
! 232: if(inflateInit2(z, -MAX_WBITS) == Z_OK) {
! 233: z->next_in = orig_in;
! 234: z->avail_in = nread;
! 235: zp->zlib_init = ZLIB_INFLATING;
! 236: zp->trailerlen = 4; /* Tolerate up to 4 unknown trailer bytes. */
! 237: done = FALSE;
! 238: break;
! 239: }
! 240: zp->zlib_init = ZLIB_UNINIT; /* inflateEnd() already called. */
! 241: }
! 242: /* FALLTHROUGH */
! 243: default:
! 244: result = exit_zlib(conn, z, &zp->zlib_init, process_zlib_error(conn, z));
! 245: break;
! 246: }
! 247: }
! 248: free(decomp);
! 249:
! 250: /* We're about to leave this call so the `nread' data bytes won't be seen
! 251: again. If we are in a state that would wrongly allow restart in raw mode
! 252: at the next call, assume output has already started. */
! 253: if(nread && zp->zlib_init == ZLIB_INIT)
! 254: zp->zlib_init = started; /* Cannot restart anymore. */
! 255:
! 256: return result;
! 257: }
! 258:
! 259:
! 260: /* Deflate handler. */
! 261: static CURLcode deflate_init_writer(struct connectdata *conn,
! 262: contenc_writer *writer)
! 263: {
! 264: zlib_params *zp = (zlib_params *) &writer->params;
! 265: z_stream *z = &zp->z; /* zlib state structure */
! 266:
! 267: if(!writer->downstream)
! 268: return CURLE_WRITE_ERROR;
! 269:
! 270: /* Initialize zlib */
! 271: z->zalloc = (alloc_func) zalloc_cb;
! 272: z->zfree = (free_func) zfree_cb;
! 273:
! 274: if(inflateInit(z) != Z_OK)
! 275: return process_zlib_error(conn, z);
! 276: zp->zlib_init = ZLIB_INIT;
! 277: return CURLE_OK;
! 278: }
! 279:
! 280: static CURLcode deflate_unencode_write(struct connectdata *conn,
! 281: contenc_writer *writer,
! 282: const char *buf, size_t nbytes)
! 283: {
! 284: zlib_params *zp = (zlib_params *) &writer->params;
! 285: z_stream *z = &zp->z; /* zlib state structure */
! 286:
! 287: /* Set the compressed input when this function is called */
! 288: z->next_in = (Bytef *) buf;
! 289: z->avail_in = (uInt) nbytes;
! 290:
! 291: if(zp->zlib_init == ZLIB_EXTERNAL_TRAILER)
! 292: return process_trailer(conn, zp);
! 293:
! 294: /* Now uncompress the data */
! 295: return inflate_stream(conn, writer, ZLIB_INFLATING);
! 296: }
! 297:
! 298: static void deflate_close_writer(struct connectdata *conn,
! 299: contenc_writer *writer)
! 300: {
! 301: zlib_params *zp = (zlib_params *) &writer->params;
! 302: z_stream *z = &zp->z; /* zlib state structure */
! 303:
! 304: exit_zlib(conn, z, &zp->zlib_init, CURLE_OK);
! 305: }
! 306:
! 307: static const content_encoding deflate_encoding = {
! 308: "deflate",
! 309: NULL,
! 310: deflate_init_writer,
! 311: deflate_unencode_write,
! 312: deflate_close_writer,
! 313: sizeof(zlib_params)
! 314: };
! 315:
! 316:
! 317: /* Gzip handler. */
! 318: static CURLcode gzip_init_writer(struct connectdata *conn,
! 319: contenc_writer *writer)
! 320: {
! 321: zlib_params *zp = (zlib_params *) &writer->params;
! 322: z_stream *z = &zp->z; /* zlib state structure */
! 323:
! 324: if(!writer->downstream)
! 325: return CURLE_WRITE_ERROR;
! 326:
! 327: /* Initialize zlib */
! 328: z->zalloc = (alloc_func) zalloc_cb;
! 329: z->zfree = (free_func) zfree_cb;
! 330:
! 331: if(strcmp(zlibVersion(), "1.2.0.4") >= 0) {
! 332: /* zlib ver. >= 1.2.0.4 supports transparent gzip decompressing */
! 333: if(inflateInit2(z, MAX_WBITS + 32) != Z_OK) {
! 334: return process_zlib_error(conn, z);
! 335: }
! 336: zp->zlib_init = ZLIB_INIT_GZIP; /* Transparent gzip decompress state */
! 337: }
! 338: else {
! 339: /* we must parse the gzip header and trailer ourselves */
! 340: if(inflateInit2(z, -MAX_WBITS) != Z_OK) {
! 341: return process_zlib_error(conn, z);
! 342: }
! 343: zp->trailerlen = 8; /* A CRC-32 and a 32-bit input size (RFC 1952, 2.2) */
! 344: zp->zlib_init = ZLIB_INIT; /* Initial call state */
! 345: }
! 346:
! 347: return CURLE_OK;
! 348: }
! 349:
! 350: #ifdef OLD_ZLIB_SUPPORT
! 351: /* Skip over the gzip header */
! 352: static enum {
! 353: GZIP_OK,
! 354: GZIP_BAD,
! 355: GZIP_UNDERFLOW
! 356: } check_gzip_header(unsigned char const *data, ssize_t len, ssize_t *headerlen)
! 357: {
! 358: int method, flags;
! 359: const ssize_t totallen = len;
! 360:
! 361: /* The shortest header is 10 bytes */
! 362: if(len < 10)
! 363: return GZIP_UNDERFLOW;
! 364:
! 365: if((data[0] != GZIP_MAGIC_0) || (data[1] != GZIP_MAGIC_1))
! 366: return GZIP_BAD;
! 367:
! 368: method = data[2];
! 369: flags = data[3];
! 370:
! 371: if(method != Z_DEFLATED || (flags & RESERVED) != 0) {
! 372: /* Can't handle this compression method or unknown flag */
! 373: return GZIP_BAD;
! 374: }
! 375:
! 376: /* Skip over time, xflags, OS code and all previous bytes */
! 377: len -= 10;
! 378: data += 10;
! 379:
! 380: if(flags & EXTRA_FIELD) {
! 381: ssize_t extra_len;
! 382:
! 383: if(len < 2)
! 384: return GZIP_UNDERFLOW;
! 385:
! 386: extra_len = (data[1] << 8) | data[0];
! 387:
! 388: if(len < (extra_len + 2))
! 389: return GZIP_UNDERFLOW;
! 390:
! 391: len -= (extra_len + 2);
! 392: data += (extra_len + 2);
! 393: }
! 394:
! 395: if(flags & ORIG_NAME) {
! 396: /* Skip over NUL-terminated file name */
! 397: while(len && *data) {
! 398: --len;
! 399: ++data;
! 400: }
! 401: if(!len || *data)
! 402: return GZIP_UNDERFLOW;
! 403:
! 404: /* Skip over the NUL */
! 405: --len;
! 406: ++data;
! 407: }
! 408:
! 409: if(flags & COMMENT) {
! 410: /* Skip over NUL-terminated comment */
! 411: while(len && *data) {
! 412: --len;
! 413: ++data;
! 414: }
! 415: if(!len || *data)
! 416: return GZIP_UNDERFLOW;
! 417:
! 418: /* Skip over the NUL */
! 419: --len;
! 420: }
! 421:
! 422: if(flags & HEAD_CRC) {
! 423: if(len < 2)
! 424: return GZIP_UNDERFLOW;
! 425:
! 426: len -= 2;
! 427: }
! 428:
! 429: *headerlen = totallen - len;
! 430: return GZIP_OK;
! 431: }
! 432: #endif
! 433:
! 434: static CURLcode gzip_unencode_write(struct connectdata *conn,
! 435: contenc_writer *writer,
! 436: const char *buf, size_t nbytes)
! 437: {
! 438: zlib_params *zp = (zlib_params *) &writer->params;
! 439: z_stream *z = &zp->z; /* zlib state structure */
! 440:
! 441: if(zp->zlib_init == ZLIB_INIT_GZIP) {
! 442: /* Let zlib handle the gzip decompression entirely */
! 443: z->next_in = (Bytef *) buf;
! 444: z->avail_in = (uInt) nbytes;
! 445: /* Now uncompress the data */
! 446: return inflate_stream(conn, writer, ZLIB_INIT_GZIP);
! 447: }
! 448:
! 449: #ifndef OLD_ZLIB_SUPPORT
! 450: /* Support for old zlib versions is compiled away and we are running with
! 451: an old version, so return an error. */
! 452: return exit_zlib(conn, z, &zp->zlib_init, CURLE_WRITE_ERROR);
! 453:
! 454: #else
! 455: /* This next mess is to get around the potential case where there isn't
! 456: * enough data passed in to skip over the gzip header. If that happens, we
! 457: * malloc a block and copy what we have then wait for the next call. If
! 458: * there still isn't enough (this is definitely a worst-case scenario), we
! 459: * make the block bigger, copy the next part in and keep waiting.
! 460: *
! 461: * This is only required with zlib versions < 1.2.0.4 as newer versions
! 462: * can handle the gzip header themselves.
! 463: */
! 464:
! 465: switch(zp->zlib_init) {
! 466: /* Skip over gzip header? */
! 467: case ZLIB_INIT:
! 468: {
! 469: /* Initial call state */
! 470: ssize_t hlen;
! 471:
! 472: switch(check_gzip_header((unsigned char *) buf, nbytes, &hlen)) {
! 473: case GZIP_OK:
! 474: z->next_in = (Bytef *) buf + hlen;
! 475: z->avail_in = (uInt) (nbytes - hlen);
! 476: zp->zlib_init = ZLIB_GZIP_INFLATING; /* Inflating stream state */
! 477: break;
! 478:
! 479: case GZIP_UNDERFLOW:
! 480: /* We need more data so we can find the end of the gzip header. It's
! 481: * possible that the memory block we malloc here will never be freed if
! 482: * the transfer abruptly aborts after this point. Since it's unlikely
! 483: * that circumstances will be right for this code path to be followed in
! 484: * the first place, and it's even more unlikely for a transfer to fail
! 485: * immediately afterwards, it should seldom be a problem.
! 486: */
! 487: z->avail_in = (uInt) nbytes;
! 488: z->next_in = malloc(z->avail_in);
! 489: if(z->next_in == NULL) {
! 490: return exit_zlib(conn, z, &zp->zlib_init, CURLE_OUT_OF_MEMORY);
! 491: }
! 492: memcpy(z->next_in, buf, z->avail_in);
! 493: zp->zlib_init = ZLIB_GZIP_HEADER; /* Need more gzip header data state */
! 494: /* We don't have any data to inflate yet */
! 495: return CURLE_OK;
! 496:
! 497: case GZIP_BAD:
! 498: default:
! 499: return exit_zlib(conn, z, &zp->zlib_init, process_zlib_error(conn, z));
! 500: }
! 501:
! 502: }
! 503: break;
! 504:
! 505: case ZLIB_GZIP_HEADER:
! 506: {
! 507: /* Need more gzip header data state */
! 508: ssize_t hlen;
! 509: z->avail_in += (uInt) nbytes;
! 510: z->next_in = Curl_saferealloc(z->next_in, z->avail_in);
! 511: if(z->next_in == NULL) {
! 512: return exit_zlib(conn, z, &zp->zlib_init, CURLE_OUT_OF_MEMORY);
! 513: }
! 514: /* Append the new block of data to the previous one */
! 515: memcpy(z->next_in + z->avail_in - nbytes, buf, nbytes);
! 516:
! 517: switch(check_gzip_header(z->next_in, z->avail_in, &hlen)) {
! 518: case GZIP_OK:
! 519: /* This is the zlib stream data */
! 520: free(z->next_in);
! 521: /* Don't point into the malloced block since we just freed it */
! 522: z->next_in = (Bytef *) buf + hlen + nbytes - z->avail_in;
! 523: z->avail_in = (uInt) (z->avail_in - hlen);
! 524: zp->zlib_init = ZLIB_GZIP_INFLATING; /* Inflating stream state */
! 525: break;
! 526:
! 527: case GZIP_UNDERFLOW:
! 528: /* We still don't have any data to inflate! */
! 529: return CURLE_OK;
! 530:
! 531: case GZIP_BAD:
! 532: default:
! 533: return exit_zlib(conn, z, &zp->zlib_init, process_zlib_error(conn, z));
! 534: }
! 535:
! 536: }
! 537: break;
! 538:
! 539: case ZLIB_EXTERNAL_TRAILER:
! 540: z->next_in = (Bytef *) buf;
! 541: z->avail_in = (uInt) nbytes;
! 542: return process_trailer(conn, zp);
! 543:
! 544: case ZLIB_GZIP_INFLATING:
! 545: default:
! 546: /* Inflating stream state */
! 547: z->next_in = (Bytef *) buf;
! 548: z->avail_in = (uInt) nbytes;
! 549: break;
! 550: }
! 551:
! 552: if(z->avail_in == 0) {
! 553: /* We don't have any data to inflate; wait until next time */
! 554: return CURLE_OK;
! 555: }
! 556:
! 557: /* We've parsed the header, now uncompress the data */
! 558: return inflate_stream(conn, writer, ZLIB_GZIP_INFLATING);
! 559: #endif
! 560: }
! 561:
! 562: static void gzip_close_writer(struct connectdata *conn,
! 563: contenc_writer *writer)
! 564: {
! 565: zlib_params *zp = (zlib_params *) &writer->params;
! 566: z_stream *z = &zp->z; /* zlib state structure */
! 567:
! 568: exit_zlib(conn, z, &zp->zlib_init, CURLE_OK);
! 569: }
! 570:
! 571: static const content_encoding gzip_encoding = {
! 572: "gzip",
! 573: "x-gzip",
! 574: gzip_init_writer,
! 575: gzip_unencode_write,
! 576: gzip_close_writer,
! 577: sizeof(zlib_params)
! 578: };
! 579:
! 580: #endif /* HAVE_LIBZ */
! 581:
! 582:
! 583: #ifdef HAVE_BROTLI
! 584:
! 585: /* Writer parameters. */
! 586: typedef struct {
! 587: BrotliDecoderState *br; /* State structure for brotli. */
! 588: } brotli_params;
! 589:
! 590:
! 591: static CURLcode brotli_map_error(BrotliDecoderErrorCode be)
! 592: {
! 593: switch(be) {
! 594: case BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE:
! 595: case BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE:
! 596: case BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET:
! 597: case BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME:
! 598: case BROTLI_DECODER_ERROR_FORMAT_CL_SPACE:
! 599: case BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE:
! 600: case BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT:
! 601: case BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1:
! 602: case BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2:
! 603: case BROTLI_DECODER_ERROR_FORMAT_TRANSFORM:
! 604: case BROTLI_DECODER_ERROR_FORMAT_DICTIONARY:
! 605: case BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS:
! 606: case BROTLI_DECODER_ERROR_FORMAT_PADDING_1:
! 607: case BROTLI_DECODER_ERROR_FORMAT_PADDING_2:
! 608: #ifdef BROTLI_DECODER_ERROR_COMPOUND_DICTIONARY
! 609: case BROTLI_DECODER_ERROR_COMPOUND_DICTIONARY:
! 610: #endif
! 611: #ifdef BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET
! 612: case BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET:
! 613: #endif
! 614: case BROTLI_DECODER_ERROR_INVALID_ARGUMENTS:
! 615: return CURLE_BAD_CONTENT_ENCODING;
! 616: case BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES:
! 617: case BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS:
! 618: case BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP:
! 619: case BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1:
! 620: case BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2:
! 621: case BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES:
! 622: return CURLE_OUT_OF_MEMORY;
! 623: default:
! 624: break;
! 625: }
! 626: return CURLE_WRITE_ERROR;
! 627: }
! 628:
! 629: static CURLcode brotli_init_writer(struct connectdata *conn,
! 630: contenc_writer *writer)
! 631: {
! 632: brotli_params *bp = (brotli_params *) &writer->params;
! 633:
! 634: (void) conn;
! 635:
! 636: if(!writer->downstream)
! 637: return CURLE_WRITE_ERROR;
! 638:
! 639: bp->br = BrotliDecoderCreateInstance(NULL, NULL, NULL);
! 640: return bp->br? CURLE_OK: CURLE_OUT_OF_MEMORY;
! 641: }
! 642:
! 643: static CURLcode brotli_unencode_write(struct connectdata *conn,
! 644: contenc_writer *writer,
! 645: const char *buf, size_t nbytes)
! 646: {
! 647: brotli_params *bp = (brotli_params *) &writer->params;
! 648: const uint8_t *src = (const uint8_t *) buf;
! 649: char *decomp;
! 650: uint8_t *dst;
! 651: size_t dstleft;
! 652: CURLcode result = CURLE_OK;
! 653: BrotliDecoderResult r = BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT;
! 654:
! 655: if(!bp->br)
! 656: return CURLE_WRITE_ERROR; /* Stream already ended. */
! 657:
! 658: decomp = malloc(DSIZ);
! 659: if(!decomp)
! 660: return CURLE_OUT_OF_MEMORY;
! 661:
! 662: while((nbytes || r == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) &&
! 663: result == CURLE_OK) {
! 664: dst = (uint8_t *) decomp;
! 665: dstleft = DSIZ;
! 666: r = BrotliDecoderDecompressStream(bp->br,
! 667: &nbytes, &src, &dstleft, &dst, NULL);
! 668: result = Curl_unencode_write(conn, writer->downstream,
! 669: decomp, DSIZ - dstleft);
! 670: if(result)
! 671: break;
! 672: switch(r) {
! 673: case BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT:
! 674: case BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT:
! 675: break;
! 676: case BROTLI_DECODER_RESULT_SUCCESS:
! 677: BrotliDecoderDestroyInstance(bp->br);
! 678: bp->br = NULL;
! 679: if(nbytes)
! 680: result = CURLE_WRITE_ERROR;
! 681: break;
! 682: default:
! 683: result = brotli_map_error(BrotliDecoderGetErrorCode(bp->br));
! 684: break;
! 685: }
! 686: }
! 687: free(decomp);
! 688: return result;
! 689: }
! 690:
! 691: static void brotli_close_writer(struct connectdata *conn,
! 692: contenc_writer *writer)
! 693: {
! 694: brotli_params *bp = (brotli_params *) &writer->params;
! 695:
! 696: (void) conn;
! 697:
! 698: if(bp->br) {
! 699: BrotliDecoderDestroyInstance(bp->br);
! 700: bp->br = NULL;
! 701: }
! 702: }
! 703:
! 704: static const content_encoding brotli_encoding = {
! 705: "br",
! 706: NULL,
! 707: brotli_init_writer,
! 708: brotli_unencode_write,
! 709: brotli_close_writer,
! 710: sizeof(brotli_params)
! 711: };
! 712: #endif
! 713:
! 714:
! 715: /* Identity handler. */
! 716: static CURLcode identity_init_writer(struct connectdata *conn,
! 717: contenc_writer *writer)
! 718: {
! 719: (void) conn;
! 720: return writer->downstream? CURLE_OK: CURLE_WRITE_ERROR;
! 721: }
! 722:
! 723: static CURLcode identity_unencode_write(struct connectdata *conn,
! 724: contenc_writer *writer,
! 725: const char *buf, size_t nbytes)
! 726: {
! 727: return Curl_unencode_write(conn, writer->downstream, buf, nbytes);
! 728: }
! 729:
! 730: static void identity_close_writer(struct connectdata *conn,
! 731: contenc_writer *writer)
! 732: {
! 733: (void) conn;
! 734: (void) writer;
! 735: }
! 736:
! 737: static const content_encoding identity_encoding = {
! 738: "identity",
! 739: "none",
! 740: identity_init_writer,
! 741: identity_unencode_write,
! 742: identity_close_writer,
! 743: 0
! 744: };
! 745:
! 746:
! 747: /* supported content encodings table. */
! 748: static const content_encoding * const encodings[] = {
! 749: &identity_encoding,
! 750: #ifdef HAVE_LIBZ
! 751: &deflate_encoding,
! 752: &gzip_encoding,
! 753: #endif
! 754: #ifdef HAVE_BROTLI
! 755: &brotli_encoding,
! 756: #endif
! 757: NULL
! 758: };
! 759:
! 760:
! 761: /* Return a list of comma-separated names of supported encodings. */
! 762: char *Curl_all_content_encodings(void)
! 763: {
! 764: size_t len = 0;
! 765: const content_encoding * const *cep;
! 766: const content_encoding *ce;
! 767: char *ace;
! 768:
! 769: for(cep = encodings; *cep; cep++) {
! 770: ce = *cep;
! 771: if(!strcasecompare(ce->name, CONTENT_ENCODING_DEFAULT))
! 772: len += strlen(ce->name) + 2;
! 773: }
! 774:
! 775: if(!len)
! 776: return strdup(CONTENT_ENCODING_DEFAULT);
! 777:
! 778: ace = malloc(len);
! 779: if(ace) {
! 780: char *p = ace;
! 781: for(cep = encodings; *cep; cep++) {
! 782: ce = *cep;
! 783: if(!strcasecompare(ce->name, CONTENT_ENCODING_DEFAULT)) {
! 784: strcpy(p, ce->name);
! 785: p += strlen(p);
! 786: *p++ = ',';
! 787: *p++ = ' ';
! 788: }
! 789: }
! 790: p[-2] = '\0';
! 791: }
! 792:
! 793: return ace;
! 794: }
! 795:
! 796:
! 797: /* Real client writer: no downstream. */
! 798: static CURLcode client_init_writer(struct connectdata *conn,
! 799: contenc_writer *writer)
! 800: {
! 801: (void) conn;
! 802: return writer->downstream? CURLE_WRITE_ERROR: CURLE_OK;
! 803: }
! 804:
! 805: static CURLcode client_unencode_write(struct connectdata *conn,
! 806: contenc_writer *writer,
! 807: const char *buf, size_t nbytes)
! 808: {
! 809: struct Curl_easy *data = conn->data;
! 810: struct SingleRequest *k = &data->req;
! 811:
! 812: (void) writer;
! 813:
! 814: if(!nbytes || k->ignorebody)
! 815: return CURLE_OK;
! 816:
! 817: return Curl_client_write(conn, CLIENTWRITE_BODY, (char *) buf, nbytes);
! 818: }
! 819:
! 820: static void client_close_writer(struct connectdata *conn,
! 821: contenc_writer *writer)
! 822: {
! 823: (void) conn;
! 824: (void) writer;
! 825: }
! 826:
! 827: static const content_encoding client_encoding = {
! 828: NULL,
! 829: NULL,
! 830: client_init_writer,
! 831: client_unencode_write,
! 832: client_close_writer,
! 833: 0
! 834: };
! 835:
! 836:
! 837: /* Deferred error dummy writer. */
! 838: static CURLcode error_init_writer(struct connectdata *conn,
! 839: contenc_writer *writer)
! 840: {
! 841: (void) conn;
! 842: return writer->downstream? CURLE_OK: CURLE_WRITE_ERROR;
! 843: }
! 844:
! 845: static CURLcode error_unencode_write(struct connectdata *conn,
! 846: contenc_writer *writer,
! 847: const char *buf, size_t nbytes)
! 848: {
! 849: char *all = Curl_all_content_encodings();
! 850:
! 851: (void) writer;
! 852: (void) buf;
! 853: (void) nbytes;
! 854:
! 855: if(!all)
! 856: return CURLE_OUT_OF_MEMORY;
! 857: failf(conn->data, "Unrecognized content encoding type. "
! 858: "libcurl understands %s content encodings.", all);
! 859: free(all);
! 860: return CURLE_BAD_CONTENT_ENCODING;
! 861: }
! 862:
! 863: static void error_close_writer(struct connectdata *conn,
! 864: contenc_writer *writer)
! 865: {
! 866: (void) conn;
! 867: (void) writer;
! 868: }
! 869:
! 870: static const content_encoding error_encoding = {
! 871: NULL,
! 872: NULL,
! 873: error_init_writer,
! 874: error_unencode_write,
! 875: error_close_writer,
! 876: 0
! 877: };
! 878:
! 879: /* Create an unencoding writer stage using the given handler. */
! 880: static contenc_writer *new_unencoding_writer(struct connectdata *conn,
! 881: const content_encoding *handler,
! 882: contenc_writer *downstream)
! 883: {
! 884: size_t sz = offsetof(contenc_writer, params) + handler->paramsize;
! 885: contenc_writer *writer = (contenc_writer *) calloc(1, sz);
! 886:
! 887: if(writer) {
! 888: writer->handler = handler;
! 889: writer->downstream = downstream;
! 890: if(handler->init_writer(conn, writer)) {
! 891: free(writer);
! 892: writer = NULL;
! 893: }
! 894: }
! 895:
! 896: return writer;
! 897: }
! 898:
! 899: /* Write data using an unencoding writer stack. */
! 900: CURLcode Curl_unencode_write(struct connectdata *conn, contenc_writer *writer,
! 901: const char *buf, size_t nbytes)
! 902: {
! 903: if(!nbytes)
! 904: return CURLE_OK;
! 905: return writer->handler->unencode_write(conn, writer, buf, nbytes);
! 906: }
! 907:
! 908: /* Close and clean-up the connection's writer stack. */
! 909: void Curl_unencode_cleanup(struct connectdata *conn)
! 910: {
! 911: struct Curl_easy *data = conn->data;
! 912: struct SingleRequest *k = &data->req;
! 913: contenc_writer *writer = k->writer_stack;
! 914:
! 915: while(writer) {
! 916: k->writer_stack = writer->downstream;
! 917: writer->handler->close_writer(conn, writer);
! 918: free(writer);
! 919: writer = k->writer_stack;
! 920: }
! 921: }
! 922:
! 923: /* Find the content encoding by name. */
! 924: static const content_encoding *find_encoding(const char *name, size_t len)
! 925: {
! 926: const content_encoding * const *cep;
! 927:
! 928: for(cep = encodings; *cep; cep++) {
! 929: const content_encoding *ce = *cep;
! 930: if((strncasecompare(name, ce->name, len) && !ce->name[len]) ||
! 931: (ce->alias && strncasecompare(name, ce->alias, len) && !ce->alias[len]))
! 932: return ce;
! 933: }
! 934: return NULL;
! 935: }
! 936:
! 937: /* Set-up the unencoding stack from the Content-Encoding header value.
! 938: * See RFC 7231 section 3.1.2.2. */
! 939: CURLcode Curl_build_unencoding_stack(struct connectdata *conn,
! 940: const char *enclist, int maybechunked)
! 941: {
! 942: struct Curl_easy *data = conn->data;
! 943: struct SingleRequest *k = &data->req;
! 944:
! 945: do {
! 946: const char *name;
! 947: size_t namelen;
! 948:
! 949: /* Parse a single encoding name. */
! 950: while(ISSPACE(*enclist) || *enclist == ',')
! 951: enclist++;
! 952:
! 953: name = enclist;
! 954:
! 955: for(namelen = 0; *enclist && *enclist != ','; enclist++)
! 956: if(!ISSPACE(*enclist))
! 957: namelen = enclist - name + 1;
! 958:
! 959: /* Special case: chunked encoding is handled at the reader level. */
! 960: if(maybechunked && namelen == 7 && strncasecompare(name, "chunked", 7)) {
! 961: k->chunk = TRUE; /* chunks coming our way. */
! 962: Curl_httpchunk_init(conn); /* init our chunky engine. */
! 963: }
! 964: else if(namelen) {
! 965: const content_encoding *encoding = find_encoding(name, namelen);
! 966: contenc_writer *writer;
! 967:
! 968: if(!k->writer_stack) {
! 969: k->writer_stack = new_unencoding_writer(conn, &client_encoding, NULL);
! 970:
! 971: if(!k->writer_stack)
! 972: return CURLE_OUT_OF_MEMORY;
! 973: }
! 974:
! 975: if(!encoding)
! 976: encoding = &error_encoding; /* Defer error at stack use. */
! 977:
! 978: /* Stack the unencoding stage. */
! 979: writer = new_unencoding_writer(conn, encoding, k->writer_stack);
! 980: if(!writer)
! 981: return CURLE_OUT_OF_MEMORY;
! 982: k->writer_stack = writer;
! 983: }
! 984: } while(*enclist);
! 985:
! 986: return CURLE_OK;
! 987: }
! 988:
! 989: #else
! 990: /* Stubs for builds without HTTP. */
! 991: CURLcode Curl_build_unencoding_stack(struct connectdata *conn,
! 992: const char *enclist, int maybechunked)
! 993: {
! 994: (void) conn;
! 995: (void) enclist;
! 996: (void) maybechunked;
! 997: return CURLE_NOT_BUILT_IN;
! 998: }
! 999:
! 1000: CURLcode Curl_unencode_write(struct connectdata *conn, contenc_writer *writer,
! 1001: const char *buf, size_t nbytes)
! 1002: {
! 1003: (void) conn;
! 1004: (void) writer;
! 1005: (void) buf;
! 1006: (void) nbytes;
! 1007: return CURLE_NOT_BUILT_IN;
! 1008: }
! 1009:
! 1010: void Curl_unencode_cleanup(struct connectdata *conn)
! 1011: {
! 1012: (void) conn;
! 1013: }
! 1014:
! 1015: char *Curl_all_content_encodings(void)
! 1016: {
! 1017: return strdup(CONTENT_ENCODING_DEFAULT); /* Satisfy caller. */
! 1018: }
! 1019:
! 1020: #endif /* CURL_DISABLE_HTTP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to content_encoding.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib