known bug #46: chunked-encoded CONNECT responses from a http proxy now works. (11936474) · Commits · CYBER - Cyber Security / TS 103 523 MSP / TLMSP / TLMSP curl

CHANGES

+3 −0

Original line number	Diff line number	Diff line
		@@ -6,6 +6,9 @@

		Changelog

		Daniel S (2 October 2007)
		- libcurl now handles chunked-encoded CONNECT responses

		Daniel S (1 October 2007)
		- Alex Fishman reported a curl_easy_escape() problem that was made the
		function do wrong on all input bytes that are >= 0x80 (decimal 128) due to a

RELEASE-NOTES

+1 −0

Original line number	Diff line number	Diff line
		@@ -29,6 +29,7 @@ This release includes the following bugfixes:
		before SIZE
		o re-used handle transfers with SFTP
		o curl_easy_escape() problem with byte values >= 128
		o handles chunked-encoded CONNECT responses

		This release includes the following known bugs:

docs/KNOWN_BUGS

+0 −3

Original line number	Diff line number	Diff line
		@@ -7,9 +7,6 @@ may have been fixed since this was written!
		to be kept alive, the function will return prematurely and will confuse the
		rest of the HTTP protocol code.

		46. If a CONNECT response is chunked-encoded, the function may return
		prematurely and will confuse the rest of the HTTP protocol code.

		45. libcurl built to support ipv6 uses getaddrinfo() to resolve host names.
		getaddrinfo() sorts the response list which effectively kills how libcurl
		deals with round-robin DNS entries. All details:

lib/http.c

+120 −49

Original line number	Diff line number	Diff line
		@@ -1143,6 +1143,7 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
		curl_socket_t tunnelsocket = conn->sock[sockindex];
		curl_off_t cl=0;
		bool closeConnection = FALSE;
		bool chunked_encoding = FALSE;
		long check;

		#define SELECT_OK 0
		@@ -1340,15 +1341,35 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
		nread += gotbytes;

		if(keepon > TRUE) {
		/* This means we are currently ignoring a response-body, so we
		simply count down our counter and make sure to break out of
		the loop when we're done! */
		/* This means we are currently ignoring a response-body */
		if(cl) {
		/* A Content-Length based body: simply count down the counter
		and make sure to break out of the loop when we're done! */
		cl -= gotbytes;
		if(cl<=0) {
		keepon = FALSE;
		break;
		}
		}
		else {
		/* chunked-encoded body, so we need to do the chunked dance
		properly to know when the end of the body is reached */
		CHUNKcode r;
		ssize_t tookcareof=0;

		/* now parse the chunked piece of data so that we can
		properly tell when the stream ends */
		r = Curl_httpchunk_read(conn, ptr, gotbytes, &tookcareof);
		if(r == CHUNKE_STOP) {
		/* we're done reading chunks! */
		infof(data, "chunk reading DONE\n");
		keepon = FALSE;
		}
		else
		infof(data, "Read %d bytes of chunk, continue\n",
		tookcareof);
		}
		}
		else
		for(i = 0; i < gotbytes; ptr++, i++) {
		perline++; /* amount of bytes in this line so far */
		@@ -1366,7 +1387,8 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
		if(data->set.include_header)
		writetype \|= CLIENTWRITE_BODY;

		result = Curl_client_write(conn, writetype, line_start, perline);
		result = Curl_client_write(conn, writetype, line_start,
		perline);
		if(result)
		return result;

		@@ -1377,20 +1399,61 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
		if(('\r' == line_start[0]) \|\|
		('\n' == line_start[0])) {
		/* end of response-headers from the proxy */
		if(cl && (407 == k->httpcode) &&
		!data->state.authproblem) {
		if((407 == k->httpcode) && !data->state.authproblem) {
		/* If we get a 407 response code with content length
		* when we have no auth problem, we must ignore the
		* whole response-body */
		when we have no auth problem, we must ignore the
		whole response-body */
		keepon = 2;

		if(cl) {

		infof(data, "Ignore %" FORMAT_OFF_T
		" bytes of response-body\n", cl);
		cl -= (gotbytes - i);/* remove the remaining chunk of
		what we already read */
		/* remove the remaining chunk of what we already
		read */
		cl -= (gotbytes - i);

		if(cl<=0)
		/* if the whole thing was already read, we are done! */
		/* if the whole thing was already read, we are done!
		*/
		keepon=FALSE;
		}
		else if(chunked_encoding) {
		CHUNKcode r;
		/* We set ignorebody true here since the chunked
		decoder function will acknowledge that. Pay
		attention so that this is cleared again when this
		function returns! */
		k->ignorebody = TRUE;
		infof(data, "%d bytes of chunk left\n", gotbytes-i);

		if(line_start[1] == '\n') {
		/* this can only be a LF if the letter at index 0
		was a CR */
		line_start++;
		i++;
		}

		/* now parse the chunked piece of data so that we can
		properly tell when the stream ends */
		r = Curl_httpchunk_read(conn, line_start+1,
		gotbytes -i, &gotbytes);
		if(r == CHUNKE_STOP) {
		/* we're done reading chunks! */
		infof(data, "chunk reading DONE\n");
		keepon = FALSE;
		}
		else
		infof(data, "Read %d bytes of chunk, continue\n",
		gotbytes);
		}
		else {
		/* without content-length or chunked encoding, we
		can't keep the connection alive since the close is
		the end signal so we bail out at once instead */
		keepon=FALSE;
		}
		}
		else
		keepon = FALSE;
		break; /* breaks out of for-loop, not switch() */
		@@ -1415,6 +1478,13 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
		else if(Curl_compareheader(line_start,
		"Connection:", "close"))
		closeConnection = TRUE;
		else if(Curl_compareheader(line_start,
		"Transfer-Encoding:", "chunked")) {
		infof(data, "CONNECT responded chunked\n");
		chunked_encoding = TRUE;
		/* init our chunky engine */
		Curl_httpchunk_init(conn);
		}
		else if(Curl_compareheader(line_start,
		"Proxy-Connection:", "close"))
		closeConnection = TRUE;
		@@ -1472,6 +1542,7 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
		data->state.authproxy.done = TRUE;

		infof (data, "Proxy replied OK to CONNECT request\n");
		k->ignorebody = FALSE; /* put it (back) to non-ignore state */
		return CURLE_OK;
		}

lib/http_chunks.c

+39 −40

Original line number	Diff line number	Diff line
		@@ -84,7 +84,7 @@

		void Curl_httpchunk_init(struct connectdata *conn)
		{
		struct Curl_chunker *chunk = &conn->data->reqdata.proto.http->chunk;
		struct Curl_chunker *chunk = &conn->chunk;
		chunk->hexindex=0; /* start at 0 */
		chunk->dataleft=0; /* no data left yet! */
		chunk->state = CHUNK_HEX; /* we get hex first! */
		@@ -108,7 +108,7 @@ CHUNKcode Curl_httpchunk_read(struct connectdata *conn,
		{
		CURLcode result=CURLE_OK;
		struct SessionHandle *data = conn->data;
		struct Curl_chunker *ch = &data->reqdata.proto.http->chunk;
		struct Curl_chunker *ch = &conn->chunk;
		struct Curl_transfer_keeper *k = &data->reqdata.keep;
		size_t piece;
		size_t length = (size_t)datalen;
		@@ -403,7 +403,6 @@ CHUNKcode Curl_httpchunk_read(struct connectdata *conn,
		return CHUNKE_BAD_CHUNK;
		}


		default:
		return CHUNKE_STATE_ERROR;
		}