lib/http_chunks.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2014, 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 #include "strtoofft.h"
  35 #include "warnless.h"
  36
  37 #define _MPRINTF_REPLACE /* use our functions only */
  38 #include <curl/mprintf.h>
  39
  40 /* The last #include file should be: */
  41 #include "memdebug.h"
  42
  43 /*
  44  * Chunk format (simplified):
  45  *
  46  * <HEX SIZE>[ chunk extension ] CRLF
  47  * <DATA> CRLF
  48  *
  49  * Highlights from RFC2616 section 3.6 say:
  50
  51    The chunked encoding modifies the body of a message in order to
  52    transfer it as a series of chunks, each with its own size indicator,
  53    followed by an OPTIONAL trailer containing entity-header fields. This
  54    allows dynamically produced content to be transferred along with the
  55    information necessary for the recipient to verify that it has
  56    received the full message.
  57
  58        Chunked-Body   = *chunk
  59                         last-chunk
  60                         trailer
  61                         CRLF
  62
  63        chunk          = chunk-size [ chunk-extension ] CRLF
  64                         chunk-data CRLF
  65        chunk-size     = 1*HEX
  66        last-chunk     = 1*("0") [ chunk-extension ] CRLF
  67
  68        chunk-extension= *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
  69        chunk-ext-name = token
  70        chunk-ext-val  = token | quoted-string
  71        chunk-data     = chunk-size(OCTET)
  72        trailer        = *(entity-header CRLF)
  73
  74    The chunk-size field is a string of hex digits indicating the size of
  75    the chunk. The chunked encoding is ended by any chunk whose size is
  76    zero, followed by the trailer, which is terminated by an empty line.
  77
  78  */
  79
  80 /* Check for an ASCII hex digit.
  81  We avoid the use of isxdigit to accommodate non-ASCII hosts. */
  82 static bool Curl_isxdigit(char digit)
  83 {
  84   return ( (digit >= 0x30 && digit <= 0x39) /* 0-9 */
  85         || (digit >= 0x41 && digit <= 0x46) /* A-F */
  86         || (digit >= 0x61 && digit <= 0x66) /* a-f */ ) ? TRUE : FALSE;
  87 }
  88
  89 void Curl_httpchunk_init(struct connectdata *conn)
  90 {
  91   struct Curl_chunker *chunk = &conn->chunk;
  92   chunk->hexindex=0;        /* start at 0 */
  93   chunk->dataleft=0;        /* no data left yet! */
  94   chunk->state = CHUNK_HEX; /* we get hex first! */
  95 }
  96
  97 /*
  98  * chunk_read() returns a OK for normal operations, or a positive return code
  99  * for errors. STOP means this sequence of chunks is complete.  The 'wrote'
 100  * argument is set to tell the caller how many bytes we actually passed to the
 101  * client (for byte-counting and whatever).
 102  *
 103  * The states and the state-machine is further explained in the header file.
 104  *
 105  * This function always uses ASCII hex values to accommodate non-ASCII hosts.
 106  * For example, 0x0d and 0x0a are used instead of '\r' and '\n'.
 107  */
 108 CHUNKcode Curl_httpchunk_read(struct connectdata *conn,
 109                               char *datap,
 110                               ssize_t datalen,
 111                               ssize_t *wrotep)
 112 {
 113   CURLcode result=CURLE_OK;
 114   struct SessionHandle *data = conn->data;
 115   struct Curl_chunker *ch = &conn->chunk;
 116   struct SingleRequest *k = &data->req;
 117   size_t piece;
 118   curl_off_t length = (curl_off_t)datalen;
 119   size_t *wrote = (size_t *)wrotep;
 120
 121   *wrote = 0; /* nothing's written yet */
 122
 123   /* the original data is written to the client, but we go on with the
 124      chunk read process, to properly calculate the content length*/
 125   if(data->set.http_te_skip && !k->ignorebody) {
 126     result = Curl_client_write(conn, CLIENTWRITE_BODY, datap, datalen);
 127     if(result)
 128       return CHUNKE_WRITE_ERROR;
 129   }
 130
 131   while(length) {
 132     switch(ch->state) {
 133     case CHUNK_HEX:
 134       if(Curl_isxdigit(*datap)) {
 135         if(ch->hexindex < MAXNUM_SIZE) {
 136           ch->hexbuffer[ch->hexindex] = *datap;
 137           datap++;
 138           length--;
 139           ch->hexindex++;
 140         }
 141         else {
 142           return CHUNKE_TOO_LONG_HEX; /* longer hex than we support */
 143         }
 144       }
 145       else {
 146         char *endptr;
 147         if(0 == ch->hexindex)
 148           /* This is illegal data, we received junk where we expected
 149              a hexadecimal digit. */
 150           return CHUNKE_ILLEGAL_HEX;
 151
 152         /* length and datap are unmodified */
 153         ch->hexbuffer[ch->hexindex]=0;
 154
 155         /* convert to host encoding before calling strtoul */
 156         result = Curl_convert_from_network(conn->data, ch->hexbuffer,
 157                                            ch->hexindex);
 158         if(result) {
 159           /* Curl_convert_from_network calls failf if unsuccessful */
 160           /* Treat it as a bad hex character */
 161           return CHUNKE_ILLEGAL_HEX ;
 162         }
 163
 164         ch->datasize=curlx_strtoofft(ch->hexbuffer, &endptr, 16);
 165         if((ch->datasize == CURL_OFF_T_MAX) && (errno == ERANGE))
 166           /* overflow is an error */
 167           return CHUNKE_ILLEGAL_HEX;
 168         ch->state = CHUNK_LF; /* now wait for the CRLF */
 169       }
 170       break;
 171
 172     case CHUNK_LF:
 173       /* waiting for the LF after a chunk size */
 174       if(*datap == 0x0a) {
 175         /* we're now expecting data to come, unless size was zero! */
 176         if(0 == ch->datasize) {
 177           ch->state = CHUNK_TRAILER; /* now check for trailers */
 178           conn->trlPos=0;
 179         }
 180         else
 181           ch->state = CHUNK_DATA;
 182       }
 183
 184       datap++;
 185       length--;
 186       break;
 187
 188     case CHUNK_DATA:
 189       /* We expect 'datasize' of data. We have 'length' right now, it can be
 190          more or less than 'datasize'. Get the smallest piece.
 191       */
 192       piece = curlx_sotouz((ch->datasize >= length)?length:ch->datasize);
 193
 194       /* Write the data portion available */
 195 #ifdef HAVE_LIBZ
 196       switch (conn->data->set.http_ce_skip?
 197               IDENTITY : data->req.auto_decoding) {
 198       case IDENTITY:
 199 #endif
 200         if(!k->ignorebody) {
 201           if(!data->set.http_te_skip)
 202             result = Curl_client_write(conn, CLIENTWRITE_BODY, datap,
 203                                        piece);
 204           else
 205             result = CURLE_OK;
 206         }
 207 #ifdef HAVE_LIBZ
 208         break;
 209
 210       case DEFLATE:
 211         /* update data->req.keep.str to point to the chunk data. */
 212         data->req.str = datap;
 213         result = Curl_unencode_deflate_write(conn, &data->req,
 214                                              (ssize_t)piece);
 215         break;
 216
 217       case GZIP:
 218         /* update data->req.keep.str to point to the chunk data. */
 219         data->req.str = datap;
 220         result = Curl_unencode_gzip_write(conn, &data->req,
 221                                           (ssize_t)piece);
 222         break;
 223
 224       case COMPRESS:
 225       default:
 226         failf (conn->data,
 227                "Unrecognized content encoding type. "
 228                "libcurl understands `identity', `deflate' and `gzip' "
 229                "content encodings.");
 230         return CHUNKE_BAD_ENCODING;
 231       }
 232 #endif
 233
 234       if(result)
 235         return CHUNKE_WRITE_ERROR;
 236
 237       *wrote += piece;
 238
 239       ch->datasize -= piece; /* decrease amount left to expect */
 240       datap += piece;    /* move read pointer forward */
 241       length -= piece;   /* decrease space left in this round */
 242
 243       if(0 == ch->datasize)
 244         /* end of data this round, we now expect a trailing CRLF */
 245         ch->state = CHUNK_POSTLF;
 246       break;
 247
 248     case CHUNK_POSTLF:
 249       if(*datap == 0x0a) {
 250         /* The last one before we go back to hex state and start all over. */
 251         Curl_httpchunk_init(conn); /* sets state back to CHUNK_HEX */
 252       }
 253       else if(*datap != 0x0d)
 254         return CHUNKE_BAD_CHUNK;
 255       datap++;
 256       length--;
 257       break;
 258
 259     case CHUNK_TRAILER:
 260       if((*datap == 0x0d) || (*datap == 0x0a)) {
 261         /* this is the end of a trailer, but if the trailer was zero bytes
 262            there was no trailer and we move on */
 263
 264         if(conn->trlPos) {
 265           /* we allocate trailer with 3 bytes extra room to fit this */
 266           conn->trailer[conn->trlPos++]=0x0d;
 267           conn->trailer[conn->trlPos++]=0x0a;
 268           conn->trailer[conn->trlPos]=0;
 269
 270           /* Convert to host encoding before calling Curl_client_write */
 271           result = Curl_convert_from_network(conn->data, conn->trailer,
 272                                              conn->trlPos);
 273           if(result)
 274             /* Curl_convert_from_network calls failf if unsuccessful */
 275             /* Treat it as a bad chunk */
 276             return CHUNKE_BAD_CHUNK;
 277
 278           if(!data->set.http_te_skip) {
 279             result = Curl_client_write(conn, CLIENTWRITE_HEADER,
 280                                        conn->trailer, conn->trlPos);
 281             if(result)
 282               return CHUNKE_WRITE_ERROR;
 283           }
 284           conn->trlPos=0;
 285           ch->state = CHUNK_TRAILER_CR;
 286           if(*datap == 0x0a)
 287             /* already on the LF */
 288             break;
 289         }
 290         else {
 291           /* no trailer, we're on the final CRLF pair */
 292           ch->state = CHUNK_TRAILER_POSTCR;
 293           break; /* don't advance the pointer */
 294         }
 295       }
 296       else {
 297         /* conn->trailer is assumed to be freed in url.c on a
 298            connection basis */
 299         if(conn->trlPos >= conn->trlMax) {
 300           /* we always allocate three extra bytes, just because when the full
 301              header has been received we append CRLF\0 */
 302           char *ptr;
 303           if(conn->trlMax) {
 304             conn->trlMax *= 2;
 305             ptr = realloc(conn->trailer, conn->trlMax + 3);
 306           }
 307           else {
 308             conn->trlMax=128;
 309             ptr = malloc(conn->trlMax + 3);
 310           }
 311           if(!ptr)
 312             return CHUNKE_OUT_OF_MEMORY;
 313           conn->trailer = ptr;
 314         }
 315         conn->trailer[conn->trlPos++]=*datap;
 316       }
 317       datap++;
 318       length--;
 319       break;
 320
 321     case CHUNK_TRAILER_CR:
 322       if(*datap == 0x0a) {
 323         ch->state = CHUNK_TRAILER_POSTCR;
 324         datap++;
 325         length--;
 326       }
 327       else
 328         return CHUNKE_BAD_CHUNK;
 329       break;
 330
 331     case CHUNK_TRAILER_POSTCR:
 332       /* We enter this state when a CR should arrive so we expect to
 333          have to first pass a CR before we wait for LF */
 334       if((*datap != 0x0d) && (*datap != 0x0a)) {
 335         /* not a CR then it must be another header in the trailer */
 336         ch->state = CHUNK_TRAILER;
 337         break;
 338       }
 339       if(*datap == 0x0d) {
 340         /* skip if CR */
 341         datap++;
 342         length--;
 343       }
 344       /* now wait for the final LF */
 345       ch->state = CHUNK_STOP;
 346       break;
 347
 348     case CHUNK_STOP:
 349       if(*datap == 0x0a) {
 350         length--;
 351
 352         /* Record the length of any data left in the end of the buffer
 353            even if there's no more chunks to read */
 354         ch->dataleft = curlx_sotouz(length);
 355
 356         return CHUNKE_STOP; /* return stop */
 357       }
 358       else
 359         return CHUNKE_BAD_CHUNK;
 360     }
 361   }
 362   return CHUNKE_OK;
 363 }
 364
 365 const char *Curl_chunked_strerror(CHUNKcode code)
 366 {
 367   switch (code) {
 368   default:
 369     return "OK";
 370   case CHUNKE_TOO_LONG_HEX:
 371     return "Too long hexadecimal number";
 372   case CHUNKE_ILLEGAL_HEX:
 373     return "Illegal or missing hexadecimal sequence";
 374   case CHUNKE_BAD_CHUNK:
 375     return "Malformed encoding found";
 376   case CHUNKE_WRITE_ERROR:
 377     return "Write error";
 378   case CHUNKE_BAD_ENCODING:
 379     return "Bad content-encoding found";
 380   case CHUNKE_OUT_OF_MEMORY:
 381     return "Out of memory";
 382   }
 383 }
 384
 385 #endif /* CURL_DISABLE_HTTP */