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