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	Original line	Diff line number	Diff line
	@@ -6,6 +6,9 @@

	Changelog		Changelog

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

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

RELEASE-NOTES

+1 −0

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

	This release includes the following known bugs:		This release includes the following known bugs:

docs/KNOWN_BUGS

+0 −3

Original line number	Original line	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		to be kept alive, the function will return prematurely and will confuse the
	rest of the HTTP protocol code.		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.		45. libcurl built to support ipv6 uses getaddrinfo() to resolve host names.
	getaddrinfo() sorts the response list which effectively kills how libcurl		getaddrinfo() sorts the response list which effectively kills how libcurl
	deals with round-robin DNS entries. All details:		deals with round-robin DNS entries. All details:

lib/http.c

+120 −49

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

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

	if(keepon > TRUE) {		if(keepon > TRUE) {
	/* This means we are currently ignoring a response-body, so we		/* This means we are currently ignoring a response-body */
	simply count down our counter and make sure to break out of		if(cl) {
	the loop when we're done! */		/* 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;		cl -= gotbytes;
	if(cl<=0) {		if(cl<=0) {
	keepon = FALSE;		keepon = FALSE;
	break;		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		else
	for(i = 0; i < gotbytes; ptr++, i++) {		for(i = 0; i < gotbytes; ptr++, i++) {
	perline++; /* amount of bytes in this line so far */		perline++; /* amount of bytes in this line so far */
	@@ -1366,7 +1387,8 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
	if(data->set.include_header)		if(data->set.include_header)
	writetype \|= CLIENTWRITE_BODY;		writetype \|= CLIENTWRITE_BODY;

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

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

			if(cl) {

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

	if(cl<=0)		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;		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		else
	keepon = FALSE;		keepon = FALSE;
	break; /* breaks out of for-loop, not switch() */		break; /* breaks out of for-loop, not switch() */
	@@ -1415,6 +1478,13 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
	else if(Curl_compareheader(line_start,		else if(Curl_compareheader(line_start,
	"Connection:", "close"))		"Connection:", "close"))
	closeConnection = TRUE;		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,		else if(Curl_compareheader(line_start,
	"Proxy-Connection:", "close"))		"Proxy-Connection:", "close"))
	closeConnection = TRUE;		closeConnection = TRUE;
	@@ -1472,6 +1542,7 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
	data->state.authproxy.done = TRUE;		data->state.authproxy.done = TRUE;

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

lib/http_chunks.c

+39 −40

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

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


	default:		default:
	return CHUNKE_STATE_ERROR;		return CHUNKE_STATE_ERROR;
	}		}