1 /*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel (at) 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 Curl_easy *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 if(curlx_strtoofft(ch->hexbuffer, &endptr, 16, &ch->datasize)) 162 return CHUNKE_ILLEGAL_HEX; 163 ch->state = CHUNK_LF; /* now wait for the CRLF */ 164 } 165 break; 166 167 case CHUNK_LF: 168 /* waiting for the LF after a chunk size */ 169 if(*datap == 0x0a) { 170 /* we're now expecting data to come, unless size was zero! */ 171 if(0 == ch->datasize) { 172 ch->state = CHUNK_TRAILER; /* now check for trailers */ 173 conn->trlPos = 0; 174 } 175 else 176 ch->state = CHUNK_DATA; 177 } 178 179 datap++; 180 length--; 181 break; 182 183 case CHUNK_DATA: 184 /* We expect 'datasize' of data. We have 'length' right now, it can be 185 more or less than 'datasize'. Get the smallest piece. 186 */ 187 piece = curlx_sotouz((ch->datasize >= length)?length:ch->datasize); 188 189 /* Write the data portion available */ 190 if(conn->data->set.http_ce_skip || !k->writer_stack) { 191 if(!k->ignorebody) 192 result = Curl_client_write(conn, CLIENTWRITE_BODY, datap, piece); 193 } 194 else 195 result = Curl_unencode_write(conn, k->writer_stack, datap, piece); 196 197 if(result) 198 return CHUNKE_WRITE_ERROR; 199 200 *wrote += piece; 201 ch->datasize -= piece; /* decrease amount left to expect */ 202 datap += piece; /* move read pointer forward */ 203 length -= piece; /* decrease space left in this round */ 204 205 if(0 == ch->datasize) 206 /* end of data this round, we now expect a trailing CRLF */ 207 ch->state = CHUNK_POSTLF; 208 break; 209 210 case CHUNK_POSTLF: 211 if(*datap == 0x0a) { 212 /* The last one before we go back to hex state and start all over. */ 213 Curl_httpchunk_init(conn); /* sets state back to CHUNK_HEX */ 214 } 215 else if(*datap != 0x0d) 216 return CHUNKE_BAD_CHUNK; 217 datap++; 218 length--; 219 break; 220 221 case CHUNK_TRAILER: 222 if((*datap == 0x0d) || (*datap == 0x0a)) { 223 /* this is the end of a trailer, but if the trailer was zero bytes 224 there was no trailer and we move on */ 225 226 if(conn->trlPos) { 227 /* we allocate trailer with 3 bytes extra room to fit this */ 228 conn->trailer[conn->trlPos++] = 0x0d; 229 conn->trailer[conn->trlPos++] = 0x0a; 230 conn->trailer[conn->trlPos] = 0; 231 232 /* Convert to host encoding before calling Curl_client_write */ 233 result = Curl_convert_from_network(conn->data, conn->trailer, 234 conn->trlPos); 235 if(result) 236 /* Curl_convert_from_network calls failf if unsuccessful */ 237 /* Treat it as a bad chunk */ 238 return CHUNKE_BAD_CHUNK; 239 240 if(!data->set.http_te_skip) { 241 result = Curl_client_write(conn, CLIENTWRITE_HEADER, 242 conn->trailer, conn->trlPos); 243 if(result) 244 return CHUNKE_WRITE_ERROR; 245 } 246 conn->trlPos = 0; 247 ch->state = CHUNK_TRAILER_CR; 248 if(*datap == 0x0a) 249 /* already on the LF */ 250 break; 251 } 252 else { 253 /* no trailer, we're on the final CRLF pair */ 254 ch->state = CHUNK_TRAILER_POSTCR; 255 break; /* don't advance the pointer */ 256 } 257 } 258 else { 259 /* conn->trailer is assumed to be freed in url.c on a 260 connection basis */ 261 if(conn->trlPos >= conn->trlMax) { 262 /* we always allocate three extra bytes, just because when the full 263 header has been received we append CRLF\0 */ 264 char *ptr; 265 if(conn->trlMax) { 266 conn->trlMax *= 2; 267 ptr = realloc(conn->trailer, conn->trlMax + 3); 268 } 269 else { 270 conn->trlMax = 128; 271 ptr = malloc(conn->trlMax + 3); 272 } 273 if(!ptr) 274 return CHUNKE_OUT_OF_MEMORY; 275 conn->trailer = ptr; 276 } 277 conn->trailer[conn->trlPos++]=*datap; 278 } 279 datap++; 280 length--; 281 break; 282 283 case CHUNK_TRAILER_CR: 284 if(*datap == 0x0a) { 285 ch->state = CHUNK_TRAILER_POSTCR; 286 datap++; 287 length--; 288 } 289 else 290 return CHUNKE_BAD_CHUNK; 291 break; 292 293 case CHUNK_TRAILER_POSTCR: 294 /* We enter this state when a CR should arrive so we expect to 295 have to first pass a CR before we wait for LF */ 296 if((*datap != 0x0d) && (*datap != 0x0a)) { 297 /* not a CR then it must be another header in the trailer */ 298 ch->state = CHUNK_TRAILER; 299 break; 300 } 301 if(*datap == 0x0d) { 302 /* skip if CR */ 303 datap++; 304 length--; 305 } 306 /* now wait for the final LF */ 307 ch->state = CHUNK_STOP; 308 break; 309 310 case CHUNK_STOP: 311 if(*datap == 0x0a) { 312 length--; 313 314 /* Record the length of any data left in the end of the buffer 315 even if there's no more chunks to read */ 316 ch->dataleft = curlx_sotouz(length); 317 318 return CHUNKE_STOP; /* return stop */ 319 } 320 else 321 return CHUNKE_BAD_CHUNK; 322 } 323 } 324 return CHUNKE_OK; 325 } 326 327 const char *Curl_chunked_strerror(CHUNKcode code) 328 { 329 switch(code) { 330 default: 331 return "OK"; 332 case CHUNKE_TOO_LONG_HEX: 333 return "Too long hexadecimal number"; 334 case CHUNKE_ILLEGAL_HEX: 335 return "Illegal or missing hexadecimal sequence"; 336 case CHUNKE_BAD_CHUNK: 337 return "Malformed encoding found"; 338 case CHUNKE_WRITE_ERROR: 339 return "Write error"; 340 case CHUNKE_BAD_ENCODING: 341 return "Bad content-encoding found"; 342 case CHUNKE_OUT_OF_MEMORY: 343 return "Out of memory"; 344 } 345 } 346 347 #endif /* CURL_DISABLE_HTTP */ 348
