Home | History | Annotate | Download | only in lib 
      1 /***************************************************************************
      2  *                                  _   _ ____  _
      3  *  Project                     ___| | | |  _ \| |
      4  *                             / __| | | | |_) | |
      5  *                            | (__| |_| |  _ <| |___
      6  *                             \___|\___/|_| \_\_____|
      7  *
      8  * Copyright (C) 1998 - 2018, Daniel Stenberg, <daniel (at) 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 */
   1021