• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /***************************************************************************
2  *                                  _   _ ____  _
3  *  Project                     ___| | | |  _ \| |
4  *                             / __| | | | |_) | |
5  *                            | (__| |_| |  _ <| |___
6  *                             \___|\___/|_| \_\_____|
7  *
8  * Copyright (C) 1998 - 2020, 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 #include "dynbuf.h"
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 #ifdef CURL_DOES_CONVERSIONS
78 /* Check for an ASCII hex digit.
79    We avoid the use of ISXDIGIT to accommodate non-ASCII hosts. */
Curl_isxdigit_ascii(char digit)80 static bool Curl_isxdigit_ascii(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 */
85 }
86 #else
87 #define Curl_isxdigit_ascii(x) Curl_isxdigit(x)
88 #endif
89 
Curl_httpchunk_init(struct connectdata * conn)90 void Curl_httpchunk_init(struct connectdata *conn)
91 {
92   struct Curl_chunker *chunk = &conn->chunk;
93   chunk->hexindex = 0;      /* start at 0 */
94   chunk->dataleft = 0;      /* no data left yet! */
95   chunk->state = CHUNK_HEX; /* we get hex first! */
96   Curl_dyn_init(&conn->trailer, DYN_H1_TRAILER);
97 }
98 
99 /*
100  * chunk_read() returns a OK for normal operations, or a positive return code
101  * for errors. STOP means this sequence of chunks is complete.  The 'wrote'
102  * argument is set to tell the caller how many bytes we actually passed to the
103  * client (for byte-counting and whatever).
104  *
105  * The states and the state-machine is further explained in the header file.
106  *
107  * This function always uses ASCII hex values to accommodate non-ASCII hosts.
108  * For example, 0x0d and 0x0a are used instead of '\r' and '\n'.
109  */
Curl_httpchunk_read(struct connectdata * conn,char * datap,ssize_t datalen,ssize_t * wrotep,CURLcode * extrap)110 CHUNKcode Curl_httpchunk_read(struct connectdata *conn,
111                               char *datap,
112                               ssize_t datalen,
113                               ssize_t *wrotep,
114                               CURLcode *extrap)
115 {
116   CURLcode result = CURLE_OK;
117   struct Curl_easy *data = conn->data;
118   struct Curl_chunker *ch = &conn->chunk;
119   struct SingleRequest *k = &data->req;
120   size_t piece;
121   curl_off_t length = (curl_off_t)datalen;
122   size_t *wrote = (size_t *)wrotep;
123 
124   *wrote = 0; /* nothing's written yet */
125 
126   /* the original data is written to the client, but we go on with the
127      chunk read process, to properly calculate the content length*/
128   if(data->set.http_te_skip && !k->ignorebody) {
129     result = Curl_client_write(conn, CLIENTWRITE_BODY, datap, datalen);
130     if(result) {
131       *extrap = result;
132       return CHUNKE_PASSTHRU_ERROR;
133     }
134   }
135 
136   while(length) {
137     switch(ch->state) {
138     case CHUNK_HEX:
139       if(Curl_isxdigit_ascii(*datap)) {
140         if(ch->hexindex < MAXNUM_SIZE) {
141           ch->hexbuffer[ch->hexindex] = *datap;
142           datap++;
143           length--;
144           ch->hexindex++;
145         }
146         else {
147           return CHUNKE_TOO_LONG_HEX; /* longer hex than we support */
148         }
149       }
150       else {
151         char *endptr;
152         if(0 == ch->hexindex)
153           /* This is illegal data, we received junk where we expected
154              a hexadecimal digit. */
155           return CHUNKE_ILLEGAL_HEX;
156 
157         /* length and datap are unmodified */
158         ch->hexbuffer[ch->hexindex] = 0;
159 
160         /* convert to host encoding before calling strtoul */
161         result = Curl_convert_from_network(conn->data, ch->hexbuffer,
162                                            ch->hexindex);
163         if(result) {
164           /* Curl_convert_from_network calls failf if unsuccessful */
165           /* Treat it as a bad hex character */
166           return CHUNKE_ILLEGAL_HEX;
167         }
168 
169         if(curlx_strtoofft(ch->hexbuffer, &endptr, 16, &ch->datasize))
170           return CHUNKE_ILLEGAL_HEX;
171         ch->state = CHUNK_LF; /* now wait for the CRLF */
172       }
173       break;
174 
175     case CHUNK_LF:
176       /* waiting for the LF after a chunk size */
177       if(*datap == 0x0a) {
178         /* we're now expecting data to come, unless size was zero! */
179         if(0 == ch->datasize) {
180           ch->state = CHUNK_TRAILER; /* now check for trailers */
181         }
182         else
183           ch->state = CHUNK_DATA;
184       }
185 
186       datap++;
187       length--;
188       break;
189 
190     case CHUNK_DATA:
191       /* We expect 'datasize' of data. We have 'length' right now, it can be
192          more or less than 'datasize'. Get the smallest piece.
193       */
194       piece = curlx_sotouz((ch->datasize >= length)?length:ch->datasize);
195 
196       /* Write the data portion available */
197       if(!conn->data->set.http_te_skip && !k->ignorebody) {
198         if(!conn->data->set.http_ce_skip && k->writer_stack)
199           result = Curl_unencode_write(conn, k->writer_stack, datap, piece);
200         else
201           result = Curl_client_write(conn, CLIENTWRITE_BODY, datap, piece);
202 
203         if(result) {
204           *extrap = result;
205           return CHUNKE_PASSTHRU_ERROR;
206         }
207       }
208 
209       *wrote += piece;
210       ch->datasize -= piece; /* decrease amount left to expect */
211       datap += piece;    /* move read pointer forward */
212       length -= piece;   /* decrease space left in this round */
213 
214       if(0 == ch->datasize)
215         /* end of data this round, we now expect a trailing CRLF */
216         ch->state = CHUNK_POSTLF;
217       break;
218 
219     case CHUNK_POSTLF:
220       if(*datap == 0x0a) {
221         /* The last one before we go back to hex state and start all over. */
222         Curl_httpchunk_init(conn); /* sets state back to CHUNK_HEX */
223       }
224       else if(*datap != 0x0d)
225         return CHUNKE_BAD_CHUNK;
226       datap++;
227       length--;
228       break;
229 
230     case CHUNK_TRAILER:
231       if((*datap == 0x0d) || (*datap == 0x0a)) {
232         char *tr = Curl_dyn_ptr(&conn->trailer);
233         /* this is the end of a trailer, but if the trailer was zero bytes
234            there was no trailer and we move on */
235 
236         if(tr) {
237           size_t trlen;
238           result = Curl_dyn_add(&conn->trailer, (char *)"\x0d\x0a");
239           if(result)
240             return CHUNKE_OUT_OF_MEMORY;
241 
242           tr = Curl_dyn_ptr(&conn->trailer);
243           trlen = Curl_dyn_len(&conn->trailer);
244           /* Convert to host encoding before calling Curl_client_write */
245           result = Curl_convert_from_network(conn->data, tr, trlen);
246           if(result)
247             /* Curl_convert_from_network calls failf if unsuccessful */
248             /* Treat it as a bad chunk */
249             return CHUNKE_BAD_CHUNK;
250 
251           if(!data->set.http_te_skip) {
252             result = Curl_client_write(conn, CLIENTWRITE_HEADER, tr, trlen);
253             if(result) {
254               *extrap = result;
255               return CHUNKE_PASSTHRU_ERROR;
256             }
257           }
258           Curl_dyn_reset(&conn->trailer);
259           ch->state = CHUNK_TRAILER_CR;
260           if(*datap == 0x0a)
261             /* already on the LF */
262             break;
263         }
264         else {
265           /* no trailer, we're on the final CRLF pair */
266           ch->state = CHUNK_TRAILER_POSTCR;
267           break; /* don't advance the pointer */
268         }
269       }
270       else {
271         result = Curl_dyn_addn(&conn->trailer, datap, 1);
272         if(result)
273           return CHUNKE_OUT_OF_MEMORY;
274       }
275       datap++;
276       length--;
277       break;
278 
279     case CHUNK_TRAILER_CR:
280       if(*datap == 0x0a) {
281         ch->state = CHUNK_TRAILER_POSTCR;
282         datap++;
283         length--;
284       }
285       else
286         return CHUNKE_BAD_CHUNK;
287       break;
288 
289     case CHUNK_TRAILER_POSTCR:
290       /* We enter this state when a CR should arrive so we expect to
291          have to first pass a CR before we wait for LF */
292       if((*datap != 0x0d) && (*datap != 0x0a)) {
293         /* not a CR then it must be another header in the trailer */
294         ch->state = CHUNK_TRAILER;
295         break;
296       }
297       if(*datap == 0x0d) {
298         /* skip if CR */
299         datap++;
300         length--;
301       }
302       /* now wait for the final LF */
303       ch->state = CHUNK_STOP;
304       break;
305 
306     case CHUNK_STOP:
307       if(*datap == 0x0a) {
308         length--;
309 
310         /* Record the length of any data left in the end of the buffer
311            even if there's no more chunks to read */
312         ch->dataleft = curlx_sotouz(length);
313 
314         return CHUNKE_STOP; /* return stop */
315       }
316       else
317         return CHUNKE_BAD_CHUNK;
318     }
319   }
320   return CHUNKE_OK;
321 }
322 
Curl_chunked_strerror(CHUNKcode code)323 const char *Curl_chunked_strerror(CHUNKcode code)
324 {
325   switch(code) {
326   default:
327     return "OK";
328   case CHUNKE_TOO_LONG_HEX:
329     return "Too long hexadecimal number";
330   case CHUNKE_ILLEGAL_HEX:
331     return "Illegal or missing hexadecimal sequence";
332   case CHUNKE_BAD_CHUNK:
333     return "Malformed encoding found";
334   case CHUNKE_PASSTHRU_ERROR:
335     DEBUGASSERT(0); /* never used */
336     return "";
337   case CHUNKE_BAD_ENCODING:
338     return "Bad content-encoding found";
339   case CHUNKE_OUT_OF_MEMORY:
340     return "Out of memory";
341   }
342 }
343 
344 #endif /* CURL_DISABLE_HTTP */
345