webservd/request.cc - aosp/platform/system/webservd - Git at Google

 // Copyright 2015 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "webservd/request.h"

 #include <microhttpd.h>

 #include <base/bind.h>
 #include <base/files/file.h>
 #include <base/guid.h>
 #include <brillo/http/http_request.h>
 #include <brillo/http/http_utils.h>
 #include <brillo/mime_utils.h>
 #include <brillo/streams/file_stream.h>
 #include <brillo/strings/string_utils.h>
 #include "webservd/log_manager.h"
 #include "webservd/protocol_handler.h"
 #include "webservd/request_handler_interface.h"
 #include "webservd/server_interface.h"
 #include "webservd/temp_file_manager.h"

 namespace webservd {

 // Helper class to provide static callback methods to microhttpd library,
 // with the ability to access private methods of Request class.
 class RequestHelper {
  public:
   static int PostDataIterator(void* cls,
                               MHD_ValueKind /* kind */,
                               const char* key,
                               const char* filename,
                               const char* content_type,
                               const char* transfer_encoding,
                               const char* data,
                               uint64_t off,
                               size_t size) {
     auto self = reinterpret_cast<Request*>(cls);
     return self->ProcessPostData(key, filename, content_type, transfer_encoding,
                                  data, off, size) ? MHD_YES : MHD_NO;
   }

   static int ValueCallback(void* cls,
                            MHD_ValueKind kind,
                            const char* key,
                            const char* value) {
     auto self = reinterpret_cast<Request*>(cls);
     std::string data;
     if (value)
       data = value;
     if (kind == MHD_HEADER_KIND) {
       self->headers_.emplace_back(brillo::http::GetCanonicalHeaderName(key),
                                   data);
     } else if (kind == MHD_COOKIE_KIND) {
       // TODO(avakulenko): add support for cookies...
     } else if (kind == MHD_POSTDATA_KIND) {
       self->post_data_.emplace_back(key, data);
     } else if (kind == MHD_GET_ARGUMENT_KIND) {
       self->get_data_.emplace_back(key, data);
     }
     return MHD_YES;
   }
 };

 FileInfo::FileInfo(const std::string& in_field_name,
                    const std::string& in_file_name,
                    const std::string& in_content_type,
                    const std::string& in_transfer_encoding)
     : field_name(in_field_name),
       file_name(in_file_name),
       content_type(in_content_type),
       transfer_encoding(in_transfer_encoding) {
 }

 Request::Request(
     const std::string& request_handler_id,
     const std::string& url,
     const std::string& method,
     const std::string& version,
     MHD_Connection* connection,
     ProtocolHandler* protocol_handler)
     : id_{base::GenerateGUID()},
       request_handler_id_{request_handler_id},
       url_{url},
       method_{method},
       version_{version},
       connection_{connection},
       protocol_handler_{protocol_handler} {
   // Here we create the data pipe used to transfer the request body from the
   // web server to the remote request handler.
   int pipe_fds[2] = {-1, -1};
   CHECK_EQ(0, pipe(pipe_fds));
   request_data_pipe_out_ = base::File{pipe_fds[0]};
   CHECK(request_data_pipe_out_.IsValid());
   request_data_stream_ = brillo::FileStream::FromFileDescriptor(
       pipe_fds[1], true, nullptr);
   CHECK(request_data_stream_);

   // POST request processor.
   post_processor_ = MHD_create_post_processor(
       connection, 1024, &RequestHelper::PostDataIterator, this);
 }

 Request::~Request() {
   if (post_processor_)
     MHD_destroy_post_processor(post_processor_);
   GetTempFileManager()->DeleteRequestTempFiles(id_);
   protocol_handler_->RemoveRequest(this);
 }

 base::File Request::GetFileData(int file_id) {
   base::File file;
   if (file_id >= 0 && static_cast<size_t>(file_id) < file_info_.size()) {
     file.Initialize(file_info_[file_id]->temp_file_name,
                     base::File::FLAG_OPEN | base::File::FLAG_READ);
   }
   return file;
 }

 base::File Request::Complete(
     int32_t status_code,
     const std::vector<std::tuple<std::string, std::string>>& headers,
     int64_t in_data_size) {
   base::File file;
   if (response_data_started_)
     return file;

   response_status_code_ = status_code;
   response_headers_.reserve(headers.size());
   for (const auto& tuple : headers) {
     response_headers_.emplace_back(std::get<0>(tuple), std::get<1>(tuple));
   }

   // Create the pipe for response data.
   int pipe_fds[2] = {-1, -1};
   CHECK_EQ(0, pipe(pipe_fds));
   file = base::File{pipe_fds[1]};
   CHECK(file.IsValid());
   response_data_stream_ = brillo::FileStream::FromFileDescriptor(
       pipe_fds[0], true, nullptr);
   CHECK(response_data_stream_);

   response_data_size_ = in_data_size;
   response_data_started_ = true;
   const MHD_ConnectionInfo* info =
       MHD_get_connection_info(connection_, MHD_CONNECTION_INFO_CLIENT_ADDRESS);

   const sockaddr* client_addr = (info ? info->client_addr : nullptr);
   LogManager::OnRequestCompleted(base::Time::Now(), client_addr, method_, url_,
                                  version_, status_code, in_data_size);
   protocol_handler_->ScheduleWork();
   return file;
 }

 bool Request::Complete(
     int32_t status_code,
     const std::vector<std::tuple<std::string, std::string>>& /* headers */,
     const std::string& mime_type,
     const std::string& data) {
   std::vector<std::tuple<std::string, std::string>> headers_copy;
   headers_copy.emplace_back(brillo::http::response_header::kContentType,
                             mime_type);
   base::File file = Complete(status_code, headers_copy, data.size());
   bool success = false;
   if (file.IsValid()) {
     const int size = data.size();
     success = (file.WriteAtCurrentPos(data.c_str(), size) == size);
   }
   return success;
 }

 const std::string& Request::GetProtocolHandlerID() const {
   return protocol_handler_->GetID();
 }

 int Request::GetBodyDataFileDescriptor() const {
   int fd = dup(request_data_pipe_out_.GetPlatformFile());
   CHECK_GE(fd, 0);
   return fd;
 }

 bool Request::BeginRequestData() {
   MHD_get_connection_values(connection_, MHD_HEADER_KIND,
                             &RequestHelper::ValueCallback, this);
   MHD_get_connection_values(connection_, MHD_COOKIE_KIND,
                             &RequestHelper::ValueCallback, this);
   MHD_get_connection_values(connection_, MHD_POSTDATA_KIND,
                             &RequestHelper::ValueCallback, this);
   MHD_get_connection_values(connection_, MHD_GET_ARGUMENT_KIND,
                             &RequestHelper::ValueCallback, this);
   // If we have POST processor, then we are parsing the request ourselves and
   // we need to dispatch it to the handler only after all the data is parsed.
   // Otherwise forward the request immediately and let the handler read the
   // request data as needed.
   if (!post_processor_)
     ForwardRequestToHandler();
   return true;
 }

 bool Request::AddRequestData(const void* data, size_t* size) {
   if (!post_processor_)
     return AddRawRequestData(data, size);
   int result =
       MHD_post_process(post_processor_, static_cast<const char*>(data), *size);
   *size = 0;
   return result == MHD_YES;
 }

 void Request::EndRequestData() {
   if (!request_data_finished_) {
     if (request_data_stream_)
       request_data_stream_->CloseBlocking(nullptr);
     if (!request_forwarded_)
       ForwardRequestToHandler();
     request_data_finished_ = true;
   }

   if (response_data_started_ && !response_data_finished_) {
     MHD_Response* resp = MHD_create_response_from_callback(
         response_data_size_, 4096, &Request::ResponseDataCallback, this,
         nullptr);
     CHECK(resp);
     for (const auto& pair : response_headers_) {
       MHD_add_response_header(resp, pair.first.c_str(), pair.second.c_str());
     }
     CHECK_EQ(MHD_YES,
              MHD_queue_response(connection_, response_status_code_, resp))
         << "Failed to queue response";
     MHD_destroy_response(resp);  // |resp| is ref-counted.
     response_data_finished_ = true;
   }
 }

 void Request::ForwardRequestToHandler() {
   request_forwarded_ = true;
   if (!request_handler_id_.empty()) {
     // Close all temporary file streams, if any.
     for (auto& file : file_info_)
       file->data_stream->CloseBlocking(nullptr);

     protocol_handler_->AddRequest(this);
     auto p = protocol_handler_->request_handlers_.find(request_handler_id_);
     CHECK(p != protocol_handler_->request_handlers_.end());
     // Send the request over D-Bus and await the response.
     p->second.handler->HandleRequest(this);
   } else {
     // There was no handler found when request was made, respond with
     // 404 Page Not Found.
     Complete(brillo::http::status_code::NotFound, {},
              brillo::mime::text::kPlain, "Not Found");
   }
 }

 bool Request::ProcessPostData(const char* key,
                               const char* filename,
                               const char* content_type,
                               const char* transfer_encoding,
                               const char* data,
                               uint64_t off,
                               size_t size) {
   if (off > 0)
     return AppendPostFieldData(key, data, size);

   return AddPostFieldData(key, filename, content_type, transfer_encoding, data,
                           size);
 }

 bool Request::AddRawRequestData(const void* data, size_t* size) {
   CHECK(*size);
   CHECK(request_data_stream_) << "Data pipe hasn't been created.";

   size_t written = 0;
   if (!request_data_stream_->WriteNonBlocking(data, *size, &written, nullptr))
     return false;

   CHECK_LE(written, *size);

   // If we didn't write all the data requested, we need to let libmicrohttpd do
   // another write cycle. Schedule a DoWork() action here.
   if (written != *size)
     protocol_handler_->ScheduleWork();

   *size -= written;

   // If written at least some data, we are good. We will be called again if more
   // data is available.
   if (written > 0 || waiting_for_data_)
     return true;

   // Nothing has been written. The output pipe is full. Need to stop the data
   // transfer on the connection and wait till some data is being read from the
   // pipe by the request handler.
   MHD_suspend_connection(connection_);

   // Now, just monitor the pipe and figure out when we can resume sending data
   // over it.
   waiting_for_data_ = request_data_stream_->WaitForData(
       brillo::Stream::AccessMode::WRITE,
       base::Bind(&Request::OnPipeAvailable, weak_ptr_factory_.GetWeakPtr()),
       nullptr);

   if (!waiting_for_data_)
     MHD_resume_connection(connection_);

   return waiting_for_data_;
 }

 ssize_t Request::ResponseDataCallback(void *cls, uint64_t /* pos */, char *buf,
                                       size_t max) {
   Request* self = static_cast<Request*>(cls);
   size_t read = 0;
   bool eos = false;
   if (!self->response_data_stream_->ReadNonBlocking(buf, max, &read, &eos,
                                                     nullptr)) {
     return MHD_CONTENT_READER_END_WITH_ERROR;
   }

   if (read > 0 || self->waiting_for_data_)
     return read;

   if (eos)
     return MHD_CONTENT_READER_END_OF_STREAM;

   // Nothing can be read. The input pipe is empty. Need to stop the data
   // transfer on the connection and wait till some data is available from the
   // pipe.
   MHD_suspend_connection(self->connection_);

   self->waiting_for_data_ = self->response_data_stream_->WaitForData(
       brillo::Stream::AccessMode::READ,
       base::Bind(&Request::OnPipeAvailable,
                  self->weak_ptr_factory_.GetWeakPtr()),
       nullptr);

   if (!self->waiting_for_data_) {
     MHD_resume_connection(self->connection_);
     return MHD_CONTENT_READER_END_WITH_ERROR;
   }
   return 0;
 }

 void Request::OnPipeAvailable(brillo::Stream::AccessMode /* mode */) {
   MHD_resume_connection(connection_);
   waiting_for_data_ = false;
   protocol_handler_->ScheduleWork();
 }

 bool Request::AddPostFieldData(const char* key,
                                const char* filename,
                                const char* content_type,
                                const char* transfer_encoding,
                                const char* data,
                                size_t size) {
   if (filename) {
     std::unique_ptr<FileInfo> file_info{
         new FileInfo{key, filename, content_type ? content_type : "",
                      transfer_encoding ? transfer_encoding : ""}};
     file_info->temp_file_name = GetTempFileManager()->CreateTempFileName(id_);
     file_info->data_stream = brillo::FileStream::Open(
         file_info->temp_file_name, brillo::Stream::AccessMode::READ_WRITE,
         brillo::FileStream::Disposition::CREATE_ALWAYS, nullptr);
     if (!file_info->data_stream ||
         !file_info->data_stream->WriteAllBlocking(data, size, nullptr)) {
       return false;
     }
     file_info_.push_back(std::move(file_info));
     last_posted_data_was_file_ = true;
     return true;
   }
   std::string value{data, size};
   post_data_.emplace_back(key, value);
   last_posted_data_was_file_ = false;
   return true;
 }

 bool Request::AppendPostFieldData(const char* key,
                                   const char* data,
                                   size_t size) {
   if (last_posted_data_was_file_) {
     CHECK(!file_info_.empty());
     CHECK(file_info_.back()->field_name == key);
     FileInfo* file_info = file_info_.back().get();
     return file_info->data_stream->WriteAllBlocking(data, size, nullptr);
   }

   CHECK(!post_data_.empty());
   CHECK(post_data_.back().first == key);
   post_data_.back().second.append(data, size);
   return true;
 }

 TempFileManager* Request::GetTempFileManager() {
   return protocol_handler_->GetServer()->GetTempFileManager();
 }

 }  // namespace webservd
	// Copyright 2015 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "webservd/request.h"

	#include <microhttpd.h>

	#include <base/bind.h>
	#include <base/files/file.h>
	#include <base/guid.h>
	#include <brillo/http/http_request.h>
	#include <brillo/http/http_utils.h>
	#include <brillo/mime_utils.h>
	#include <brillo/streams/file_stream.h>
	#include <brillo/strings/string_utils.h>
	#include "webservd/log_manager.h"
	#include "webservd/protocol_handler.h"
	#include "webservd/request_handler_interface.h"
	#include "webservd/server_interface.h"
	#include "webservd/temp_file_manager.h"

	namespace webservd {

	// Helper class to provide static callback methods to microhttpd library,
	// with the ability to access private methods of Request class.
	class RequestHelper {
	public:
	static int PostDataIterator(void* cls,
	MHD_ValueKind /* kind */,
	const char* key,
	const char* filename,
	const char* content_type,
	const char* transfer_encoding,
	const char* data,
	uint64_t off,
	size_t size) {
	auto self = reinterpret_cast<Request*>(cls);
	return self->ProcessPostData(key, filename, content_type, transfer_encoding,
	data, off, size) ? MHD_YES : MHD_NO;
	}

	static int ValueCallback(void* cls,
	MHD_ValueKind kind,
	const char* key,
	const char* value) {
	auto self = reinterpret_cast<Request*>(cls);
	std::string data;
	if (value)
	data = value;
	if (kind == MHD_HEADER_KIND) {
	self->headers_.emplace_back(brillo::http::GetCanonicalHeaderName(key),
	data);
	} else if (kind == MHD_COOKIE_KIND) {
	// TODO(avakulenko): add support for cookies...
	} else if (kind == MHD_POSTDATA_KIND) {
	self->post_data_.emplace_back(key, data);
	} else if (kind == MHD_GET_ARGUMENT_KIND) {
	self->get_data_.emplace_back(key, data);
	}
	return MHD_YES;
	}
	};

	FileInfo::FileInfo(const std::string& in_field_name,
	const std::string& in_file_name,
	const std::string& in_content_type,
	const std::string& in_transfer_encoding)
	: field_name(in_field_name),
	file_name(in_file_name),
	content_type(in_content_type),
	transfer_encoding(in_transfer_encoding) {
	}

	Request::Request(
	const std::string& request_handler_id,
	const std::string& url,
	const std::string& method,
	const std::string& version,
	MHD_Connection* connection,
	ProtocolHandler* protocol_handler)
	: id_{base::GenerateGUID()},
	request_handler_id_{request_handler_id},
	url_{url},
	method_{method},
	version_{version},
	connection_{connection},
	protocol_handler_{protocol_handler} {
	// Here we create the data pipe used to transfer the request body from the
	// web server to the remote request handler.
	int pipe_fds[2] = {-1, -1};
	CHECK_EQ(0, pipe(pipe_fds));
	request_data_pipe_out_ = base::File{pipe_fds[0]};
	CHECK(request_data_pipe_out_.IsValid());
	request_data_stream_ = brillo::FileStream::FromFileDescriptor(
	pipe_fds[1], true, nullptr);
	CHECK(request_data_stream_);

	// POST request processor.
	post_processor_ = MHD_create_post_processor(
	connection, 1024, &RequestHelper::PostDataIterator, this);
	}

	Request::~Request() {
	if (post_processor_)
	MHD_destroy_post_processor(post_processor_);
	GetTempFileManager()->DeleteRequestTempFiles(id_);
	protocol_handler_->RemoveRequest(this);
	}

	base::File Request::GetFileData(int file_id) {
	base::File file;
	if (file_id >= 0 && static_cast<size_t>(file_id) < file_info_.size()) {
	file.Initialize(file_info_[file_id]->temp_file_name,
	base::File::FLAG_OPEN \| base::File::FLAG_READ);
	}
	return file;
	}

	base::File Request::Complete(
	int32_t status_code,
	const std::vector<std::tuple<std::string, std::string>>& headers,
	int64_t in_data_size) {
	base::File file;
	if (response_data_started_)
	return file;

	response_status_code_ = status_code;
	response_headers_.reserve(headers.size());
	for (const auto& tuple : headers) {
	response_headers_.emplace_back(std::get<0>(tuple), std::get<1>(tuple));
	}

	// Create the pipe for response data.
	int pipe_fds[2] = {-1, -1};
	CHECK_EQ(0, pipe(pipe_fds));
	file = base::File{pipe_fds[1]};
	CHECK(file.IsValid());
	response_data_stream_ = brillo::FileStream::FromFileDescriptor(
	pipe_fds[0], true, nullptr);
	CHECK(response_data_stream_);

	response_data_size_ = in_data_size;
	response_data_started_ = true;
	const MHD_ConnectionInfo* info =
	MHD_get_connection_info(connection_, MHD_CONNECTION_INFO_CLIENT_ADDRESS);

	const sockaddr* client_addr = (info ? info->client_addr : nullptr);
	LogManager::OnRequestCompleted(base::Time::Now(), client_addr, method_, url_,
	version_, status_code, in_data_size);
	protocol_handler_->ScheduleWork();
	return file;
	}

	bool Request::Complete(
	int32_t status_code,
	const std::vector<std::tuple<std::string, std::string>>& /* headers */,
	const std::string& mime_type,
	const std::string& data) {
	std::vector<std::tuple<std::string, std::string>> headers_copy;
	headers_copy.emplace_back(brillo::http::response_header::kContentType,
	mime_type);
	base::File file = Complete(status_code, headers_copy, data.size());
	bool success = false;
	if (file.IsValid()) {
	const int size = data.size();
	success = (file.WriteAtCurrentPos(data.c_str(), size) == size);
	}
	return success;
	}

	const std::string& Request::GetProtocolHandlerID() const {
	return protocol_handler_->GetID();
	}

	int Request::GetBodyDataFileDescriptor() const {
	int fd = dup(request_data_pipe_out_.GetPlatformFile());
	CHECK_GE(fd, 0);
	return fd;
	}

	bool Request::BeginRequestData() {
	MHD_get_connection_values(connection_, MHD_HEADER_KIND,
	&RequestHelper::ValueCallback, this);
	MHD_get_connection_values(connection_, MHD_COOKIE_KIND,
	&RequestHelper::ValueCallback, this);
	MHD_get_connection_values(connection_, MHD_POSTDATA_KIND,
	&RequestHelper::ValueCallback, this);
	MHD_get_connection_values(connection_, MHD_GET_ARGUMENT_KIND,
	&RequestHelper::ValueCallback, this);
	// If we have POST processor, then we are parsing the request ourselves and
	// we need to dispatch it to the handler only after all the data is parsed.
	// Otherwise forward the request immediately and let the handler read the
	// request data as needed.
	if (!post_processor_)
	ForwardRequestToHandler();
	return true;
	}

	bool Request::AddRequestData(const void* data, size_t* size) {
	if (!post_processor_)
	return AddRawRequestData(data, size);
	int result =
	MHD_post_process(post_processor_, static_cast<const char>(data), size);
	*size = 0;
	return result == MHD_YES;
	}

	void Request::EndRequestData() {
	if (!request_data_finished_) {
	if (request_data_stream_)
	request_data_stream_->CloseBlocking(nullptr);
	if (!request_forwarded_)
	ForwardRequestToHandler();
	request_data_finished_ = true;
	}

	if (response_data_started_ && !response_data_finished_) {
	MHD_Response* resp = MHD_create_response_from_callback(
	response_data_size_, 4096, &Request::ResponseDataCallback, this,
	nullptr);
	CHECK(resp);
	for (const auto& pair : response_headers_) {
	MHD_add_response_header(resp, pair.first.c_str(), pair.second.c_str());
	}
	CHECK_EQ(MHD_YES,
	MHD_queue_response(connection_, response_status_code_, resp))
	<< "Failed to queue response";
	MHD_destroy_response(resp); // \|resp\| is ref-counted.
	response_data_finished_ = true;
	}
	}

	void Request::ForwardRequestToHandler() {
	request_forwarded_ = true;
	if (!request_handler_id_.empty()) {
	// Close all temporary file streams, if any.
	for (auto& file : file_info_)
	file->data_stream->CloseBlocking(nullptr);

	protocol_handler_->AddRequest(this);
	auto p = protocol_handler_->request_handlers_.find(request_handler_id_);
	CHECK(p != protocol_handler_->request_handlers_.end());
	// Send the request over D-Bus and await the response.
	p->second.handler->HandleRequest(this);
	} else {
	// There was no handler found when request was made, respond with
	// 404 Page Not Found.
	Complete(brillo::http::status_code::NotFound, {},
	brillo::mime::text::kPlain, "Not Found");
	}
	}

	bool Request::ProcessPostData(const char* key,
	const char* filename,
	const char* content_type,
	const char* transfer_encoding,
	const char* data,
	uint64_t off,
	size_t size) {
	if (off > 0)
	return AppendPostFieldData(key, data, size);

	return AddPostFieldData(key, filename, content_type, transfer_encoding, data,
	size);
	}

	bool Request::AddRawRequestData(const void* data, size_t* size) {
	CHECK(*size);
	CHECK(request_data_stream_) << "Data pipe hasn't been created.";

	size_t written = 0;
	if (!request_data_stream_->WriteNonBlocking(data, *size, &written, nullptr))
	return false;

	CHECK_LE(written, *size);

	// If we didn't write all the data requested, we need to let libmicrohttpd do
	// another write cycle. Schedule a DoWork() action here.
	if (written != *size)
	protocol_handler_->ScheduleWork();

	*size -= written;

	// If written at least some data, we are good. We will be called again if more
	// data is available.
	if (written > 0 \|\| waiting_for_data_)
	return true;

	// Nothing has been written. The output pipe is full. Need to stop the data
	// transfer on the connection and wait till some data is being read from the
	// pipe by the request handler.
	MHD_suspend_connection(connection_);

	// Now, just monitor the pipe and figure out when we can resume sending data
	// over it.
	waiting_for_data_ = request_data_stream_->WaitForData(
	brillo::Stream::AccessMode::WRITE,
	base::Bind(&Request::OnPipeAvailable, weak_ptr_factory_.GetWeakPtr()),
	nullptr);

	if (!waiting_for_data_)
	MHD_resume_connection(connection_);

	return waiting_for_data_;
	}

	ssize_t Request::ResponseDataCallback(void cls, uint64_t / pos /, char buf,
	size_t max) {
	Request* self = static_cast<Request*>(cls);
	size_t read = 0;
	bool eos = false;
	if (!self->response_data_stream_->ReadNonBlocking(buf, max, &read, &eos,
	nullptr)) {
	return MHD_CONTENT_READER_END_WITH_ERROR;
	}

	if (read > 0 \|\| self->waiting_for_data_)
	return read;

	if (eos)
	return MHD_CONTENT_READER_END_OF_STREAM;

	// Nothing can be read. The input pipe is empty. Need to stop the data
	// transfer on the connection and wait till some data is available from the
	// pipe.
	MHD_suspend_connection(self->connection_);

	self->waiting_for_data_ = self->response_data_stream_->WaitForData(
	brillo::Stream::AccessMode::READ,
	base::Bind(&Request::OnPipeAvailable,
	self->weak_ptr_factory_.GetWeakPtr()),
	nullptr);

	if (!self->waiting_for_data_) {
	MHD_resume_connection(self->connection_);
	return MHD_CONTENT_READER_END_WITH_ERROR;
	}
	return 0;
	}

	void Request::OnPipeAvailable(brillo::Stream::AccessMode /* mode */) {
	MHD_resume_connection(connection_);
	waiting_for_data_ = false;
	protocol_handler_->ScheduleWork();
	}

	bool Request::AddPostFieldData(const char* key,
	const char* filename,
	const char* content_type,
	const char* transfer_encoding,
	const char* data,
	size_t size) {
	if (filename) {
	std::unique_ptr<FileInfo> file_info{
	new FileInfo{key, filename, content_type ? content_type : "",
	transfer_encoding ? transfer_encoding : ""}};
	file_info->temp_file_name = GetTempFileManager()->CreateTempFileName(id_);
	file_info->data_stream = brillo::FileStream::Open(
	file_info->temp_file_name, brillo::Stream::AccessMode::READ_WRITE,
	brillo::FileStream::Disposition::CREATE_ALWAYS, nullptr);
	if (!file_info->data_stream \|\|
	!file_info->data_stream->WriteAllBlocking(data, size, nullptr)) {
	return false;
	}
	file_info_.push_back(std::move(file_info));
	last_posted_data_was_file_ = true;
	return true;
	}
	std::string value{data, size};
	post_data_.emplace_back(key, value);
	last_posted_data_was_file_ = false;
	return true;
	}

	bool Request::AppendPostFieldData(const char* key,
	const char* data,
	size_t size) {
	if (last_posted_data_was_file_) {
	CHECK(!file_info_.empty());
	CHECK(file_info_.back()->field_name == key);
	FileInfo* file_info = file_info_.back().get();
	return file_info->data_stream->WriteAllBlocking(data, size, nullptr);
	}

	CHECK(!post_data_.empty());
	CHECK(post_data_.back().first == key);
	post_data_.back().second.append(data, size);
	return true;
	}

	TempFileManager* Request::GetTempFileManager() {
	return protocol_handler_->GetServer()->GetTempFileManager();
	}

	} // namespace webservd