Merge branch 'development' of https://git01.codeplex.com/forks/evanc/mshpccasablanca into evanc/mshpccasablanca

unknown · unknown · commit 93e73be5be06 · 2015-10-07T11:44:57.000-07:00
diff --git a/Release/include/cpprest/asyncrt_utils.h b/Release/include/cpprest/asyncrt_utils.h
@@ -284,6 +284,11 @@ namespace details
         return std::unique_ptr<_Type>(new _Type(std::forward<_Arg1>(arg1), std::forward<_Arg2>(arg2), std::forward<_Arg3>(arg3)));
     }
 
+    template <typename _Type, typename _Arg1, typename _Arg2, typename _Arg3, typename _Arg4>
+    std::unique_ptr<_Type> make_unique(_Arg1&& arg1, _Arg2&& arg2, _Arg3&& arg3, _Arg4&& arg4) {
+        return std::unique_ptr<_Type>(new _Type(std::forward<_Arg1>(arg1), std::forward<_Arg2>(arg2), std::forward<_Arg3>(arg3), std::forward<_Arg4>(arg4)));
+    }
+
     /// <summary>
     /// Cross platform utility function for performing case insensitive string comparision.
     /// </summary>
diff --git a/Release/include/cpprest/details/http_server_asio.h b/Release/include/cpprest/details/http_server_asio.h
@@ -19,6 +19,7 @@
 #pragma clang diagnostic ignored "-Wconversion"
 #endif
 #include <boost/asio.hpp>
+#include <boost/asio/ssl.hpp>
 #if defined(__clang__)
 #pragma clang diagnostic pop
 #endif
@@ -57,6 +58,8 @@ class hostport_listener;
 class connection
 {
 private:
+    typedef void (connection::*ResponseFuncPtr) (const http_response &response, const boost::system::error_code& ec);
+
     std::unique_ptr<boost::asio::ip::tcp::socket> m_socket;
     boost::asio::streambuf m_request_buf;
     boost::asio::streambuf m_response_buf;
@@ -69,16 +72,28 @@ class connection
     bool m_chunked;
     std::atomic<int> m_refs; // track how many threads are still referring to this
     
+    std::unique_ptr<boost::asio::ssl::stream<boost::asio::ip::tcp::socket&>> m_ssl_stream;
+
 public:
-    connection(std::unique_ptr<boost::asio::ip::tcp::socket> socket, http_linux_server* server, hostport_listener* parent)
+    connection(std::unique_ptr<boost::asio::ip::tcp::socket> socket, http_linux_server* server, hostport_listener* parent, bool is_https, const std::function<void(boost::asio::ssl::context&)>& ssl_context_callback)
     : m_socket(std::move(socket))
     , m_request_buf()
     , m_response_buf()
     , m_p_server(server)
     , m_p_parent(parent)
     , m_refs(1)
     {
-        start_request_response();
+        if (is_https)
+        {
+            boost::asio::ssl::context ssl_context(boost::asio::ssl::context::sslv23);
+            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);
+            m_ssl_stream->async_handshake(boost::asio::ssl::stream_base::server, [this](const boost::system::error_code&) { this->start_request_response(); });
+        }
+        else 
+        {
+            start_request_response();
+        }
     }
 
     connection(const connection&) = delete;
@@ -95,6 +110,10 @@ class connection
     void handle_chunked_body(const boost::system::error_code& ec, int toWrite);
     void dispatch_request_to_listener();
     void do_response(bool bad_request);
+    void async_write(ResponseFuncPtr response_func_ptr, const http_response &response);
+    template <typename CompletionCondition, typename Handler>
+    void async_read(CompletionCondition &&condition, Handler &&read_handler);
+    void async_read_until();
     template <typename ReadHandler>
     void async_read_until_buffersize(size_t size, const ReadHandler &handler);
     void async_process_response(http_response response);
@@ -124,14 +143,19 @@ class hostport_listener
     std::string m_host;
     std::string m_port;
 
+    bool m_is_https;
+    const std::function<void(boost::asio::ssl::context&)>& m_ssl_context_callback;
+
 public:
-     hostport_listener(http_linux_server* server, const std::string& hostport)
+     hostport_listener(http_linux_server* server, const std::string& hostport, bool is_https, const http_listener_config& config)
     : m_acceptor()
     , m_listeners()
     , m_listeners_lock()
     , m_connections_lock()
     , m_connections()
     , m_p_server(server)
+    , m_is_https(is_https)
+    , m_ssl_context_callback(config.get_ssl_context_callback())
     {
         m_all_connections_complete.set();
 
diff --git a/Release/include/cpprest/http_client.h b/Release/include/cpprest/http_client.h
@@ -42,6 +42,9 @@ typedef void* native_handle;}}}
 
 #include <memory>
 #include <limits>
+#if !defined(_WIN32) && !defined(__cplusplus_winrt)
+#include <boost/asio/ssl.hpp>
+#endif
 
 #include "pplx/pplxtasks.h"
 #include "cpprest/http_msg.h"
@@ -88,6 +91,9 @@ class http_client_config
         , m_validate_certificates(true)
 #endif
         , m_set_user_nativehandle_options([](native_handle)->void{})
+#if !defined(_WIN32) && !defined(__cplusplus_winrt)
+        , m_ssl_context_callback([](boost::asio::ssl::context&)->void{})
+#endif
 #if defined(_WIN32) && !defined(__cplusplus_winrt)
         , m_buffer_request(false)
 #endif
@@ -316,6 +322,25 @@ class http_client_config
         m_set_user_nativehandle_options(handle);
     }
 
+#if !defined(_WIN32) && !defined(__cplusplus_winrt)
+    /// <summary>
+    /// Sets a callback to enable custom setting of the ssl context, at construction time.
+    /// </summary>
+    /// <param name="callback">A user callback allowing for customization of the ssl context at construction time.</param>
+    void set_ssl_context_callback(const std::function<void(boost::asio::ssl::context&)>& callback)
+    {
+         m_ssl_context_callback = callback;
+    }
+
+    /// <summary>
+    /// Gets the user's callback to allow for customization of the ssl context.
+    /// </summary>
+    const std::function<void(boost::asio::ssl::context&)>& get_ssl_context_callback() const
+    {
+        return m_ssl_context_callback;
+    }
+#endif
+
 private:
 #if !defined(CPPREST_TARGET_XP)
     std::shared_ptr<oauth1::experimental::oauth1_config> m_oauth1;
@@ -337,6 +362,9 @@ class http_client_config
 
     std::function<void(native_handle)> m_set_user_nativehandle_options;
 
+#if !defined(_WIN32) && !defined(__cplusplus_winrt)
+    std::function<void(boost::asio::ssl::context&)> m_ssl_context_callback;
+#endif
 #if defined(_WIN32) && !defined(__cplusplus_winrt)
     bool m_buffer_request;
 #endif
diff --git a/Release/include/cpprest/http_listener.h b/Release/include/cpprest/http_listener.h
@@ -29,6 +29,10 @@
 #include <limits>
 #include <functional>
 
+#if !defined(_WIN32) || (_WIN32_WINNT >= _WIN32_WINNT_VISTA && !defined(__cplusplus_winrt))
+#include <boost/asio/ssl.hpp>
+#endif
+
 #include "cpprest/http_msg.h"
 
 #if !defined(_WIN32) || (_WIN32_WINNT >= _WIN32_WINNT_VISTA && !defined(__cplusplus_winrt))
@@ -64,6 +68,9 @@ class http_listener_config
     /// <param name="other">http_listener_config to copy.</param>
     http_listener_config(const http_listener_config &other)
         : m_timeout(other.m_timeout)
+#ifndef _WIN32
+        , m_ssl_context_callback(other.m_ssl_context_callback)
+#endif
     {}
 
     /// <summary>
@@ -72,6 +79,9 @@ class http_listener_config
     /// <param name="other">http_listener_config to move from.</param>
     http_listener_config(http_listener_config &&other)
         : m_timeout(std::move(other.m_timeout))
+#ifndef _WIN32
+        , m_ssl_context_callback(std::move(other.m_ssl_context_callback))
+#endif
     {}
 
     /// <summary>
@@ -83,6 +93,9 @@ class http_listener_config
         if(this != &rhs)
         {
             m_timeout = rhs.m_timeout;
+#ifndef _WIN32
+            m_ssl_context_callback = rhs.m_ssl_context_callback;
+#endif
         }
         return *this;
     }
@@ -96,6 +109,9 @@ class http_listener_config
         if(this != &rhs)
         {
             m_timeout = std::move(rhs.m_timeout);
+#ifndef _WIN32
+            m_ssl_context_callback = std::move(rhs.m_ssl_context_callback);
+#endif
         }
         return *this;
     }
@@ -118,9 +134,32 @@ class http_listener_config
         m_timeout = std::move(timeout);
     }
 
+#ifndef _WIN32
+    /// <summary>
+    /// Get the callback of ssl context
+    /// </summary>
+    /// <returns>The function defined by the user of http_listener_config to configure a ssl context.</returns>
+    const std::function<void(boost::asio::ssl::context&)>& get_ssl_context_callback() const
+    {
+        return m_ssl_context_callback;
+    }
+
+    /// <summary>
+    /// Set the callback of ssl context
+    /// </summary>
+    /// <param name="ssl_context_callback">The function to configure a ssl context which will setup https connections.</param>
+    void set_ssl_context_callback(const std::function<void(boost::asio::ssl::context&)> &ssl_context_callback)
+    {
+        m_ssl_context_callback = ssl_context_callback;
+    }
+#endif
+
 private:
 
     utility::seconds m_timeout;
+#ifndef _WIN32
+    std::function<void(boost::asio::ssl::context&)> m_ssl_context_callback;
+#endif
 };
 
 namespace details
@@ -311,4 +350,4 @@ class http_listener
 }}}}
 
 #endif
-#endif
+#endif
diff --git a/Release/src/http/client/http_client_asio.cpp b/Release/src/http/client/http_client_asio.cpp
@@ -67,18 +67,19 @@ class asio_connection
     friend class asio_connection_pool;
     friend class asio_client;
 public:
-    asio_connection(boost::asio::io_service& io_service, bool use_ssl) :
+    asio_connection(boost::asio::io_service& io_service, bool use_ssl, const std::function<void(boost::asio::ssl::context&)>& ssl_context_callback) :
     m_socket(io_service),
     m_pool_timer(io_service),
     m_is_reused(false),
     m_keep_alive(true)
     {
         if (use_ssl)
         {
-            boost::asio::ssl::context sslContext(boost::asio::ssl::context::sslv23);
-            sslContext.set_default_verify_paths();
-            sslContext.set_options(boost::asio::ssl::context::default_workarounds);
-            m_ssl_stream = utility::details::make_unique<boost::asio::ssl::stream<boost::asio::ip::tcp::socket &>>(m_socket, sslContext);
+            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);
+            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);
 
         }
     }
@@ -221,10 +222,11 @@ class asio_connection_pool
 {
 public:
 
-    asio_connection_pool(boost::asio::io_service& io_service, bool use_ssl, const std::chrono::seconds &idle_timeout) :
+    asio_connection_pool(boost::asio::io_service& io_service, bool use_ssl, const std::chrono::seconds &idle_timeout, const std::function<void(boost::asio::ssl::context&)> &ssl_context_callback) :
     m_io_service(io_service),
     m_timeout_secs(static_cast<int>(idle_timeout.count())),
-    m_use_ssl(use_ssl)
+    m_use_ssl(use_ssl),
+    m_ssl_context_callback(ssl_context_callback)
     {}
 
     ~asio_connection_pool()
@@ -260,7 +262,7 @@ class asio_connection_pool
             lock.unlock();
 
             // No connections in pool => create a new connection instance.
-            return std::make_shared<asio_connection>(m_io_service, m_use_ssl);
+            return std::make_shared<asio_connection>(m_io_service, m_use_ssl, m_ssl_context_callback);
         }
         else
         {
@@ -297,6 +299,7 @@ class asio_connection_pool
     boost::asio::io_service& m_io_service;
     const int m_timeout_secs;
     const bool m_use_ssl;
+    const std::function<void(boost::asio::ssl::context&)>& m_ssl_context_callback;
     std::vector<std::shared_ptr<asio_connection> > m_connections;
     std::mutex m_connections_mutex;
 };
@@ -308,7 +311,8 @@ class asio_client : public _http_client_communicator, public std::enable_shared_
     : _http_client_communicator(std::move(address), std::move(client_config))
     , m_pool(crossplat::threadpool::shared_instance().service(),
              base_uri().scheme() == "https",
-             std::chrono::seconds(30)) // Unused sockets are kept in pool for 30 seconds.
+             std::chrono::seconds(30), // Unused sockets are kept in pool for 30 seconds.
+             this->client_config().get_ssl_context_callback()) 
     , m_resolver(crossplat::threadpool::shared_instance().service())
     {}
 
diff --git a/Release/src/http/listener/http_listener.cpp b/Release/src/http/listener/http_listener.cpp
@@ -41,23 +41,11 @@ static void check_listener_uri(const http::uri &address)
     // Some things like proper URI schema are verified by the URI class.
     // We only need to check certain things specific to HTTP.
 
-#ifdef _WIN32
     //HTTP Server API includes SSL support
     if(address.scheme() != U("http") && address.scheme() != U("https"))
     {
         throw std::invalid_argument("URI scheme must be 'http' or 'https'");
     }
-#else
-    if(address.scheme() == U("https"))
-    {
-        throw std::invalid_argument("Listeners using 'https' are not yet supported");
-    }
-
-    if(address.scheme() != U("http"))
-    {
-        throw std::invalid_argument("URI scheme must be 'http'");
-    }
-#endif
 
     if(address.host().empty())
     {
diff --git a/Release/src/http/listener/http_server_asio.cpp b/Release/src/http/listener/http_server_asio.cpp
diff --git a/Release/tests/functional/http/client/client_construction.cpp b/Release/tests/functional/http/client/client_construction.cpp
diff --git a/Release/tests/functional/http/listener/listener_construction_tests.cpp b/Release/tests/functional/http/listener/listener_construction_tests.cpp
