/***

* ==++==

*

* Copyright (c) Microsoft Corporation. All rights reserved.

* 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.

*

* ==--==

* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+

*

* HTTP Library: Client-side APIs.

*

* This file contains a cross platform implementation based on Boost.ASIO.

*

* For the latest on this and related APIs, please see: https://github.com/Microsoft/cpprestsdk

*

* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

****/

#include "stdafx.h"

#if defined(__clang__)

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wunused-local-typedef"

#pragma clang diagnostic ignored "-Winfinite-recursion"

#endif

#include <boost/asio.hpp>

#include <boost/asio/ssl.hpp>

#include <boost/asio/steady_timer.hpp>

#include <boost/algorithm/string.hpp>

#if defined(__clang__)

#pragma clang diagnostic pop

#endif

#if defined(BOOST_NO_CXX11_SMART_PTR)

#error "Cpp rest SDK requires c++11 smart pointer support from boost"

#endif

#include "http_client_impl.h"

#include "cpprest/base_uri.h"

#include "cpprest/details/x509_cert_utilities.h"

#include <unordered_set>

using boost::asio::ip::tcp;

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

namespace web { namespace http

{

namespace client

{

namespace details

{

enum class httpclient_errorcode_context

{

none = 0,

connect,

handshake,

writeheader,

writebody,

readheader,

readbody,

close

};

class asio_connection

{

friend class asio_client;

public:

asio_connection(boost::asio::io_service& io_service)

: m_socket(io_service),

m_is_reused(false),

m_keep_alive(true)

{}

~asio_connection()

{

close();

}

// This simply instantiates the internal state to support ssl. It does not perform the handshake.

void upgrade_to_ssl(const std::function<void(boost::asio::ssl::context&)>& ssl_context_callback)

{

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

assert(!is_ssl());

boost::asio::ssl::context ssl_context(boost::asio::ssl::context::sslv23);

ssl_context.set_default_verify_paths();

ssl_context.set_options(boost::asio::ssl::context::default_workarounds);

if (ssl_context_callback)

{

ssl_context_callback(ssl_context);

}

m_ssl_stream = utility::details::make_unique<boost::asio::ssl::stream<boost::asio::ip::tcp::socket &>>(m_socket, ssl_context);

}

void close()

{

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

// Ensures closed connections owned by request_context will not be put to pool when they are released.

m_keep_alive = false;

boost::system::error_code error;

m_socket.shutdown(tcp::socket::shutdown_both, error);

m_socket.close(error);

}

boost::system::error_code cancel()

{

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

boost::system::error_code error;

m_socket.cancel(error);

return error;

}

bool is_reused() const { return m_is_reused; }

void set_keep_alive(bool keep_alive) { m_keep_alive = keep_alive; }

bool keep_alive() const { return m_keep_alive; }

bool is_ssl() const { return m_ssl_stream ? true : false; }

template <typename Iterator, typename Handler>

void async_connect(const Iterator &begin, const Handler &handler)

{

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

m_socket.async_connect(begin, handler);

}

template <typename HandshakeHandler, typename CertificateHandler>

void async_handshake(boost::asio::ssl::stream_base::handshake_type type,

const http_client_config &config,

const utility::string_t &host_name,

const HandshakeHandler &handshake_handler,

const CertificateHandler &cert_handler)

{

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

assert(is_ssl());

// Check to turn on/off server certificate verification.

if (config.validate_certificates())

{

m_ssl_stream->set_verify_mode(boost::asio::ssl::context::verify_peer);

m_ssl_stream->set_verify_callback(cert_handler);

}

else

{

m_ssl_stream->set_verify_mode(boost::asio::ssl::context::verify_none);

}

// Check to set host name for Server Name Indication (SNI)

if (config.is_tlsext_sni_enabled())

{

SSL_set_tlsext_host_name(m_ssl_stream->native_handle(), const_cast<char *>(host_name.data()));

}

m_ssl_stream->async_handshake(type, handshake_handler);

}

template <typename ConstBufferSequence, typename Handler>

void async_write(ConstBufferSequence &buffer, const Handler &writeHandler)

{

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

if (m_ssl_stream)

{

boost::asio::async_write(*m_ssl_stream, buffer, writeHandler);

}

else

{

boost::asio::async_write(m_socket, buffer, writeHandler);

}

}

template <typename MutableBufferSequence, typename CompletionCondition, typename Handler>

void async_read(MutableBufferSequence &buffer, const CompletionCondition &condition, const Handler &readHandler)

{

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

if (m_ssl_stream)

{

boost::asio::async_read(*m_ssl_stream, buffer, condition, readHandler);

}

else

{

boost::asio::async_read(m_socket, buffer, condition, readHandler);

}

}

template <typename Handler>

void async_read_until(boost::asio::streambuf &buffer, const std::string &delim, const Handler &readHandler)

{

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

if (m_ssl_stream)

{

boost::asio::async_read_until(*m_ssl_stream, buffer, delim, readHandler);

}

else

{

boost::asio::async_read_until(m_socket, buffer, delim, readHandler);

}

}

void start_reuse()

{

m_is_reused = true;

}

private:

// Guards concurrent access to socket/ssl::stream. This is necessary

// because timeouts and cancellation can touch the socket at the same time

// as normal message processing.

std::mutex m_socket_lock;

tcp::socket m_socket;

std::unique_ptr<boost::asio::ssl::stream<tcp::socket &> > m_ssl_stream;

bool m_is_reused;

bool m_keep_alive;

};

/// <summary>Implements a connection pool with adaptive connection removal</summary>

/// <remarks>

/// The timeout mechanism is based on the `uint64_t m_epoch` member. Every 30 seconds,

/// the lambda in `start_epoch_interval` fires, triggering the cleanup of any

/// connections that have resided in the pool since the last cleanup phase's epoch.

///

/// This works because the `m_connections` member functions is used in LIFO order.

/// LIFO usage guarantees that the elements remain sorted based on epoch number,

/// since the highest epoch is always removed and on insertion the next monotonically

/// increasing epoch is used.

///

/// During the cleanup phase, connections are removed starting with the oldest. This

/// ensures that if a high intensity workload is followed by a low intensity workload,

/// the connection pool will correctly adapt to the low intensity workload.

///

/// Specifically, the following code will eventually result in a maximum of one pooled

/// connection regardless of the initial number of pooled connections:

/// <code>

/// while(1)

/// {

/// auto conn = pool.acquire();

/// if (!conn) conn = new_conn();

/// pool.release(conn);

/// }

/// </code>

/// </remarks>

class asio_connection_pool : public std::enable_shared_from_this<asio_connection_pool>

{

public:

asio_connection_pool() : m_pool_epoch_timer(crossplat::threadpool::shared_instance().service())

{}

std::shared_ptr<asio_connection> acquire()

{

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

if (m_connections.empty())

return nullptr;

auto conn = std::move(m_connections.back().second);

m_connections.pop_back();

conn->start_reuse();

return conn;

}

void release(const std::shared_ptr<asio_connection>& connection)

{

connection->cancel();

if (!connection->keep_alive())

return;

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

if (!is_timer_running)

{

start_epoch_interval(shared_from_this());

is_timer_running = true;

}

m_epoch++;

m_connections.emplace_back(m_epoch, std::move(connection));

}

private:

// Note: must be called under m_lock

static void start_epoch_interval(const std::shared_ptr<asio_connection_pool>& pool)

{

_ASSERTE(pool.get() != nullptr);

auto& self = *pool;

std::weak_ptr<asio_connection_pool> weak_pool = pool;

self.m_prev_epoch = self.m_epoch;

pool->m_pool_epoch_timer.expires_from_now(boost::posix_time::seconds(30));

pool->m_pool_epoch_timer.async_wait([weak_pool](const boost::system::error_code& ec)

{

if (ec)

return;

auto pool = weak_pool.lock();

if (!pool)

return;

auto& self = *pool;

std::lock_guard<std::mutex> lock(self.m_lock);

if (self.m_prev_epoch == self.m_epoch)

{

self.m_connections.clear();

self.is_timer_running = false;

return;

}

else

{

auto prev_epoch = self.m_prev_epoch;

auto erase_end = std::find_if(self.m_connections.begin(), self.m_connections.end(),

[prev_epoch](std::pair<uint64_t, std::shared_ptr<asio_connection>>& p)

{

return p.first > prev_epoch;

});

self.m_connections.erase(self.m_connections.begin(), erase_end);

start_epoch_interval(pool);

}

});

}

std::mutex m_lock;

std::deque<std::pair<uint64_t, std::shared_ptr<asio_connection>>> m_connections;

uint64_t m_epoch = 0;

uint64_t m_prev_epoch = 0;

bool is_timer_running = false;

boost::asio::deadline_timer m_pool_epoch_timer;

};

class asio_client final : public _http_client_communicator

{

public:

asio_client(http::uri&& address, http_client_config&& client_config)

: _http_client_communicator(std::move(address), std::move(client_config))

, m_resolver(crossplat::threadpool::shared_instance().service())

, m_pool(std::make_shared<asio_connection_pool>())

, m_start_with_ssl(base_uri().scheme() == "https" && !this->client_config().proxy().is_specified())

{}

void send_request(const std::shared_ptr<request_context> &request_ctx) override;

unsigned long open() override { return 0; }

void release_connection(std::shared_ptr<asio_connection>& conn)

{

m_pool->release(conn);

}

std::shared_ptr<asio_connection> obtain_connection()

{

std::shared_ptr<asio_connection> conn = m_pool->acquire();

if (conn == nullptr)

{

// Pool was empty. Create a new connection

conn = std::make_shared<asio_connection>(crossplat::threadpool::shared_instance().service());

if (m_start_with_ssl)

conn->upgrade_to_ssl(this->client_config().get_ssl_context_callback());

}

return conn;

}

virtual pplx::task<http_response> propagate(http_request request) override;

public:

tcp::resolver m_resolver;

private:

const std::shared_ptr<asio_connection_pool> m_pool;

const bool m_start_with_ssl;

};

class asio_context : public request_context, public std::enable_shared_from_this<asio_context>

{

friend class asio_client;

public:

asio_context(const std::shared_ptr<_http_client_communicator> &client,

http_request &request,

const std::shared_ptr<asio_connection> &connection)

: request_context(client, request)

, m_content_length(0)

, m_needChunked(false)

, m_timer(client->client_config().timeout<std::chrono::microseconds>())

, m_connection(connection)

#if defined(__APPLE__) || (defined(ANDROID) || defined(__ANDROID__))

, m_openssl_failed(false)

#endif

{}

virtual ~asio_context()

{

m_timer.stop();

// Release connection back to the pool. If connection was not closed, it will be put to the pool for reuse.

std::static_pointer_cast<asio_client>(m_http_client)->release_connection(m_connection);

}

static std::shared_ptr<request_context> create_request_context(std::shared_ptr<_http_client_communicator> &client, http_request &request)

{

auto client_cast(std::static_pointer_cast<asio_client>(client));

auto connection(client_cast->obtain_connection());

auto ctx = std::make_shared<asio_context>(client, request, connection);

ctx->m_timer.set_ctx(std::weak_ptr<asio_context>(ctx));

return ctx;

}

class ssl_proxy_tunnel : public std::enable_shared_from_this<ssl_proxy_tunnel>

{

public:

ssl_proxy_tunnel(std::shared_ptr<asio_context> context, std::function<void(std::shared_ptr<asio_context>)> ssl_tunnel_established)

: m_ssl_tunnel_established(ssl_tunnel_established), m_context(context)

{}

void start_proxy_connect()

{

auto proxy = m_context->m_http_client->client_config().proxy();

auto proxy_uri = proxy.address();

utility::string_t proxy_host = proxy_uri.host();

int proxy_port = proxy_uri.port() == -1 ? 8080 : proxy_uri.port();

const auto &base_uri = m_context->m_http_client->base_uri();

const auto &host = base_uri.host();

std::ostream request_stream(&m_request);

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

request_stream << "CONNECT " << host << ":" << 443 << " HTTP/1.1" << CRLF;

request_stream << "Host: " << host << ":" << 443 << CRLF;

request_stream << "Proxy-Connection: Keep-Alive" << CRLF;

if(m_context->m_http_client->client_config().proxy().credentials().is_set())

{

request_stream << m_context->generate_basic_proxy_auth_header() << CRLF;

}

request_stream << CRLF;

m_context->m_timer.start();

tcp::resolver::query query(proxy_host, utility::conversions::print_string(proxy_port, std::locale::classic()));

auto client = std::static_pointer_cast<asio_client>(m_context->m_http_client);

client->m_resolver.async_resolve(query, boost::bind(&ssl_proxy_tunnel::handle_resolve, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::iterator));

}

private:

void handle_resolve(const boost::system::error_code& ec, tcp::resolver::iterator endpoints)

{

if (ec)

{

m_context->report_error("Error resolving proxy address", ec, httpclient_errorcode_context::connect);

}

else

{

m_context->m_timer.reset();

auto endpoint = *endpoints;

m_context->m_connection->async_connect(endpoint, boost::bind(&ssl_proxy_tunnel::handle_tcp_connect, shared_from_this(), boost::asio::placeholders::error, ++endpoints));

// TODO: refactor all interactions with the timeout_timer to avoid racing

if (m_context->m_timer.has_timedout())

{

m_context->m_connection->close();

}

}

}

void handle_tcp_connect(const boost::system::error_code& ec, tcp::resolver::iterator endpoints)

{

if (!ec)

{

m_context->m_timer.reset();

m_context->m_connection->async_write(m_request, boost::bind(&ssl_proxy_tunnel::handle_write_request, shared_from_this(), boost::asio::placeholders::error));

}

else if (endpoints == tcp::resolver::iterator())

{

m_context->report_error("Failed to connect to any resolved proxy endpoint", ec, httpclient_errorcode_context::connect);

}

else

{

m_context->m_timer.reset();

//// Replace the connection. This causes old connection object to go out of scope.

auto client = std::static_pointer_cast<asio_client>(m_context->m_http_client);

m_context->m_connection = client->obtain_connection();

auto endpoint = *endpoints;

m_context->m_connection->async_connect(endpoint, boost::bind(&ssl_proxy_tunnel::handle_tcp_connect, shared_from_this(), boost::asio::placeholders::error, ++endpoints));

}

}

void handle_write_request(const boost::system::error_code& err)

{

if (!err)

{

m_context->m_timer.reset();

m_context->m_connection->async_read_until(m_response, CRLF + CRLF, boost::bind(&ssl_proxy_tunnel::handle_status_line, shared_from_this(), boost::asio::placeholders::error));

}

else

{

m_context->report_error("Failed to send connect request to proxy.", err, httpclient_errorcode_context::writebody);

}

}

void handle_status_line(const boost::system::error_code& ec)

{

if (!ec)

{

m_context->m_timer.reset();

std::istream response_stream(&m_response);

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

std::string http_version;

response_stream >> http_version;

status_code status_code;

response_stream >> status_code;

if (!response_stream || http_version.substr(0, 5) != "HTTP/")

{

m_context->report_error("Invalid HTTP status line during proxy connection", ec, httpclient_errorcode_context::readheader);

return;

}

if (status_code != 200)

{

utility::stringstream_t err_ss;

err_ss << U("Expected a 200 response from proxy, received: ") << status_code;

m_context->report_error(err_ss.str(), ec, httpclient_errorcode_context::readheader);

return;

}

m_context->m_connection->upgrade_to_ssl(m_context->m_http_client->client_config().get_ssl_context_callback());

m_ssl_tunnel_established(m_context);

}

else

{

// These errors tell if connection was closed.

const bool socket_was_closed((boost::asio::error::eof == ec)

|| (boost::asio::error::connection_reset == ec)

|| (boost::asio::error::connection_aborted == ec));

if (socket_was_closed && m_context->m_connection->is_reused())

{

// Failed to write to socket because connection was already closed while it was in the pool.

// close() here ensures socket is closed in a robust way and prevents the connection from being put to the pool again.

m_context->m_connection->close();

// Create a new context and copy the request object, completion event and

// cancellation registration to maintain the old state.

// This also obtains a new connection from pool.

auto new_ctx = m_context->create_request_context(m_context->m_http_client, m_context->m_request);

new_ctx->m_request_completion = m_context->m_request_completion;

new_ctx->m_cancellationRegistration = m_context->m_cancellationRegistration;

auto client = std::static_pointer_cast<asio_client>(m_context->m_http_client);

// Resend the request using the new context.

client->send_request(new_ctx);

}

else

{

m_context->report_error("Failed to read HTTP status line from proxy", ec, httpclient_errorcode_context::readheader);

}

}

}

std::function<void(std::shared_ptr<asio_context>)> m_ssl_tunnel_established;

std::shared_ptr<asio_context> m_context;

boost::asio::streambuf m_request;

boost::asio::streambuf m_response;

};

enum class http_proxy_type

{

none,

http,

ssl_tunnel

};

void start_request()

{

if (m_request._cancellation_token().is_canceled())

{

request_context::report_error(make_error_code(std::errc::operation_canceled).value(), "Request canceled by user.");

return;

}

http_proxy_type proxy_type = http_proxy_type::none;

utility::string_t proxy_host;

int proxy_port = -1;

// There is no support for auto-detection of proxies on non-windows platforms, it must be specified explicitly from the client code.

if (m_http_client->client_config().proxy().is_specified())

{

proxy_type = m_http_client->base_uri().scheme() == U("https") ? http_proxy_type::ssl_tunnel : http_proxy_type::http;

auto proxy = m_http_client->client_config().proxy();

auto proxy_uri = proxy.address();

proxy_port = proxy_uri.port() == -1 ? 8080 : proxy_uri.port();

proxy_host = proxy_uri.host();

}

auto start_http_request_flow = [proxy_type, proxy_host, proxy_port](std::shared_ptr<asio_context> ctx)

{

if (ctx->m_request._cancellation_token().is_canceled())

{

ctx->request_context::report_error(make_error_code(std::errc::operation_canceled).value(), "Request canceled by user.");

return;

}

const auto &base_uri = ctx->m_http_client->base_uri();

const auto full_uri = uri_builder(base_uri).append(ctx->m_request.relative_uri()).to_uri();

// For a normal http proxy, we need to specify the full request uri, otherwise just specify the resource

auto encoded_resource = proxy_type == http_proxy_type::http ? full_uri.to_string() : full_uri.resource().to_string();

if (encoded_resource == "")

{

encoded_resource = "/";

}

const auto &method = ctx->m_request.method();

// stop injection of headers via method

// resource should be ok, since it's been encoded

// and host won't resolve

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

{

ctx->report_exception(http_exception("The method string is invalid."));

return;

}

std::ostream request_stream(&ctx->m_body_buf);

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

const auto &host = base_uri.host();

request_stream << method << " " << encoded_resource << " " << "HTTP/1.1" << CRLF;

int port = base_uri.port();

if (base_uri.is_port_default())

{

port = (ctx->m_connection->is_ssl() ? 443 : 80);

}

// Add the Host header if user has not specified it explicitly

if (!ctx->m_request.headers().has(header_names::host))

{

request_stream << "Host: " << host << ":" << port << CRLF;

}

// Extra request headers are constructed here.

utility::string_t extra_headers;

// Add header for basic proxy authentication

if (proxy_type == http_proxy_type::http && ctx->m_http_client->client_config().proxy().credentials().is_set())

{

extra_headers.append(ctx->generate_basic_proxy_auth_header());

}

if (ctx->m_http_client->client_config().credentials().is_set())

{

extra_headers.append(ctx->generate_basic_auth_header());

}

// Check user specified transfer-encoding.

std::string transferencoding;

if (ctx->m_request.headers().match(header_names::transfer_encoding, transferencoding) && transferencoding == "chunked")

{

ctx->m_needChunked = true;

}

else if (!ctx->m_request.headers().match(header_names::content_length, ctx->m_content_length))

{

// Stream without content length is the signal of requiring transfer encoding chunked.

if (ctx->m_request.body())

{

ctx->m_needChunked = true;

extra_headers.append(header_names::transfer_encoding);

extra_headers.append(":chunked" + CRLF);

}

}

if (proxy_type == http_proxy_type::http)

{

extra_headers.append(header_names::cache_control);

extra_headers.append(": no-store, no-cache" + CRLF);

extra_headers.append(header_names::pragma);

extra_headers.append(": no-cache" + CRLF);

}

request_stream << ::web::http::details::flatten_http_headers(ctx->m_request.headers());

request_stream << extra_headers;

// Enforce HTTP connection keep alive (even for the old HTTP/1.0 protocol).

request_stream << "Connection: Keep-Alive" << CRLF << CRLF;

// Start connection timeout timer.

if (!ctx->m_timer.has_started())

{

ctx->m_timer.start();

}

if (ctx->m_connection->is_reused() || proxy_type == http_proxy_type::ssl_tunnel)

{

// If socket is a reused connection or we're connected via an ssl-tunneling proxy, try to write the request directly. In both cases we have already established a tcp connection.

ctx->write_request();

}

else

{

// If the connection is new (unresolved and unconnected socket), then start async

// call to resolve first, leading eventually to request write.

// For normal http proxies, we want to connect directly to the proxy server. It will relay our request.

auto tcp_host = proxy_type == http_proxy_type::http ? proxy_host : host;

auto tcp_port = proxy_type == http_proxy_type::http ? proxy_port : port;

tcp::resolver::query query(tcp_host, utility::conversions::print_string(tcp_port, std::locale::classic()));

auto client = std::static_pointer_cast<asio_client>(ctx->m_http_client);

client->m_resolver.async_resolve(query, boost::bind(&asio_context::handle_resolve, ctx, boost::asio::placeholders::error, boost::asio::placeholders::iterator));

}

// Register for notification on cancellation to abort this request.

if (ctx->m_request._cancellation_token() != pplx::cancellation_token::none())

{

// weak_ptr prevents lambda from taking shared ownership of the context.

// Otherwise context replacement in the handle_status_line() would leak the objects.

std::weak_ptr<asio_context> ctx_weak(ctx);

ctx->m_cancellationRegistration = ctx->m_request._cancellation_token().register_callback([ctx_weak]()

{

if (auto ctx_lock = ctx_weak.lock())

{

// Shut down transmissions, close the socket and prevent connection from being pooled.

ctx_lock->m_connection->close();

}

});

}

};

if (proxy_type == http_proxy_type::ssl_tunnel)

{

// The ssl_tunnel_proxy keeps the context alive and then calls back once the ssl tunnel is established via 'start_http_request_flow'

std::shared_ptr<ssl_proxy_tunnel> ssl_tunnel = std::make_shared<ssl_proxy_tunnel>(shared_from_this(), start_http_request_flow);

ssl_tunnel->start_proxy_connect();

}

else

{

start_http_request_flow(shared_from_this());

}

}

template<typename _ExceptionType>

void report_exception(const _ExceptionType &e)

{

report_exception(std::make_exception_ptr(e));

}

void report_exception(std::exception_ptr exceptionPtr) override

{

// Don't recycle connections that had an error into the connection pool.

m_connection->close();

request_context::report_exception(exceptionPtr);

}

private:

utility::string_t generate_basic_auth_header()

{

utility::string_t header;

header.append(header_names::authorization);

header.append(": Basic ");

auto credential_str = web::details::plaintext_string(new ::utility::string_t(m_http_client->client_config().credentials().username()));

credential_str->append(":");

credential_str->append(*m_http_client->client_config().credentials().decrypt());

std::vector<unsigned char> credentials_buffer(credential_str->begin(), credential_str->end());

header.append(utility::conversions::to_base64(credentials_buffer));

header.append(CRLF);

return header;

}

utility::string_t generate_basic_proxy_auth_header()

{

utility::string_t header;

header.append(header_names::proxy_authorization);

header.append(": Basic ");

auto credential_str = web::details::plaintext_string(new ::utility::string_t(m_http_client->client_config().proxy().credentials().username()));

credential_str->append(":");

credential_str->append(*m_http_client->client_config().proxy().credentials().decrypt());

std::vector<unsigned char> credentials_buffer(credential_str->begin(), credential_str->end());

header.append(utility::conversions::to_base64(credentials_buffer));

header.append(CRLF);

return header;

}

void report_error(const utility::string_t &message, const boost::system::error_code &ec, httpclient_errorcode_context context = httpclient_errorcode_context::none)

{

// By default, errorcodeValue don't need to converted

long errorcodeValue = ec.value();

// map timer cancellation to time_out

if (m_timer.has_timedout())

{

errorcodeValue = make_error_code(std::errc::timed_out).value();

}

else

{

// We need to correct inaccurate ASIO error code base on context information

switch (context)

{

case httpclient_errorcode_context::writeheader:

if (ec == boost::system::errc::broken_pipe)

{

errorcodeValue = make_error_code(std::errc::host_unreachable).value();

}

break;

case httpclient_errorcode_context::connect:

if (ec == boost::system::errc::connection_refused)

{

errorcodeValue = make_error_code(std::errc::host_unreachable).value();

}

break;

case httpclient_errorcode_context::readheader:

if (ec.default_error_condition().value() == boost::system::errc::no_such_file_or_directory) // bug in boost error_code mapping

{

errorcodeValue = make_error_code(std::errc::connection_aborted).value();

}

break;

default:

break;

}

}

request_context::report_error(errorcodeValue, message);

}

void handle_connect(const boost::system::error_code& ec, tcp::resolver::iterator endpoints)

{

m_timer.reset();

if (!ec)

{

write_request();

}

else if (ec.value() == boost::system::errc::operation_canceled)

{

request_context::report_error(ec.value(), "Request canceled by user.");

}

else if (endpoints == tcp::resolver::iterator())

{

report_error("Failed to connect to any resolved endpoint", ec, httpclient_errorcode_context::connect);

}

else

{

// Replace the connection. This causes old connection object to go out of scope.

auto client = std::static_pointer_cast<asio_client>(m_http_client);

m_connection = client->obtain_connection();

auto endpoint = *endpoints;

m_connection->async_connect(endpoint, boost::bind(&asio_context::handle_connect, shared_from_this(), boost::asio::placeholders::error, ++endpoints));

}

}

void handle_resolve(const boost::system::error_code& ec, tcp::resolver::iterator endpoints)

{

if (ec)

{

report_error("Error resolving address", ec, httpclient_errorcode_context::connect);

}

else

{

m_timer.reset();

auto endpoint = *endpoints;

m_connection->async_connect(endpoint, boost::bind(&asio_context::handle_connect, shared_from_this(), boost::asio::placeholders::error, ++endpoints));

// TODO: refactor all interactions with the timeout_timer to avoid racing

if (m_timer.has_timedout())

{

m_connection->close();

}

}

}

void write_request()

{

// Only perform handshake if a TLS connection and not being reused.

if (m_connection->is_ssl() && !m_connection->is_reused())

{

const auto weakCtx = std::weak_ptr<asio_context>(shared_from_this());

m_connection->async_handshake(boost::asio::ssl::stream_base::client,

m_http_client->client_config(),

m_http_client->base_uri().host(),

boost::bind(&asio_context::handle_handshake, shared_from_this(), boost::asio::placeholders::error),

// Use a weak_ptr since the verify_callback is stored until the connection is destroyed.

// This avoids creating a circular reference since we pool connection objects.

[weakCtx](bool preverified, boost::asio::ssl::verify_context &verify_context)

{

auto this_request = weakCtx.lock();

if(this_request)

{

return this_request->handle_cert_verification(preverified, verify_context);

}

return false;

});

}

else

{

m_connection->async_write(m_body_buf, boost::bind(&asio_context::handle_write_headers, shared_from_this(), boost::asio::placeholders::error));

}

}

void handle_handshake(const boost::system::error_code& ec)

{

if (!ec)

{

m_connection->async_write(m_body_buf, boost::bind(&asio_context::handle_write_headers, shared_from_this(), boost::asio::placeholders::error));

}

else

{

report_error("Error in SSL handshake", ec, httpclient_errorcode_context::handshake);

}

}

bool handle_cert_verification(bool preverified, boost::asio::ssl::verify_context &verifyCtx)

{

// OpenSSL calls the verification callback once per certificate in the chain,

// starting with the root CA certificate. The 'leaf', non-Certificate Authority (CA)

// certificate, i.e. actual server certificate is at the '0' position in the

// certificate chain, the rest are optional intermediate certificates, followed

// finally by the root CA self signed certificate.

const auto &host = m_http_client->base_uri().host();

#if defined(__APPLE__) || (defined(ANDROID) || defined(__ANDROID__))

// On OS X, iOS, and Android, OpenSSL doesn't have access to where the OS

// stores keychains. If OpenSSL fails we will doing verification at the

// end using the whole certificate chain so wait until the 'leaf' cert.

// For now return true so OpenSSL continues down the certificate chain.

if(!preverified)

{

m_openssl_failed = true;

}

if(m_openssl_failed)

{

return verify_cert_chain_platform_specific(verifyCtx, host);

}

#endif

boost::asio::ssl::rfc2818_verification rfc2818(host);

return rfc2818(preverified, verifyCtx);

}

void handle_write_headers(const boost::system::error_code& ec)

{

if(ec)

{

report_error("Failed to write request headers", ec, httpclient_errorcode_context::writeheader);

}

else

{

if (m_needChunked)

{

handle_write_chunked_body(ec);

}

else

{

handle_write_large_body(ec);

}

}

}

void handle_write_chunked_body(const boost::system::error_code& ec)

{

if (ec)

{

// Reuse error handling.

return handle_write_body(ec);

}

m_timer.reset();

const auto &progress = m_request._get_impl()->_progress_handler();

if (progress)

{

try

{

(*progress)(message_direction::upload, m_uploaded);

}

catch(...)