bugfix 760544

Author: hohong

Release/include/cpprest/http_linux_server.h

@@ -100,6 +100,7 @@ class connection
     template <typename ReadHandler>
     void async_read_until_buffersize(size_t size, ReadHandler handler);
     void async_process_response(http_response response);
+	void cancel_sending_response_with_error(http_response response, std::exception_ptr);
     void handle_headers_written(http_response response, const boost::system::error_code& ec);
     void handle_write_large_response(http_response response, const boost::system::error_code& ec);
     void handle_write_chunked_response(http_response response, const boost::system::error_code& ec);

Release/src/http/listener/http_linux_server.cpp

@@ -114,7 +114,7 @@ void connection::handle_http_line(const boost::system::error_code& ec)
         }
         else
         {
-            m_request.reply(status_codes::InternalError);
+            m_request.reply(status_codes::BadRequest);
             do_response();
         }
     }
@@ -252,7 +252,13 @@ void connection::handle_chunked_body(const boost::system::error_code& ec, int to
     if (!ec)
     {
         auto writebuf = m_request._get_impl()->outstream().streambuf();
-        writebuf.putn(buffer_cast<const uint8_t *>(m_request_buf.data()), toWrite).then([=](size_t) {
+        writebuf.putn(buffer_cast<const uint8_t *>(m_request_buf.data()), toWrite).then([=](pplx::task<size_t> writeChunkTask) {
+			try {
+				writeChunkTask.get();
+			} catch (...) {
+				m_request._reply_if_not_already(status_codes::InternalError);
+				return;
+			}
             m_request_buf.consume(2 + toWrite);
 
             boost::asio::async_read_until(*m_socket, m_request_buf, CRLF, 
@@ -275,7 +281,14 @@ void connection::handle_body(const boost::system::error_code& ec)
     else if (m_read < m_read_size)  // there is more to read
     {
         auto writebuf = m_request._get_impl()->outstream().streambuf();
-        writebuf.putn(boost::asio::buffer_cast<const uint8_t*>(m_request_buf.data()), std::min(m_request_buf.size(), m_read_size - m_read)).then([=](size_t writtenSize) {
+        writebuf.putn(boost::asio::buffer_cast<const uint8_t*>(m_request_buf.data()), std::min(m_request_buf.size(), m_read_size - m_read)).then([=](pplx::task<size_t> writtenSizeTask) {
+			size_t writtenSize = 0;
+			try {
+				writtenSize = writtenSizeTask.get();
+			} catch (...) {
+				m_request._reply_if_not_already(status_codes::InternalError);
+				return;
+			}
             m_read += writtenSize;
             m_request_buf.consume(writtenSize);
             async_read_until_buffersize(std::min(ChunkSize, m_read_size - m_read), boost::bind(&connection::handle_body, this, placeholders::error));
@@ -457,16 +470,33 @@ void connection::async_process_response(http_response response)
     boost::asio::async_write(*m_socket, m_response_buf, boost::bind(&connection::handle_headers_written, this, response, placeholders::error));
 }
 
+void connection::cancel_sending_response_with_error(http_response response, std::exception_ptr eptr)
+{
+	auto * context = static_cast<linux_request_context*>(response._get_server_context());
+	context->m_response_completed.set_exception(eptr);
+	// always terminate the connection since error happens
+	finish_request_response();
+}
+
 
 void connection::handle_write_chunked_response(http_response response, const boost::system::error_code& ec)
 {
     if (ec)
         return handle_response_written(response, ec);
 
     auto readbuf = response._get_impl()->instream().streambuf();
+	if (readbuf.is_eof())
+		return cancel_sending_response_with_error(response, std::make_exception_ptr(http_exception("Response stream close early!")));	
     auto membuf = m_response_buf.prepare(ChunkSize + http::details::chunked_encoding::additional_encoding_space);
 
-    readbuf.getn(buffer_cast<uint8_t *>(membuf) + http::details::chunked_encoding::data_offset, ChunkSize).then([=](size_t actualSize) {
+    readbuf.getn(buffer_cast<uint8_t *>(membuf) + http::details::chunked_encoding::data_offset, ChunkSize).then([=](pplx::task<size_t> actualSizeTask) {
+		
+		size_t actualSize = 0;
+		try {
+			actualSize = actualSizeTask.get();
+		} catch (...) {
+			return cancel_sending_response_with_error(response, std::current_exception());
+		}
         size_t offset = http::details::chunked_encoding::add_chunked_delimiters(buffer_cast<uint8_t *>(membuf), ChunkSize+http::details::chunked_encoding::additional_encoding_space, actualSize);
         m_response_buf.commit(actualSize + http::details::chunked_encoding::additional_encoding_space);
         m_response_buf.consume(offset);
@@ -482,8 +512,16 @@ void connection::handle_write_large_response(http_response response, const boost
         return handle_response_written(response, ec);
 
     auto readbuf = response._get_impl()->instream().streambuf();
+	if (readbuf.is_eof())
+		return cancel_sending_response_with_error(response, std::make_exception_ptr(http_exception("Response stream close early!")));
     size_t readBytes = std::min(ChunkSize, m_write_size - m_write);
-    readbuf.getn(buffer_cast<uint8_t *>(m_response_buf.prepare(readBytes)), readBytes).then([=](size_t actualSize) {
+    readbuf.getn(buffer_cast<uint8_t *>(m_response_buf.prepare(readBytes)), readBytes).then([=](pplx::task<size_t> actualSizeTask) {
+		size_t actualSize = 0;
+		try {
+			actualSize = actualSizeTask.get();
+		} catch (...) {
+			return cancel_sending_response_with_error(response, std::current_exception());
+		}
         m_write += actualSize;
         m_response_buf.commit(actualSize);
         boost::asio::async_write(*m_socket, m_response_buf, boost::bind(&connection::handle_write_large_response, this, response, placeholders::error));
@@ -494,9 +532,7 @@ void connection::handle_headers_written(http_response response, const boost::sys
 {
     if (ec)
     {
-        auto * context = static_cast<linux_request_context*>(response._get_server_context());
-        context->m_response_completed.set_exception(std::runtime_error("error writing headers"));
-        finish_request_response();
+		return cancel_sending_response_with_error(response, std::make_exception_ptr(http_exception("error writing headers")));
     }
     else
     {
@@ -512,9 +548,7 @@ void connection::handle_response_written(http_response response, const boost::sy
     auto * context = static_cast<linux_request_context*>(response._get_server_context());
     if (ec)
     {
-        //printf("-> boost::system::error_code %d in handle_response_written\n", ec.value());
-        context->m_response_completed.set_exception(std::runtime_error("error writing response"));
-        finish_request_response();
+        return cancel_sending_response_with_error(response, std::make_exception_ptr(http_exception("error writing response")));
     }
     else
     {
@@ -532,7 +566,6 @@ void connection::handle_response_written(http_response response, const boost::sy
 
 void connection::finish_request_response()
 {
-	//usleep(100000);
     // kill the connection
     {
         pplx::scoped_lock<pplx::extensibility::recursive_lock_t> lock(m_p_parent->m_connections_lock);
@@ -548,7 +581,6 @@ void connection::finish_request_response()
 
 void hostport_listener::stop()
 {
-
     // halt existing connections
     {
         pplx::scoped_lock<pplx::extensibility::recursive_lock_t> lock(m_connections_lock);

Release/tests/Functional/http/listener/connections_and_errors.cpp

@@ -194,7 +194,7 @@ static void close_stream_early_with_length_impl(const uri &u, bool useException)
     listener.close().wait();
 }
 
-TEST_FIXTURE(uri_address, close_stream_early_with_length, "Ignore:Linux", "760544")
+TEST_FIXTURE(uri_address, close_stream_early_with_length)
 {
     close_stream_early_with_length_impl(m_uri, true);
     close_stream_early_with_length_impl(m_uri, false);