lib/content_encoding.c

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