Utilities/cmcurl/lib/http_chunks.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2022, 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.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  * SPDX-License-Identifier: curl
  22  *
  23  ***************************************************************************/
  24
  25 #include "curl_setup.h"
  26
  27 #ifndef CURL_DISABLE_HTTP
  28
  29 #include "urldata.h" /* it includes http_chunks.h */
  30 #include "sendf.h"   /* for the client write stuff */
  31 #include "dynbuf.h"
  32 #include "content_encoding.h"
  33 #include "http.h"
  34 #include "strtoofft.h"
  35 #include "warnless.h"
  36
  37 /* The last #include files should be: */
  38 #include "curl_memory.h"
  39 #include "memdebug.h"
  40
  41 /*
  42  * Chunk format (simplified):
  43  *
  44  * <HEX SIZE>[ chunk extension ] CRLF
  45  * <DATA> CRLF
  46  *
  47  * Highlights from RFC2616 section 3.6 say:
  48
  49    The chunked encoding modifies the body of a message in order to
  50    transfer it as a series of chunks, each with its own size indicator,
  51    followed by an OPTIONAL trailer containing entity-header fields. This
  52    allows dynamically produced content to be transferred along with the
  53    information necessary for the recipient to verify that it has
  54    received the full message.
  55
  56        Chunked-Body   = *chunk
  57                         last-chunk
  58                         trailer
  59                         CRLF
  60
  61        chunk          = chunk-size [ chunk-extension ] CRLF
  62                         chunk-data CRLF
  63        chunk-size     = 1*HEX
  64        last-chunk     = 1*("0") [ chunk-extension ] CRLF
  65
  66        chunk-extension= *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
  67        chunk-ext-name = token
  68        chunk-ext-val  = token | quoted-string
  69        chunk-data     = chunk-size(OCTET)
  70        trailer        = *(entity-header CRLF)
  71
  72    The chunk-size field is a string of hex digits indicating the size of
  73    the chunk. The chunked encoding is ended by any chunk whose size is
  74    zero, followed by the trailer, which is terminated by an empty line.
  75
  76  */
  77
  78 #define isxdigit_ascii(x) Curl_isxdigit(x)
  79
  80 void Curl_httpchunk_init(struct Curl_easy *data)
  81 {
  82   struct connectdata *conn = data->conn;
  83   struct Curl_chunker *chunk = &conn->chunk;
  84   chunk->hexindex = 0;      /* start at 0 */
  85   chunk->state = CHUNK_HEX; /* we get hex first! */
  86   Curl_dyn_init(&conn->trailer, DYN_H1_TRAILER);
  87 }
  88
  89 /*
  90  * chunk_read() returns a OK for normal operations, or a positive return code
  91  * for errors. STOP means this sequence of chunks is complete.  The 'wrote'
  92  * argument is set to tell the caller how many bytes we actually passed to the
  93  * client (for byte-counting and whatever).
  94  *
  95  * The states and the state-machine is further explained in the header file.
  96  *
  97  * This function always uses ASCII hex values to accommodate non-ASCII hosts.
  98  * For example, 0x0d and 0x0a are used instead of '\r' and '\n'.
  99  */
 100 CHUNKcode Curl_httpchunk_read(struct Curl_easy *data,
 101                               char *datap,
 102                               ssize_t datalen,
 103                               ssize_t *wrote,
 104                               CURLcode *extrap)
 105 {
 106   CURLcode result = CURLE_OK;
 107   struct connectdata *conn = data->conn;
 108   struct Curl_chunker *ch = &conn->chunk;
 109   struct SingleRequest *k = &data->req;
 110   size_t piece;
 111   curl_off_t length = (curl_off_t)datalen;
 112
 113   *wrote = 0; /* nothing's written yet */
 114
 115   /* the original data is written to the client, but we go on with the
 116      chunk read process, to properly calculate the content length*/
 117   if(data->set.http_te_skip && !k->ignorebody) {
 118     result = Curl_client_write(data, CLIENTWRITE_BODY, datap, datalen);
 119     if(result) {
 120       *extrap = result;
 121       return CHUNKE_PASSTHRU_ERROR;
 122     }
 123   }
 124
 125   while(length) {
 126     switch(ch->state) {
 127     case CHUNK_HEX:
 128       if(ISXDIGIT(*datap)) {
 129         if(ch->hexindex < CHUNK_MAXNUM_LEN) {
 130           ch->hexbuffer[ch->hexindex] = *datap;
 131           datap++;
 132           length--;
 133           ch->hexindex++;
 134         }
 135         else {
 136           return CHUNKE_TOO_LONG_HEX; /* longer hex than we support */
 137         }
 138       }
 139       else {
 140         char *endptr;
 141         if(0 == ch->hexindex)
 142           /* This is illegal data, we received junk where we expected
 143              a hexadecimal digit. */
 144           return CHUNKE_ILLEGAL_HEX;
 145
 146         /* length and datap are unmodified */
 147         ch->hexbuffer[ch->hexindex] = 0;
 148
 149         if(curlx_strtoofft(ch->hexbuffer, &endptr, 16, &ch->datasize))
 150           return CHUNKE_ILLEGAL_HEX;
 151         ch->state = CHUNK_LF; /* now wait for the CRLF */
 152       }
 153       break;
 154
 155     case CHUNK_LF:
 156       /* waiting for the LF after a chunk size */
 157       if(*datap == 0x0a) {
 158         /* we're now expecting data to come, unless size was zero! */
 159         if(0 == ch->datasize) {
 160           ch->state = CHUNK_TRAILER; /* now check for trailers */
 161         }
 162         else
 163           ch->state = CHUNK_DATA;
 164       }
 165
 166       datap++;
 167       length--;
 168       break;
 169
 170     case CHUNK_DATA:
 171       /* We expect 'datasize' of data. We have 'length' right now, it can be
 172          more or less than 'datasize'. Get the smallest piece.
 173       */
 174       piece = curlx_sotouz((ch->datasize >= length)?length:ch->datasize);
 175
 176       /* Write the data portion available */
 177       if(!data->set.http_te_skip && !k->ignorebody) {
 178         if(!data->set.http_ce_skip && k->writer_stack)
 179           result = Curl_unencode_write(data, k->writer_stack, datap, piece);
 180         else
 181           result = Curl_client_write(data, CLIENTWRITE_BODY, datap, piece);
 182
 183         if(result) {
 184           *extrap = result;
 185           return CHUNKE_PASSTHRU_ERROR;
 186         }
 187       }
 188
 189       *wrote += piece;
 190       ch->datasize -= piece; /* decrease amount left to expect */
 191       datap += piece;    /* move read pointer forward */
 192       length -= piece;   /* decrease space left in this round */
 193
 194       if(0 == ch->datasize)
 195         /* end of data this round, we now expect a trailing CRLF */
 196         ch->state = CHUNK_POSTLF;
 197       break;
 198
 199     case CHUNK_POSTLF:
 200       if(*datap == 0x0a) {
 201         /* The last one before we go back to hex state and start all over. */
 202         Curl_httpchunk_init(data); /* sets state back to CHUNK_HEX */
 203       }
 204       else if(*datap != 0x0d)
 205         return CHUNKE_BAD_CHUNK;
 206       datap++;
 207       length--;
 208       break;
 209
 210     case CHUNK_TRAILER:
 211       if((*datap == 0x0d) || (*datap == 0x0a)) {
 212         char *tr = Curl_dyn_ptr(&conn->trailer);
 213         /* this is the end of a trailer, but if the trailer was zero bytes
 214            there was no trailer and we move on */
 215
 216         if(tr) {
 217           size_t trlen;
 218           result = Curl_dyn_addn(&conn->trailer, (char *)STRCONST("\x0d\x0a"));
 219           if(result)
 220             return CHUNKE_OUT_OF_MEMORY;
 221
 222           tr = Curl_dyn_ptr(&conn->trailer);
 223           trlen = Curl_dyn_len(&conn->trailer);
 224           if(!data->set.http_te_skip) {
 225             result = Curl_client_write(data,
 226                                        CLIENTWRITE_HEADER|CLIENTWRITE_TRAILER,
 227                                        tr, trlen);
 228             if(result) {
 229               *extrap = result;
 230               return CHUNKE_PASSTHRU_ERROR;
 231             }
 232           }
 233           Curl_dyn_reset(&conn->trailer);
 234           ch->state = CHUNK_TRAILER_CR;
 235           if(*datap == 0x0a)
 236             /* already on the LF */
 237             break;
 238         }
 239         else {
 240           /* no trailer, we're on the final CRLF pair */
 241           ch->state = CHUNK_TRAILER_POSTCR;
 242           break; /* don't advance the pointer */
 243         }
 244       }
 245       else {
 246         result = Curl_dyn_addn(&conn->trailer, datap, 1);
 247         if(result)
 248           return CHUNKE_OUT_OF_MEMORY;
 249       }
 250       datap++;
 251       length--;
 252       break;
 253
 254     case CHUNK_TRAILER_CR:
 255       if(*datap == 0x0a) {
 256         ch->state = CHUNK_TRAILER_POSTCR;
 257         datap++;
 258         length--;
 259       }
 260       else
 261         return CHUNKE_BAD_CHUNK;
 262       break;
 263
 264     case CHUNK_TRAILER_POSTCR:
 265       /* We enter this state when a CR should arrive so we expect to
 266          have to first pass a CR before we wait for LF */
 267       if((*datap != 0x0d) && (*datap != 0x0a)) {
 268         /* not a CR then it must be another header in the trailer */
 269         ch->state = CHUNK_TRAILER;
 270         break;
 271       }
 272       if(*datap == 0x0d) {
 273         /* skip if CR */
 274         datap++;
 275         length--;
 276       }
 277       /* now wait for the final LF */
 278       ch->state = CHUNK_STOP;
 279       break;
 280
 281     case CHUNK_STOP:
 282       if(*datap == 0x0a) {
 283         length--;
 284
 285         /* Record the length of any data left in the end of the buffer
 286            even if there's no more chunks to read */
 287         ch->datasize = curlx_sotouz(length);
 288
 289         return CHUNKE_STOP; /* return stop */
 290       }
 291       else
 292         return CHUNKE_BAD_CHUNK;
 293     }
 294   }
 295   return CHUNKE_OK;
 296 }
 297
 298 const char *Curl_chunked_strerror(CHUNKcode code)
 299 {
 300   switch(code) {
 301   default:
 302     return "OK";
 303   case CHUNKE_TOO_LONG_HEX:
 304     return "Too long hexadecimal number";
 305   case CHUNKE_ILLEGAL_HEX:
 306     return "Illegal or missing hexadecimal sequence";
 307   case CHUNKE_BAD_CHUNK:
 308     return "Malformed encoding found";
 309   case CHUNKE_PASSTHRU_ERROR:
 310     DEBUGASSERT(0); /* never used */
 311     return "";
 312   case CHUNKE_BAD_ENCODING:
 313     return "Bad content-encoding found";
 314   case CHUNKE_OUT_OF_MEMORY:
 315     return "Out of memory";
 316   }
 317 }
 318
 319 #endif /* CURL_DISABLE_HTTP */