#include "stdafx.h"

#undef min

#undef max

#include <boost/algorithm/string/find.hpp>

#include <boost/algorithm/string/predicate.hpp>

#include <boost/asio/read_until.hpp>

#if defined(__clang__)

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wconversion"

#pragma clang diagnostic ignored "-Winfinite-recursion"

#endif

#include <boost/asio.hpp>

#include <boost/asio/ssl.hpp>

#include <boost/filesystem.hpp>

#if defined(__clang__)

#pragma clang diagnostic pop

#endif

#include "cpprest/asyncrt_utils.h"

#include "pplx/threadpool.h"

#include "../common/internal_http_helpers.h"

#include "http_server_impl.h"

#ifdef __ANDROID__

using utility::conversions::details::to_string;

#else

using std::to_string;

#endif

using namespace boost::asio;

using namespace boost::asio::ip;

typedef boost::asio::ip::tcp::socket tcp_socket;

typedef boost::asio::ip::tcp::acceptor tcp_acceptor;

typedef boost::asio::local::stream_protocol::acceptor stream_acceptor;

typedef boost::asio::local::stream_protocol::socket stream_socket;

#define CRLF std::string("\r\n")

#define CRLFCRLF std::string("\r\n\r\n")

namespace listener = web::http::experimental::listener;

namespace chunked_encoding = web::http::details::chunked_encoding;

using web::uri;

using web::http::http_request;

using web::http::http_response;

using web::http::methods;

using web::http::status_codes;

using web::http::header_names;

using web::http::http_exception;

using web::http::experimental::listener::details::http_listener_impl;

using web::http::experimental::listener::http_listener_config;

using utility::details::make_unique;

{

template<class SOCKET_T, class ACCEPTOR_T> class hostport_listener;

template<class SOCKET_T, class ACCEPTOR_T> class http_linux_server;

template<class SOCKET_T, class ACCEPTOR_T> class asio_server_connection;

}

{

struct iequal_to

};

template<class SOCKET_T, class ACCEPTOR_T>

class http_linux_server : public web::http::experimental::details::http_server

};

struct linux_request_context : web::http::details::_http_server_context

};

template<class SOCKET_T, class ACCEPTOR_T>

class hostport_listener

};

}

{

struct crlfcrlf_nonascii_searcher_t

} crlfcrlf_nonascii_searcher;

struct will_erase_from_parent_t {};

struct will_deref_and_erase_t {};

struct will_deref_t {};

template<class SOCKET_T, class ACCEPTOR_T>

class asio_server_connection

};

}

namespace boost

{

namespace asio

{

template <> struct is_match_condition<crlfcrlf_nonascii_searcher_t> : public boost::true_type {};

}}

{

const size_t ChunkSize = 4 * 1024;

template<class SOCKET_T, class ACCEPTOR_T>

void hostport_listener<SOCKET_T, ACCEPTOR_T>::internal_erase_connection(asio_server_connection<SOCKET_T, ACCEPTOR_T>* conn)

{

std::lock_guard<std::mutex> lock(m_connections_lock);

m_connections.erase(conn);

tcp::resolver::query(m_host, m_port);

if (m_connections.empty())

{

m_all_connections_complete.set();

}

}

template<>

void hostport_listener<stream_socket, stream_acceptor>::start()

{

auto& service = crossplat::threadpool::shared_instance().service();

// Remove old socket file.

std::string socket_file_path = get_socket_file_path();

if (boost::filesystem::exists(socket_file_path.c_str()))

{

boost::filesystem::remove_all(socket_file_path.c_str());

}

local::stream_protocol::endpoint endpoint(socket_file_path.c_str());

m_acceptor.reset(new local::stream_protocol::acceptor(service, endpoint));

auto socket = new local::stream_protocol::socket(service);

m_acceptor->async_accept(*socket, [this, socket](const boost::system::error_code& ec)

{

this->on_accept(socket, ec);

});

}

template<>

will_deref_and_erase_t asio_server_connection<stream_socket, stream_acceptor>::start(bool, const std::function<void(boost::asio::ssl::context&)>&)

{

return start_request_response();

}

template<>

void hostport_listener<tcp_socket, tcp_acceptor>::start()

{

// resolve the endpoint address

auto& service = crossplat::threadpool::shared_instance().service();

tcp::resolver resolver(service);

// #446: boost resolver does not recognize "+" as a host wildchar

tcp::resolver::query query = ( "+" == m_host)?

tcp::resolver::query(m_port):

tcp::resolver::query(m_host, m_port);

tcp::endpoint endpoint =

*resolver.resolve(query);

m_acceptor.reset(new tcp::acceptor(service));

m_acceptor->open(endpoint.protocol());

m_acceptor->set_option(socket_base::reuse_address(true));

m_acceptor->bind(endpoint);

m_acceptor->listen(0 != m_backlog ? m_backlog : socket_base::max_connections);

auto socket = new ip::tcp::socket(service);

m_acceptor->async_accept(*socket, [this, socket](const boost::system::error_code& ec)

{

this->on_accept(socket, ec);

});

}

template<>

will_deref_and_erase_t asio_server_connection<tcp_socket, tcp_acceptor>::start(bool is_https, const std::function<void(boost::asio::ssl::context&)>& ssl_context_callback)

{

if (is_https)

{

m_ssl_context = make_unique<boost::asio::ssl::context>(boost::asio::ssl::context::sslv23);

if (ssl_context_callback)

{

ssl_context_callback(*m_ssl_context);

}

m_ssl_stream = make_unique<ssl_stream>(*m_socket, *m_ssl_context);

m_ssl_stream->async_handshake(boost::asio::ssl::stream_base::server, [this](const boost::system::error_code&)

{

(will_deref_and_erase_t)this->start_request_response();

});

return will_deref_and_erase_t{};

}

else

{

return start_request_response();

}

}

template<class SOCKET_T, class ACCEPTOR_T>

void asio_server_connection<SOCKET_T, ACCEPTOR_T>::close()

{

m_close = true;

auto sock = m_socket.get();

if (sock != nullptr)

{

boost::system::error_code ec;

sock->cancel(ec);

sock->shutdown(tcp::socket::shutdown_both, ec);

sock->close(ec);

}

m_request._reply_if_not_already(status_codes::InternalError);

}

template<class SOCKET_T, class ACCEPTOR_T>

will_deref_and_erase_t asio_server_connection<SOCKET_T, ACCEPTOR_T>::start_request_response()

{

m_read_size = 0;

m_read = 0;

m_request_buf.consume(m_request_buf.size()); // clear the buffer

if (m_ssl_stream)

{

boost::asio::async_read_until(*m_ssl_stream, m_request_buf, CRLFCRLF, [this](const boost::system::error_code& ec, std::size_t)

{

(will_deref_and_erase_t)this->handle_http_line(ec);

});

}

else

{

boost::asio::async_read_until(*m_socket, m_request_buf, crlfcrlf_nonascii_searcher, [this](const boost::system::error_code& ec, std::size_t)

{

(will_deref_and_erase_t)this->handle_http_line(ec);

});

}

return will_deref_and_erase_t{};

}

template<class SOCKET_T, class ACCEPTOR_T>

void hostport_listener<SOCKET_T, ACCEPTOR_T>::on_accept(SOCKET_T* socket, const boost::system::error_code& ec)

{

std::unique_ptr<SOCKET_T> usocket(std::move(socket));

if (!ec)

{

auto conn = new asio_server_connection<SOCKET_T, ACCEPTOR_T>(std::move(usocket), m_p_server, this);

std::lock_guard<std::mutex> lock(m_connections_lock);

m_connections.insert(conn);

conn->start(m_is_https, m_ssl_context_callback);

if (m_connections.size() == 1)

m_all_connections_complete.reset();

if (m_acceptor)

{

// spin off another async accept

auto newSocket = new SOCKET_T(crossplat::threadpool::shared_instance().service());

m_acceptor->async_accept(*newSocket, [this, newSocket](const boost::system::error_code& ec)

{

this->on_accept(newSocket, ec);

});

}

}

}

template<class SOCKET_T, class ACCEPTOR_T>

will_deref_and_erase_t asio_server_connection<SOCKET_T, ACCEPTOR_T>::handle_http_line(const boost::system::error_code& ec)

{

m_request = http_request::_create_request(make_unique<linux_request_context>());

if (ec)

{

// client closed connection

if (

ec == boost::asio::error::eof || // peer has performed an orderly shutdown

ec == boost::asio::error::operation_aborted || // this can be removed. ECONNABORTED happens only for accept()

ec == boost::asio::error::connection_reset || // connection reset by peer

ec == boost::asio::error::timed_out // connection timed out

)

{

return finish_request_response();

}

else

{

m_request._reply_if_not_already(status_codes::BadRequest);

m_close = true;

(will_erase_from_parent_t)do_bad_response();

(will_deref_t)deref();

return will_deref_and_erase_t{};

}

}

else

{

// read http status line

std::istream request_stream(&m_request_buf);

request_stream.imbue(std::locale::classic());

std::skipws(request_stream);

web::http::method http_verb;

#ifndef _UTF16_STRINGS

request_stream >> http_verb;

#else

{

std::string tmp;

request_stream >> tmp;

http_verb = utility::conversions::latin1_to_utf16(tmp);

}

#endif

if (boost::iequals(http_verb, methods::GET)) http_verb = methods::GET;

else if (boost::iequals(http_verb, methods::POST)) http_verb = methods::POST;

else if (boost::iequals(http_verb, methods::PUT)) http_verb = methods::PUT;

else if (boost::iequals(http_verb, methods::DEL)) http_verb = methods::DEL;

else if (boost::iequals(http_verb, methods::HEAD)) http_verb = methods::HEAD;

else if (boost::iequals(http_verb, methods::TRCE)) http_verb = methods::TRCE;

else if (boost::iequals(http_verb, methods::CONNECT)) http_verb = methods::CONNECT;

else if (boost::iequals(http_verb, methods::OPTIONS)) http_verb = methods::OPTIONS;

// Check to see if there is not allowed character on the input

if (!web::http::details::validate_method(http_verb))

{

m_request.reply(status_codes::BadRequest);

m_close = true;

(will_erase_from_parent_t)do_bad_response();

(will_deref_t)deref();

return will_deref_and_erase_t{};

}

m_request.set_method(http_verb);

std::string http_path_and_version;

std::getline(request_stream, http_path_and_version);

const size_t VersionPortionSize = sizeof(" HTTP/1.1\r") - 1;

// Make sure path and version is long enough to contain the HTTP version

if(http_path_and_version.size() < VersionPortionSize + 2)

{

m_request.reply(status_codes::BadRequest);

m_close = true;

(will_erase_from_parent_t)do_bad_response();

(will_deref_t)deref();

return will_deref_and_erase_t{};

}

// Get the path - remove the version portion and prefix space

try

{

m_request.set_request_uri(utility::conversions::to_string_t(http_path_and_version.substr(1, http_path_and_version.size() - VersionPortionSize - 1)));

}

catch (const std::exception& e) // may be std::range_error indicating invalid Unicode, or web::uri_exception

{

m_request.reply(status_codes::BadRequest, e.what());

m_close = true;

(will_erase_from_parent_t)do_bad_response();

(will_deref_t)deref();

return will_deref_and_erase_t{};

}

// Get the version

std::string http_version = http_path_and_version.substr(http_path_and_version.size() - VersionPortionSize + 1, VersionPortionSize - 2);

auto m_request_impl = m_request._get_impl().get();

web::http::http_version parsed_version = web::http::http_version::from_string(utility::conversions::to_string_t(http_version));

m_request_impl->_set_http_version(parsed_version);

// if HTTP version is 1.0 then disable pipelining

if (parsed_version == web::http::http_versions::HTTP_1_0)

{

m_close = true;

}

// Get the remote IP address

auto remote_address = get_remote_address();

if (remote_address.size() > 0)

{

m_request._get_impl()->_set_remote_address(remote_address);

}

return handle_headers();

}

}

template<>

utility::string_t asio_server_connection<stream_socket, stream_acceptor>::get_remote_address() {

return _XPLATSTR("127.0.0.1");

}

template<>

utility::string_t asio_server_connection<tcp_socket, tcp_acceptor>::get_remote_address() {

boost::system::error_code socket_ec;

auto endpoint = m_socket->remote_endpoint(socket_ec);

if (!socket_ec) {

return utility::conversions::to_string_t(endpoint.address().to_string());

}

return _XPLATSTR("");

}

template<class SOCKET_T, class ACCEPTOR_T>

will_deref_and_erase_t asio_server_connection<SOCKET_T, ACCEPTOR_T>::handle_headers()

{

std::istream request_stream(&m_request_buf);

request_stream.imbue(std::locale::classic());

std::string header;

auto& headers = m_request.headers();

while (std::getline(request_stream, header) && header != "\r")

{

auto colon = header.find(':');

if (colon != std::string::npos && colon != 0)

{

auto name = utility::conversions::to_string_t(header.substr(0, colon));

auto value = utility::conversions::to_string_t(header.substr(colon + 1, header.length() - (colon + 1))); // also exclude '\r'

web::http::details::trim_whitespace(name);

web::http::details::trim_whitespace(value);

if (boost::iequals(name, header_names::content_length))

{

headers[header_names::content_length] = value;

}

else

{

headers.add(name, value);

}

}

else

{

m_request.reply(status_codes::BadRequest);

m_close = true;

(will_erase_from_parent_t)do_bad_response();

(will_deref_t)deref();

return will_deref_and_erase_t{};

}

}

m_chunked = false;

utility::string_t name;

// check if the client has requested we close the connection

if (m_request.headers().match(header_names::connection, name))

{

m_close = boost::iequals(name, U("close"));

}

if (m_request.headers().match(header_names::transfer_encoding, name))

{

m_chunked = boost::ifind_first(name, U("chunked"));

}

m_request._get_impl()->_prepare_to_receive_data();

if (m_chunked)

{

++m_refs;

(will_deref_t)async_handle_chunked_header();

return dispatch_request_to_listener();

}

if (!m_request.headers().match(header_names::content_length, m_read_size))

{

m_read_size = 0;

}

if (m_read_size == 0)

{

m_request._get_impl()->_complete(0);

}

else // need to read the sent data

{

m_read = 0;

++m_refs;

async_read_until_buffersize(std::min(ChunkSize, m_read_size), [this](const boost::system::error_code& ec, size_t)

{

(will_deref_t)this->handle_body(ec);

});

}

return dispatch_request_to_listener();

}

template<class SOCKET_T, class ACCEPTOR_T>

will_deref_t asio_server_connection<SOCKET_T, ACCEPTOR_T>::handle_chunked_header(const boost::system::error_code& ec)

{

if (ec)

{

m_request._get_impl()->_complete(0, std::make_exception_ptr(http_exception(ec.value())));

return deref();

}

else

{

std::istream is(&m_request_buf);

is.imbue(std::locale::classic());

int len;

is >> std::hex >> len;

m_request_buf.consume(CRLF.size());

m_read += len;

if (len == 0)

{

m_request._get_impl()->_complete(m_read);

return deref();

}

else

{

async_read_until_buffersize(len + 2, [this, len](const boost::system::error_code& ec, size_t)

{

(will_deref_t)this->handle_chunked_body(ec, len);

});

return will_deref_t{};

}

}

}

template<class SOCKET_T, class ACCEPTOR_T>

will_deref_t asio_server_connection<SOCKET_T, ACCEPTOR_T>::handle_chunked_body(const boost::system::error_code& ec, int toWrite)

{

if (ec)

{

m_request._get_impl()->_complete(0, std::make_exception_ptr(http_exception(ec.value())));

return deref();

}

else

{

auto writebuf = m_request._get_impl()->outstream().streambuf();

writebuf.putn_nocopy(buffer_cast<const uint8_t *>(m_request_buf.data()), toWrite).then([=](pplx::task<size_t> writeChunkTask) -> will_deref_t

{

try

{

writeChunkTask.get();

}

catch (...)

{

m_request._get_impl()->_complete(0, std::current_exception());

return deref();

}

m_request_buf.consume(2 + toWrite);

return async_handle_chunked_header();

});

return will_deref_t{};

}

}

template<class SOCKET_T, class ACCEPTOR_T>

will_deref_t asio_server_connection<SOCKET_T, ACCEPTOR_T>::handle_body(const boost::system::error_code& ec)

{

// read body

if (ec)

{

m_request._get_impl()->_complete(0, std::make_exception_ptr(http_exception(ec.value())));

return deref();

}

else if (m_read < m_read_size) // there is more to read

{

auto writebuf = m_request._get_impl()->outstream().streambuf();

writebuf.putn_nocopy(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) -> will_deref_t

{

size_t writtenSize = 0;

try

{

writtenSize = writtenSizeTask.get();

}

catch (...)

{

m_request._get_impl()->_complete(0, std::current_exception());

return deref();

}

m_read += writtenSize;

m_request_buf.consume(writtenSize);

async_read_until_buffersize(std::min(ChunkSize, m_read_size - m_read), [this](const boost::system::error_code& ec, size_t)

{

(will_deref_t) this->handle_body(ec);

});

return will_deref_t{};

});

return will_deref_t{};

}

else // have read request body

{

m_request._get_impl()->_complete(m_read);

return deref();

}

}

template<class SOCKET_T, class ACCEPTOR_T>

will_deref_and_erase_t asio_server_connection<SOCKET_T, ACCEPTOR_T>::async_write(WriteFunc response_func_ptr, const http_response &response)

{

if (m_ssl_stream)

{

boost::asio::async_write(*m_ssl_stream, m_response_buf, [=] (const boost::system::error_code& ec, std::size_t)

{

(this->*response_func_ptr)(response, ec);

});

}

else

{

boost::asio::async_write(*m_socket, m_response_buf, [=] (const boost::system::error_code& ec, std::size_t)

{

(this->*response_func_ptr)(response, ec);

});

}

return will_deref_and_erase_t{};

}

template<class SOCKET_T, class ACCEPTOR_T>

will_deref_t asio_server_connection<SOCKET_T, ACCEPTOR_T>::async_handle_chunked_header()

{

if (m_ssl_stream)

{

boost::asio::async_read_until(*m_ssl_stream, m_request_buf, CRLF, [this](const boost::system::error_code& ec, size_t)

{

(will_deref_t)this->handle_chunked_header(ec);

});

}