Annotation of embedaddon/curl/lib/http_chunks.c, revision 1.1.1.1
1.1 misho 1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2019, 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: #ifdef CURL_DOES_CONVERSIONS
78: /* Check for an ASCII hex digit.
79: We avoid the use of ISXDIGIT to accommodate non-ASCII hosts. */
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:
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: }
97:
98: /*
99: * chunk_read() returns a OK for normal operations, or a positive return code
100: * for errors. STOP means this sequence of chunks is complete. The 'wrote'
101: * argument is set to tell the caller how many bytes we actually passed to the
102: * client (for byte-counting and whatever).
103: *
104: * The states and the state-machine is further explained in the header file.
105: *
106: * This function always uses ASCII hex values to accommodate non-ASCII hosts.
107: * For example, 0x0d and 0x0a are used instead of '\r' and '\n'.
108: */
109: CHUNKcode Curl_httpchunk_read(struct connectdata *conn,
110: char *datap,
111: ssize_t datalen,
112: ssize_t *wrotep,
113: CURLcode *extrap)
114: {
115: CURLcode result = CURLE_OK;
116: struct Curl_easy *data = conn->data;
117: struct Curl_chunker *ch = &conn->chunk;
118: struct SingleRequest *k = &data->req;
119: size_t piece;
120: curl_off_t length = (curl_off_t)datalen;
121: size_t *wrote = (size_t *)wrotep;
122:
123: *wrote = 0; /* nothing's written yet */
124:
125: /* the original data is written to the client, but we go on with the
126: chunk read process, to properly calculate the content length*/
127: if(data->set.http_te_skip && !k->ignorebody) {
128: result = Curl_client_write(conn, CLIENTWRITE_BODY, datap, datalen);
129: if(result) {
130: *extrap = result;
131: return CHUNKE_PASSTHRU_ERROR;
132: }
133: }
134:
135: while(length) {
136: switch(ch->state) {
137: case CHUNK_HEX:
138: if(Curl_isxdigit_ascii(*datap)) {
139: if(ch->hexindex < MAXNUM_SIZE) {
140: ch->hexbuffer[ch->hexindex] = *datap;
141: datap++;
142: length--;
143: ch->hexindex++;
144: }
145: else {
146: return CHUNKE_TOO_LONG_HEX; /* longer hex than we support */
147: }
148: }
149: else {
150: char *endptr;
151: if(0 == ch->hexindex)
152: /* This is illegal data, we received junk where we expected
153: a hexadecimal digit. */
154: return CHUNKE_ILLEGAL_HEX;
155:
156: /* length and datap are unmodified */
157: ch->hexbuffer[ch->hexindex] = 0;
158:
159: /* convert to host encoding before calling strtoul */
160: result = Curl_convert_from_network(conn->data, ch->hexbuffer,
161: ch->hexindex);
162: if(result) {
163: /* Curl_convert_from_network calls failf if unsuccessful */
164: /* Treat it as a bad hex character */
165: return CHUNKE_ILLEGAL_HEX;
166: }
167:
168: if(curlx_strtoofft(ch->hexbuffer, &endptr, 16, &ch->datasize))
169: return CHUNKE_ILLEGAL_HEX;
170: ch->state = CHUNK_LF; /* now wait for the CRLF */
171: }
172: break;
173:
174: case CHUNK_LF:
175: /* waiting for the LF after a chunk size */
176: if(*datap == 0x0a) {
177: /* we're now expecting data to come, unless size was zero! */
178: if(0 == ch->datasize) {
179: ch->state = CHUNK_TRAILER; /* now check for trailers */
180: conn->trlPos = 0;
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: /* this is the end of a trailer, but if the trailer was zero bytes
233: there was no trailer and we move on */
234:
235: if(conn->trlPos) {
236: /* we allocate trailer with 3 bytes extra room to fit this */
237: conn->trailer[conn->trlPos++] = 0x0d;
238: conn->trailer[conn->trlPos++] = 0x0a;
239: conn->trailer[conn->trlPos] = 0;
240:
241: /* Convert to host encoding before calling Curl_client_write */
242: result = Curl_convert_from_network(conn->data, conn->trailer,
243: conn->trlPos);
244: if(result)
245: /* Curl_convert_from_network calls failf if unsuccessful */
246: /* Treat it as a bad chunk */
247: return CHUNKE_BAD_CHUNK;
248:
249: if(!data->set.http_te_skip) {
250: result = Curl_client_write(conn, CLIENTWRITE_HEADER,
251: conn->trailer, conn->trlPos);
252: if(result) {
253: *extrap = result;
254: return CHUNKE_PASSTHRU_ERROR;
255: }
256: }
257: conn->trlPos = 0;
258: ch->state = CHUNK_TRAILER_CR;
259: if(*datap == 0x0a)
260: /* already on the LF */
261: break;
262: }
263: else {
264: /* no trailer, we're on the final CRLF pair */
265: ch->state = CHUNK_TRAILER_POSTCR;
266: break; /* don't advance the pointer */
267: }
268: }
269: else {
270: /* conn->trailer is assumed to be freed in url.c on a
271: connection basis */
272: if(conn->trlPos >= conn->trlMax) {
273: /* we always allocate three extra bytes, just because when the full
274: header has been received we append CRLF\0 */
275: char *ptr;
276: if(conn->trlMax) {
277: conn->trlMax *= 2;
278: ptr = realloc(conn->trailer, conn->trlMax + 3);
279: }
280: else {
281: conn->trlMax = 128;
282: ptr = malloc(conn->trlMax + 3);
283: }
284: if(!ptr)
285: return CHUNKE_OUT_OF_MEMORY;
286: conn->trailer = ptr;
287: }
288: conn->trailer[conn->trlPos++]=*datap;
289: }
290: datap++;
291: length--;
292: break;
293:
294: case CHUNK_TRAILER_CR:
295: if(*datap == 0x0a) {
296: ch->state = CHUNK_TRAILER_POSTCR;
297: datap++;
298: length--;
299: }
300: else
301: return CHUNKE_BAD_CHUNK;
302: break;
303:
304: case CHUNK_TRAILER_POSTCR:
305: /* We enter this state when a CR should arrive so we expect to
306: have to first pass a CR before we wait for LF */
307: if((*datap != 0x0d) && (*datap != 0x0a)) {
308: /* not a CR then it must be another header in the trailer */
309: ch->state = CHUNK_TRAILER;
310: break;
311: }
312: if(*datap == 0x0d) {
313: /* skip if CR */
314: datap++;
315: length--;
316: }
317: /* now wait for the final LF */
318: ch->state = CHUNK_STOP;
319: break;
320:
321: case CHUNK_STOP:
322: if(*datap == 0x0a) {
323: length--;
324:
325: /* Record the length of any data left in the end of the buffer
326: even if there's no more chunks to read */
327: ch->dataleft = curlx_sotouz(length);
328:
329: return CHUNKE_STOP; /* return stop */
330: }
331: else
332: return CHUNKE_BAD_CHUNK;
333: }
334: }
335: return CHUNKE_OK;
336: }
337:
338: const char *Curl_chunked_strerror(CHUNKcode code)
339: {
340: switch(code) {
341: default:
342: return "OK";
343: case CHUNKE_TOO_LONG_HEX:
344: return "Too long hexadecimal number";
345: case CHUNKE_ILLEGAL_HEX:
346: return "Illegal or missing hexadecimal sequence";
347: case CHUNKE_BAD_CHUNK:
348: return "Malformed encoding found";
349: case CHUNKE_PASSTHRU_ERROR:
350: DEBUGASSERT(0); /* never used */
351: return "";
352: case CHUNKE_BAD_ENCODING:
353: return "Bad content-encoding found";
354: case CHUNKE_OUT_OF_MEMORY:
355: return "Out of memory";
356: }
357: }
358:
359: #endif /* CURL_DISABLE_HTTP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http_chunks.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib