/src/curl/lib/http_chunks.c

Source (jump to first uncovered line)
/***************************************************************************
 *                                  _   _ ____  _
 *  Project                     ___| | | |  _ \| |
 *                             / __| | | | |_) | |
 *                            | (__| |_| |  _ <| |___
 *                             \___|\___/|_| \_\_____|
 *
 * Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
 *
 * This software is licensed as described in the file COPYING, which
 * you should have received as part of this distribution. The terms
 * are also available at https://curl.se/docs/copyright.html.
 *
 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
 * copies of the Software, and permit persons to whom the Software is
 * furnished to do so, under the terms of the COPYING file.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 * SPDX-License-Identifier: curl
 *
 ***************************************************************************/

#include "curl_setup.h"

#ifndef CURL_DISABLE_HTTP

#include "urldata.h" /* it includes http_chunks.h */
#include "sendf.h"   /* for the client write stuff */
#include "dynbuf.h"
#include "content_encoding.h"
#include "http.h"
#include "strtoofft.h"
#include "warnless.h"

/* The last #include files should be: */
#include "curl_memory.h"
#include "memdebug.h"

/*
 * Chunk format (simplified):
 *
 * <HEX SIZE>[ chunk extension ] CRLF
 * <DATA> CRLF
 *
 * Highlights from RFC2616 section 3.6 say:

   The chunked encoding modifies the body of a message in order to
   transfer it as a series of chunks, each with its own size indicator,
   followed by an OPTIONAL trailer containing entity-header fields. This
   allows dynamically produced content to be transferred along with the
   information necessary for the recipient to verify that it has
   received the full message.

       Chunked-Body   = *chunk
                        last-chunk
                        trailer
                        CRLF

       chunk          = chunk-size [ chunk-extension ] CRLF
                        chunk-data CRLF
       chunk-size     = 1*HEX
       last-chunk     = 1*("0") [ chunk-extension ] CRLF

       chunk-extension= *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
       chunk-ext-name = token
       chunk-ext-val  = token | quoted-string
       chunk-data     = chunk-size(OCTET)
       trailer        = *(entity-header CRLF)

   The chunk-size field is a string of hex digits indicating the size of
   the chunk. The chunked encoding is ended by any chunk whose size is
   zero, followed by the trailer, which is terminated by an empty line.

 */

#define isxdigit_ascii(x) Curl_isxdigit(x)

void Curl_httpchunk_init(struct Curl_easy *data)
{
  struct connectdata *conn = data->conn;
  struct Curl_chunker *chunk = &conn->chunk;
  chunk->hexindex = 0;      /* start at 0 */
  chunk->state = CHUNK_HEX; /* we get hex first! */
  Curl_dyn_init(&conn->trailer, DYN_H1_TRAILER);
}

/*
 * chunk_read() returns a OK for normal operations, or a positive return code
 * for errors. STOP means this sequence of chunks is complete.  The 'wrote'
 * argument is set to tell the caller how many bytes we actually passed to the
 * client (for byte-counting and whatever).
 *
 * The states and the state-machine is further explained in the header file.
 *
 * This function always uses ASCII hex values to accommodate non-ASCII hosts.
 * For example, 0x0d and 0x0a are used instead of '\r' and '\n'.
 */
CHUNKcode Curl_httpchunk_read(struct Curl_easy *data,
                              char *datap,
                              ssize_t datalen,
                              ssize_t *wrote,
                              CURLcode *extrap)
{
  CURLcode result = CURLE_OK;
  struct connectdata *conn = data->conn;
  struct Curl_chunker *ch = &conn->chunk;
  struct SingleRequest *k = &data->req;
  size_t piece;
  curl_off_t length = (curl_off_t)datalen;

  *wrote = 0; /* nothing's written yet */

  /* the original data is written to the client, but we go on with the
     chunk read process, to properly calculate the content length*/
  if(data->set.http_te_skip && !k->ignorebody) {
    result = Curl_client_write(data, CLIENTWRITE_BODY, datap, datalen);
    if(result) {
      *extrap = result;
      return CHUNKE_PASSTHRU_ERROR;
    }
  }

  while(length) {
    switch(ch->state) {
    case CHUNK_HEX:
      if(ISXDIGIT(*datap)) {
        if(ch->hexindex < CHUNK_MAXNUM_LEN) {
          ch->hexbuffer[ch->hexindex] = *datap;
          datap++;
          length--;
          ch->hexindex++;
        }
        else {
          return CHUNKE_TOO_LONG_HEX; /* longer hex than we support */
        }
      }
      else {
        char *endptr;
        if(0 == ch->hexindex)
          /* This is illegal data, we received junk where we expected
             a hexadecimal digit. */
          return CHUNKE_ILLEGAL_HEX;

        /* length and datap are unmodified */
        ch->hexbuffer[ch->hexindex] = 0;

        if(curlx_strtoofft(ch->hexbuffer, &endptr, 16, &ch->datasize))
          return CHUNKE_ILLEGAL_HEX;
        ch->state = CHUNK_LF; /* now wait for the CRLF */
      }
      break;

    case CHUNK_LF:
      /* waiting for the LF after a chunk size */
      if(*datap == 0x0a) {
        /* we're now expecting data to come, unless size was zero! */
        if(0 == ch->datasize) {
          ch->state = CHUNK_TRAILER; /* now check for trailers */
        }
        else
          ch->state = CHUNK_DATA;
      }

      datap++;
      length--;
      break;

    case CHUNK_DATA:
      /* We expect 'datasize' of data. We have 'length' right now, it can be
         more or less than 'datasize'. Get the smallest piece.
      */
      piece = curlx_sotouz((ch->datasize >= length)?length:ch->datasize);

      /* Write the data portion available */
      if(!data->set.http_te_skip && !k->ignorebody) {
        if(!data->set.http_ce_skip && k->writer_stack)
          result = Curl_unencode_write(data, k->writer_stack, datap, piece);
        else
          result = Curl_client_write(data, CLIENTWRITE_BODY, datap, piece);

        if(result) {
          *extrap = result;
          return CHUNKE_PASSTHRU_ERROR;
        }
      }

      *wrote += piece;
      ch->datasize -= piece; /* decrease amount left to expect */
      datap += piece;    /* move read pointer forward */
      length -= piece;   /* decrease space left in this round */

      if(0 == ch->datasize)
        /* end of data this round, we now expect a trailing CRLF */
        ch->state = CHUNK_POSTLF;
      break;

    case CHUNK_POSTLF:
      if(*datap == 0x0a) {
        /* The last one before we go back to hex state and start all over. */
        Curl_httpchunk_init(data); /* sets state back to CHUNK_HEX */
      }
      else if(*datap != 0x0d)
        return CHUNKE_BAD_CHUNK;
      datap++;
      length--;
      break;

    case CHUNK_TRAILER:
      if((*datap == 0x0d) || (*datap == 0x0a)) {
        char *tr = Curl_dyn_ptr(&conn->trailer);
        /* this is the end of a trailer, but if the trailer was zero bytes
           there was no trailer and we move on */

        if(tr) {
          size_t trlen;
          result = Curl_dyn_addn(&conn->trailer, (char *)STRCONST("\x0d\x0a"));
          if(result)
            return CHUNKE_OUT_OF_MEMORY;

          tr = Curl_dyn_ptr(&conn->trailer);
          trlen = Curl_dyn_len(&conn->trailer);
          if(!data->set.http_te_skip) {
            result = Curl_client_write(data,
                                       CLIENTWRITE_HEADER|CLIENTWRITE_TRAILER,
                                       tr, trlen);
            if(result) {
              *extrap = result;
              return CHUNKE_PASSTHRU_ERROR;
            }
          }
          Curl_dyn_reset(&conn->trailer);
          ch->state = CHUNK_TRAILER_CR;
          if(*datap == 0x0a)
            /* already on the LF */
            break;
        }
        else {
          /* no trailer, we're on the final CRLF pair */
          ch->state = CHUNK_TRAILER_POSTCR;
          break; /* don't advance the pointer */
        }
      }
      else {
        result = Curl_dyn_addn(&conn->trailer, datap, 1);
        if(result)
          return CHUNKE_OUT_OF_MEMORY;
      }
      datap++;
      length--;
      break;

    case CHUNK_TRAILER_CR:
      if(*datap == 0x0a) {
        ch->state = CHUNK_TRAILER_POSTCR;
        datap++;
        length--;
      }
      else
        return CHUNKE_BAD_CHUNK;
      break;

    case CHUNK_TRAILER_POSTCR:
      /* We enter this state when a CR should arrive so we expect to
         have to first pass a CR before we wait for LF */
      if((*datap != 0x0d) && (*datap != 0x0a)) {
        /* not a CR then it must be another header in the trailer */
        ch->state = CHUNK_TRAILER;
        break;
      }
      if(*datap == 0x0d) {
        /* skip if CR */
        datap++;
        length--;
      }
      /* now wait for the final LF */
      ch->state = CHUNK_STOP;
      break;

    case CHUNK_STOP:
      if(*datap == 0x0a) {
        length--;

        /* Record the length of any data left in the end of the buffer
           even if there's no more chunks to read */
        ch->datasize = curlx_sotouz(length);

        return CHUNKE_STOP; /* return stop */
      }
      else
        return CHUNKE_BAD_CHUNK;
    }
  }
  return CHUNKE_OK;
}

const char *Curl_chunked_strerror(CHUNKcode code)
{
  switch(code) {
  default:
    return "OK";
  case CHUNKE_TOO_LONG_HEX:
    return "Too long hexadecimal number";
  case CHUNKE_ILLEGAL_HEX:
    return "Illegal or missing hexadecimal sequence";
  case CHUNKE_BAD_CHUNK:
    return "Malformed encoding found";
  case CHUNKE_PASSTHRU_ERROR:
    DEBUGASSERT(0); /* never used */
    return "";
  case CHUNKE_BAD_ENCODING:
    return "Bad content-encoding found";
  case CHUNKE_OUT_OF_MEMORY:
    return "Out of memory";
  }
}

#endif /* CURL_DISABLE_HTTP */

Coverage Report

Created: 2022-10-16 06:45

Line	Count	Source (jump to first uncovered line)
1		/***************************************************************************
2		* _ _ ____ _
3		* Project ___\| \| \| \| _ \\| \|
4		* / __\| \| \| \| \|_) \| \|
5		* \| (__\| \|_\| \| _ <\| \|___
6		* \___\|\___/\|_\| \_\_____\|
7		*
8		* Copyright (C) 1998 - 2022, 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.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		* SPDX-License-Identifier: curl
22		*
23		***************************************************************************/
24
25		#include "curl_setup.h"
26
27		#ifndef CURL_DISABLE_HTTP
28
29		#include "urldata.h" /* it includes http_chunks.h */
30		#include "sendf.h" /* for the client write stuff */
31		#include "dynbuf.h"
32		#include "content_encoding.h"
33		#include "http.h"
34		#include "strtoofft.h"
35		#include "warnless.h"
36
37		/* The last #include files should be: */
38		#include "curl_memory.h"
39		#include "memdebug.h"
40
41		/*
42		* Chunk format (simplified):
43		*
44		* <HEX SIZE>[ chunk extension ] CRLF
45		* <DATA> CRLF
46		*
47		* Highlights from RFC2616 section 3.6 say:
48
49		The chunked encoding modifies the body of a message in order to
50		transfer it as a series of chunks, each with its own size indicator,
51		followed by an OPTIONAL trailer containing entity-header fields. This
52		allows dynamically produced content to be transferred along with the
53		information necessary for the recipient to verify that it has
54		received the full message.
55
56		Chunked-Body = *chunk
57		last-chunk
58		trailer
59		CRLF
60
61		chunk = chunk-size [ chunk-extension ] CRLF
62		chunk-data CRLF
63		chunk-size = 1*HEX
64		last-chunk = 1*("0") [ chunk-extension ] CRLF
65
66		chunk-extension= *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
67		chunk-ext-name = token
68		chunk-ext-val = token \| quoted-string
69		chunk-data = chunk-size(OCTET)
70		trailer = *(entity-header CRLF)
71
72		The chunk-size field is a string of hex digits indicating the size of
73		the chunk. The chunked encoding is ended by any chunk whose size is
74		zero, followed by the trailer, which is terminated by an empty line.
75
76		*/
77
78		#define isxdigit_ascii(x) Curl_isxdigit(x)
79
80		void Curl_httpchunk_init(struct Curl_easy *data)
81	2.84k	{
82	2.84k	struct connectdata *conn = data->conn;
83	2.84k	struct Curl_chunker *chunk = &conn->chunk;
84	2.84k	chunk->hexindex = 0; /* start at 0 */
85	2.84k	chunk->state = CHUNK_HEX; /* we get hex first! */
86	2.84k	Curl_dyn_init(&conn->trailer, DYN_H1_TRAILER);
87	2.84k	}
88
89		/*
90		* chunk_read() returns a OK for normal operations, or a positive return code
91		* for errors. STOP means this sequence of chunks is complete. The 'wrote'
92		* argument is set to tell the caller how many bytes we actually passed to the
93		* client (for byte-counting and whatever).
94		*
95		* The states and the state-machine is further explained in the header file.
96		*
97		* This function always uses ASCII hex values to accommodate non-ASCII hosts.
98		* For example, 0x0d and 0x0a are used instead of '\r' and '\n'.
99		*/
100		CHUNKcode Curl_httpchunk_read(struct Curl_easy *data,
101		char *datap,
102		ssize_t datalen,
103		ssize_t *wrote,
104		CURLcode *extrap)
105	529	{
106	529	CURLcode result = CURLE_OK;
107	529	struct connectdata *conn = data->conn;
108	529	struct Curl_chunker *ch = &conn->chunk;
109	529	struct SingleRequest *k = &data->req;
110	529	size_t piece;
111	529	curl_off_t length = (curl_off_t)datalen;
112
113	529	wrote = 0; / nothing's written yet */
114
115		/* the original data is written to the client, but we go on with the
116		chunk read process, to properly calculate the content length*/
117	529	if(data->set.http_te_skip && !k->ignorebody) {
118	0	result = Curl_client_write(data, CLIENTWRITE_BODY, datap, datalen);
119	0	if(result) {
120	0	*extrap = result;
121	0	return CHUNKE_PASSTHRU_ERROR;
122	0	}
123	0	}
124
125	216k	while(length) {
126	216k	switch(ch->state) {
127	5.49k	case CHUNK_HEX:
128	5.49k	if(ISXDIGIT(*datap)) {
129	3.79k	if(ch->hexindex < CHUNK_MAXNUM_LEN) {
130	3.78k	ch->hexbuffer[ch->hexindex] = *datap;
131	3.78k	datap++;
132	3.78k	length--;
133	3.78k	ch->hexindex++;
134	3.78k	}
135	4	else {
136	4	return CHUNKE_TOO_LONG_HEX; /* longer hex than we support */
137	4	}
138	3.79k	}
139	1.70k	else {
140	1.70k	char *endptr;
141	1.70k	if(0 == ch->hexindex)
142		/* This is illegal data, we received junk where we expected
143		a hexadecimal digit. */
144	16	return CHUNKE_ILLEGAL_HEX;
145
146		/* length and datap are unmodified */
147	1.69k	ch->hexbuffer[ch->hexindex] = 0;
148
149	1.69k	if(curlx_strtoofft(ch->hexbuffer, &endptr, 16, &ch->datasize))
150	3	return CHUNKE_ILLEGAL_HEX;
151	1.68k	ch->state = CHUNK_LF; /* now wait for the CRLF */
152	1.68k	}
153	5.47k	break;
154
155	14.0k	case CHUNK_LF:
156		/* waiting for the LF after a chunk size */
157	14.0k	if(*datap == 0x0a) {
158		/* we're now expecting data to come, unless size was zero! */
159	1.64k	if(0 == ch->datasize) {
160	101	ch->state = CHUNK_TRAILER; /* now check for trailers */
161	101	}
162	1.54k	else
163	1.54k	ch->state = CHUNK_DATA;
164	1.64k	}
165
166	14.0k	datap++;
167	14.0k	length--;
168	14.0k	break;
169
170	1.56k	case CHUNK_DATA:
171		/* We expect 'datasize' of data. We have 'length' right now, it can be
172		more or less than 'datasize'. Get the smallest piece.
173		*/
174	1.56k	piece = curlx_sotouz((ch->datasize >= length)?length:ch->datasize);
175
176		/* Write the data portion available */
177	1.56k	if(!data->set.http_te_skip && !k->ignorebody) {
178	1.47k	if(!data->set.http_ce_skip && k->writer_stack)
179	510	result = Curl_unencode_write(data, k->writer_stack, datap, piece);
180	964	else
181	964	result = Curl_client_write(data, CLIENTWRITE_BODY, datap, piece);
182
183	1.47k	if(result) {
184	7	*extrap = result;
185	7	return CHUNKE_PASSTHRU_ERROR;
186	7	}
187	1.47k	}
188
189	1.55k	*wrote += piece;
190	1.55k	ch->datasize -= piece; /* decrease amount left to expect */
191	1.55k	datap += piece; /* move read pointer forward */
192	1.55k	length -= piece; /* decrease space left in this round */
193
194	1.55k	if(0 == ch->datasize)
195		/* end of data this round, we now expect a trailing CRLF */
196	1.31k	ch->state = CHUNK_POSTLF;
197	1.55k	break;
198
199	2.09k	case CHUNK_POSTLF:
200	2.09k	if(*datap == 0x0a) {
201		/* The last one before we go back to hex state and start all over. */
202	1.27k	Curl_httpchunk_init(data); /* sets state back to CHUNK_HEX */
203	1.27k	}
204	826	else if(*datap != 0x0d)
205	38	return CHUNKE_BAD_CHUNK;
206	2.05k	datap++;
207	2.05k	length--;
208	2.05k	break;
209
210	186k	case CHUNK_TRAILER:
211	186k	if((datap == 0x0d) \|\| (datap == 0x0a)) {
212	3.49k	char *tr = Curl_dyn_ptr(&conn->trailer);
213		/* this is the end of a trailer, but if the trailer was zero bytes
214		there was no trailer and we move on */
215
216	3.49k	if(tr) {
217	3.48k	size_t trlen;
218	3.48k	result = Curl_dyn_addn(&conn->trailer, (char *)STRCONST("\x0d\x0a"));
219	3.48k	if(result)
220	1	return CHUNKE_OUT_OF_MEMORY;
221
222	3.48k	tr = Curl_dyn_ptr(&conn->trailer);
223	3.48k	trlen = Curl_dyn_len(&conn->trailer);
224	3.48k	if(!data->set.http_te_skip) {
225	3.48k	result = Curl_client_write(data,
226	3.48k	CLIENTWRITE_HEADER\|CLIENTWRITE_TRAILER,
227	3.48k	tr, trlen);
228	3.48k	if(result) {
229	8	*extrap = result;
230	8	return CHUNKE_PASSTHRU_ERROR;
231	8	}
232	3.48k	}
233	3.47k	Curl_dyn_reset(&conn->trailer);
234	3.47k	ch->state = CHUNK_TRAILER_CR;
235	3.47k	if(*datap == 0x0a)
236		/* already on the LF */
237	3.15k	break;
238	3.47k	}
239	13	else {
240		/* no trailer, we're on the final CRLF pair */
241	13	ch->state = CHUNK_TRAILER_POSTCR;
242	13	break; /* don't advance the pointer */
243	13	}
244	3.49k	}
245	182k	else {
246	182k	result = Curl_dyn_addn(&conn->trailer, datap, 1);
247	182k	if(result)
248	1	return CHUNKE_OUT_OF_MEMORY;
249	182k	}
250	183k	datap++;
251	183k	length--;
252	183k	break;
253
254	3.47k	case CHUNK_TRAILER_CR:
255	3.47k	if(*datap == 0x0a) {
256	3.46k	ch->state = CHUNK_TRAILER_POSTCR;
257	3.46k	datap++;
258	3.46k	length--;
259	3.46k	}
260	12	else
261	12	return CHUNKE_BAD_CHUNK;
262	3.46k	break;
263
264	3.47k	case CHUNK_TRAILER_POSTCR:
265		/* We enter this state when a CR should arrive so we expect to
266		have to first pass a CR before we wait for LF */
267	3.47k	if((datap != 0x0d) && (datap != 0x0a)) {
268		/* not a CR then it must be another header in the trailer */
269	3.43k	ch->state = CHUNK_TRAILER;
270	3.43k	break;
271	3.43k	}
272	37	if(*datap == 0x0d) {
273		/* skip if CR */
274	2	datap++;
275	2	length--;
276	2	}
277		/* now wait for the final LF */
278	37	ch->state = CHUNK_STOP;
279	37	break;
280
281	58	case CHUNK_STOP:
282	58	if(*datap == 0x0a) {
283	52	length--;
284
285		/* Record the length of any data left in the end of the buffer
286		even if there's no more chunks to read */
287	52	ch->datasize = curlx_sotouz(length);
288
289	52	return CHUNKE_STOP; /* return stop */
290	52	}
291	6	else
292	6	return CHUNKE_BAD_CHUNK;
293	216k	}
294	216k	}
295	381	return CHUNKE_OK;
296	529	}
297
298		const char *Curl_chunked_strerror(CHUNKcode code)
299	81	{
300	81	switch(code) {
301	0	default:
302	0	return "OK";
303	4	case CHUNKE_TOO_LONG_HEX:
304	4	return "Too long hexadecimal number";
305	19	case CHUNKE_ILLEGAL_HEX:
306	19	return "Illegal or missing hexadecimal sequence";
307	56	case CHUNKE_BAD_CHUNK:
308	56	return "Malformed encoding found";
309	0	case CHUNKE_PASSTHRU_ERROR:
310	0	DEBUGASSERT(0); /* never used */
311	0	return "";
312	0	case CHUNKE_BAD_ENCODING:
313	0	return "Bad content-encoding found";
314	2	case CHUNKE_OUT_OF_MEMORY:
315	2	return "Out of memory";
316	81	}
317	81	}
318
319		#endif /* CURL_DISABLE_HTTP */