lib/http_chunks.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2011, 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 http://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 #ifndef CURL_DISABLE_HTTP
  26
  27 #include "urldata.h" /* it includes http_chunks.h */
  28 #include "sendf.h"   /* for the client write stuff */
  29
  30 #include "content_encoding.h"
  31 #include "http.h"
  32 #include "curl_memory.h"
  33 #include "non-ascii.h" /* for Curl_convert_to_network prototype */
  34
  35 #define _MPRINTF_REPLACE /* use our functions only */
  36 #include <curl/mprintf.h>
  37
  38 /* The last #include file should be: */
  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 /* Check for an ASCII hex digit.
  79  We avoid the use of isxdigit to accommodate non-ASCII hosts. */
  80 static bool Curl_isxdigit(char digit)
  81 {
  82   return ( (digit >= 0x30 && digit <= 0x39) /* 0-9 */
  83         || (digit >= 0x41 && digit <= 0x46) /* A-F */
  84         || (digit >= 0x61 && digit <= 0x66) /* a-f */ ) ? TRUE : FALSE;
  85 }
  86
  87 void Curl_httpchunk_init(struct connectdata *conn)
  88 {
  89   struct Curl_chunker *chunk = &conn->chunk;
  90   chunk->hexindex=0; /* start at 0 */
  91   chunk->dataleft=0; /* no data left yet! */
  92   chunk->state = CHUNK_HEX; /* we get hex first! */
  93 }
  94
  95 /*
  96  * chunk_read() returns a OK for normal operations, or a positive return code
  97  * for errors. STOP means this sequence of chunks is complete.  The 'wrote'
  98  * argument is set to tell the caller how many bytes we actually passed to the
  99  * client (for byte-counting and whatever).
 100  *
 101  * The states and the state-machine is further explained in the header file.
 102  *
 103  * This function always uses ASCII hex values to accommodate non-ASCII hosts.
 104  * For example, 0x0d and 0x0a are used instead of '\r' and '\n'.
 105  */
 106 CHUNKcode Curl_httpchunk_read(struct connectdata *conn,
 107                               char *datap,
 108                               ssize_t datalen,
 109                               ssize_t *wrotep)
 110 {
 111   CURLcode result=CURLE_OK;
 112   struct SessionHandle *data = conn->data;
 113   struct Curl_chunker *ch = &conn->chunk;
 114   struct SingleRequest *k = &data->req;
 115   size_t piece;
 116   size_t length = (size_t)datalen;
 117   size_t *wrote = (size_t *)wrotep;
 118
 119   *wrote = 0; /* nothing's written yet */
 120
 121   /* the original data is written to the client, but we go on with the
 122      chunk read process, to properly calculate the content length*/
 123   if(data->set.http_te_skip && !k->ignorebody) {
 124     result = Curl_client_write(conn, CLIENTWRITE_BODY, datap, datalen);
 125     if(result)
 126       return CHUNKE_WRITE_ERROR;
 127   }
 128
 129   while(length) {
 130     switch(ch->state) {
 131     case CHUNK_HEX:
 132       if(Curl_isxdigit(*datap)) {
 133         if(ch->hexindex < MAXNUM_SIZE) {
 134           ch->hexbuffer[ch->hexindex] = *datap;
 135           datap++;
 136           length--;
 137           ch->hexindex++;
 138         }
 139         else {
 140           return CHUNKE_TOO_LONG_HEX; /* longer hex than we support */
 141         }
 142       }
 143       else {
 144         if(0 == ch->hexindex) {
 145           /* This is illegal data, we received junk where we expected
 146              a hexadecimal digit. */
 147           return CHUNKE_ILLEGAL_HEX;
 148         }
 149         /* length and datap are unmodified */
 150         ch->hexbuffer[ch->hexindex]=0;
 151
 152         /* convert to host encoding before calling strtoul */
 153         result = Curl_convert_from_network(conn->data, ch->hexbuffer,
 154                                            ch->hexindex);
 155         if(result) {
 156           /* Curl_convert_from_network calls failf if unsuccessful */
 157           /* Treat it as a bad hex character */
 158           return(CHUNKE_ILLEGAL_HEX);
 159         }
 160
 161         ch->datasize=strtoul(ch->hexbuffer, NULL, 16);
 162         ch->state = CHUNK_POSTHEX;
 163       }
 164       break;
 165
 166     case CHUNK_POSTHEX:
 167       /* In this state, we're waiting for CRLF to arrive. We support
 168          this to allow so called chunk-extensions to show up here
 169          before the CRLF comes. */
 170       if(*datap == 0x0d)
 171         ch->state = CHUNK_CR;
 172       length--;
 173       datap++;
 174       break;
 175
 176     case CHUNK_CR:
 177       /* waiting for the LF */
 178       if(*datap == 0x0a) {
 179         /* we're now expecting data to come, unless size was zero! */
 180         if(0 == ch->datasize) {
 181           ch->state = CHUNK_TRAILER; /* now check for trailers */
 182           conn->trlPos=0;
 183         }
 184         else {
 185           ch->state = CHUNK_DATA;
 186         }
 187       }
 188       else
 189         /* previously we got a fake CR, go back to CR waiting! */
 190         ch->state = CHUNK_CR;
 191       datap++;
 192       length--;
 193       break;
 194
 195     case CHUNK_DATA:
 196       /* we get pure and fine data
 197
 198          We expect another 'datasize' of data. We have 'length' right now,
 199          it can be more or less than 'datasize'. Get the smallest piece.
 200       */
 201       piece = (ch->datasize >= length)?length:ch->datasize;
 202
 203       /* Write the data portion available */
 204 #ifdef HAVE_LIBZ
 205       switch (conn->data->set.http_ce_skip?
 206               IDENTITY : data->req.auto_decoding) {
 207       case IDENTITY:
 208 #endif
 209         if(!k->ignorebody) {
 210           if(!data->set.http_te_skip)
 211             result = Curl_client_write(conn, CLIENTWRITE_BODY, datap,
 212                                        piece);
 213           else
 214             result = CURLE_OK;
 215         }
 216 #ifdef HAVE_LIBZ
 217         break;
 218
 219       case DEFLATE:
 220         /* update data->req.keep.str to point to the chunk data. */
 221         data->req.str = datap;
 222         result = Curl_unencode_deflate_write(conn, &data->req,
 223                                              (ssize_t)piece);
 224         break;
 225
 226       case GZIP:
 227         /* update data->req.keep.str to point to the chunk data. */
 228         data->req.str = datap;
 229         result = Curl_unencode_gzip_write(conn, &data->req,
 230                                           (ssize_t)piece);
 231         break;
 232
 233       case COMPRESS:
 234       default:
 235         failf (conn->data,
 236                "Unrecognized content encoding type. "
 237                "libcurl understands `identity', `deflate' and `gzip' "
 238                "content encodings.");
 239         return CHUNKE_BAD_ENCODING;
 240       }
 241 #endif
 242
 243       if(result)
 244         return CHUNKE_WRITE_ERROR;
 245
 246       *wrote += piece;
 247
 248       ch->datasize -= piece; /* decrease amount left to expect */
 249       datap += piece;    /* move read pointer forward */
 250       length -= piece;   /* decrease space left in this round */
 251
 252       if(0 == ch->datasize)
 253         /* end of data this round, we now expect a trailing CRLF */
 254         ch->state = CHUNK_POSTCR;
 255       break;
 256
 257     case CHUNK_POSTCR:
 258       if(*datap == 0x0d) {
 259         ch->state = CHUNK_POSTLF;
 260         datap++;
 261         length--;
 262       }
 263       else
 264         return CHUNKE_BAD_CHUNK;
 265
 266       break;
 267
 268     case CHUNK_POSTLF:
 269       if(*datap == 0x0a) {
 270         /*
 271          * The last one before we go back to hex state and start all
 272          * over.
 273          */
 274         Curl_httpchunk_init(conn);
 275         datap++;
 276         length--;
 277       }
 278       else
 279         return CHUNKE_BAD_CHUNK;
 280
 281       break;
 282
 283     case CHUNK_TRAILER:
 284       if(*datap == 0x0d) {
 285         /* this is the end of a trailer, but if the trailer was zero bytes
 286            there was no trailer and we move on */
 287
 288         if(conn->trlPos) {
 289           /* we allocate trailer with 3 bytes extra room to fit this */
 290           conn->trailer[conn->trlPos++]=0x0d;
 291           conn->trailer[conn->trlPos++]=0x0a;
 292           conn->trailer[conn->trlPos]=0;
 293
 294           /* Convert to host encoding before calling Curl_client_write */
 295           result = Curl_convert_from_network(conn->data, conn->trailer,
 296                                              conn->trlPos);
 297           if(result)
 298             /* Curl_convert_from_network calls failf if unsuccessful */
 299             /* Treat it as a bad chunk */
 300             return CHUNKE_BAD_CHUNK;
 301
 302           if(!data->set.http_te_skip) {
 303             result = Curl_client_write(conn, CLIENTWRITE_HEADER,
 304                                        conn->trailer, conn->trlPos);
 305             if(result)
 306               return CHUNKE_WRITE_ERROR;
 307           }
 308           conn->trlPos=0;
 309           ch->state = CHUNK_TRAILER_CR;
 310         }
 311         else {
 312           /* no trailer, we're on the final CRLF pair */
 313           ch->state = CHUNK_TRAILER_POSTCR;
 314           break; /* don't advance the pointer */
 315         }
 316       }
 317       else {
 318         /* conn->trailer is assumed to be freed in url.c on a
 319            connection basis */
 320         if(conn->trlPos >= conn->trlMax) {
 321           /* we always allocate three extra bytes, just because when the full
 322              header has been received we append CRLF\0 */
 323           char *ptr;
 324           if(conn->trlMax) {
 325             conn->trlMax *= 2;
 326             ptr = realloc(conn->trailer, conn->trlMax + 3);
 327           }
 328           else {
 329             conn->trlMax=128;
 330             ptr = malloc(conn->trlMax + 3);
 331           }
 332           if(!ptr)
 333             return CHUNKE_OUT_OF_MEMORY;
 334           conn->trailer = ptr;
 335         }
 336         conn->trailer[conn->trlPos++]=*datap;
 337       }
 338       datap++;
 339       length--;
 340       break;
 341
 342     case CHUNK_TRAILER_CR:
 343       if(*datap == 0x0a) {
 344         ch->state = CHUNK_TRAILER_POSTCR;
 345         datap++;
 346         length--;
 347       }
 348       else
 349         return CHUNKE_BAD_CHUNK;
 350       break;
 351
 352     case CHUNK_TRAILER_POSTCR:
 353       /* We enter this state when a CR should arrive so we expect to
 354          have to first pass a CR before we wait for LF */
 355       if(*datap != 0x0d) {
 356         /* not a CR then it must be another header in the trailer */
 357         ch->state = CHUNK_TRAILER;
 358         break;
 359       }
 360       datap++;
 361       length--;
 362       /* now wait for the final LF */
 363       ch->state = CHUNK_STOP;
 364       break;
 365
 366     case CHUNK_STOPCR:
 367       /* Read the final CRLF that ends all chunk bodies */
 368
 369       if(*datap == 0x0d) {
 370         ch->state = CHUNK_STOP;
 371         datap++;
 372         length--;
 373       }
 374       else
 375         return CHUNKE_BAD_CHUNK;
 376       break;
 377
 378     case CHUNK_STOP:
 379       if(*datap == 0x0a) {
 380         length--;
 381
 382         /* Record the length of any data left in the end of the buffer
 383            even if there's no more chunks to read */
 384
 385         ch->dataleft = length;
 386         return CHUNKE_STOP; /* return stop */
 387       }
 388       else
 389         return CHUNKE_BAD_CHUNK;
 390
 391     default:
 392       return CHUNKE_STATE_ERROR;
 393     }
 394   }
 395   return CHUNKE_OK;
 396 }
 397 #endif /* CURL_DISABLE_HTTP */