Implement sending plain data over tls socket before handshake.

uralm1 · uralm1 · commit 048340917a32 · 2023-08-29T14:07:25.000+05:00
diff --git a/include/restc-cpp/url_encode.h b/include/restc-cpp/url_encode.h
@@ -1,8 +1,5 @@
 #pragma once
 
-#ifndef RESTC_CPP_URL_ENCODE_H_
-#define RESTC_CPP_URL_ENCODE_H_
-
 #include "restc-cpp.h"
 
 #include <boost/utility/string_view.hpp>
@@ -13,4 +10,3 @@ std::string url_encode(const boost::string_view& src);
 
 } // namespace
 
-#endif // RESTC_CPP_URL_ENCODE_H_
diff --git a/src/ConnectionPoolImpl.cpp b/src/ConnectionPoolImpl.cpp
@@ -365,7 +365,9 @@ class ConnectionPoolImpl
         }
         else {
 #ifdef RESTC_CPP_WITH_TLS
-            socket = make_unique<TlsSocketImpl>(owner_.GetIoService(), owner_.GetTLSContext());
+            socket = make_unique<TlsSocketImpl>(owner_.GetIoService(), owner_.GetTLSContext(),
+                /*can_send_over_unupgraded_socket to send plain data over tls socket before handshake*/
+                properties_->proxy.type == Request::Proxy::Type::HTTPS);
 #else
             throw NotImplementedException(
                 "restc_cpp is compiled without TLS support");
diff --git a/src/RequestImpl.cpp b/src/RequestImpl.cpp
@@ -327,6 +327,10 @@ void DoProxyConnect(const Connection::ptr_t& connection,
 
             //sets status_code, reason_phrase in response
             stream->ReadServerResponse(proxy_response);
+            stream->ReadHeaderLines(
+                [](std::string&& name, std::string&& value) {
+                    RESTC_CPP_LOG_TRACE_("Read proxy header: " << name);
+            });
 
         } catch (const exception& ex) {
             RESTC_CPP_LOG_DEBUG_("DoProxyConnect: exception from ReceivingFromProxy: " << ex.what());
@@ -614,8 +618,8 @@ class RequestImpl : public Request {
         return request_buffer.str();
     }
 
-    //returns {protocol_type, host, service} instead of deprecated ip::resolver::query
-    tuple<Connection::Type, string, string> GetRequestEndpoint() {
+    //returns {host, service} instead of deprecated ip::resolver::query
+    tuple<string, string> GetRequestEndpoint() {
         const auto proxy_type = properties_->proxy.type;
 
         if (proxy_type == Request::Proxy::Type::SOCKS5) {
@@ -627,11 +631,7 @@ class RequestImpl : public Request {
                                  << " Proxy at: "
                                  << host << ':' << port);
 
-            // what connection type should we use for SOCKS tunnel?
-            return { (parsed_url_.GetProtocol() == Url::Protocol::HTTPS)
-                       ? Connection::Type::HTTPS
-                       : Connection::Type::HTTP,
-                      host, to_string(port) };
+            return { host, to_string(port) };
         }
 
         if ( (proxy_type == Request::Proxy::Type::HTTP &&
@@ -645,17 +645,11 @@ class RequestImpl : public Request {
                                  << " Proxy at: "
                                  << proxy.GetHost() << ':' << proxy.GetPort());
 
-            return { (proxy.GetProtocol() == Url::Protocol::HTTPS)
-                       ? Connection::Type::HTTPS
-                       : Connection::Type::HTTP,
-                     proxy.GetHost().to_string(),
+            return { proxy.GetHost().to_string(),
                      proxy.GetPort().to_string() };
         }
 
-        return { (parsed_url_.GetProtocol() == Url::Protocol::HTTPS)
-                   ? Connection::Type::HTTPS
-                   : Connection::Type::HTTP,
-                 parsed_url_.GetHost().to_string(),
+        return { parsed_url_.GetHost().to_string(),
                  parsed_url_.GetPort().to_string() };
     }
 
@@ -756,15 +750,21 @@ class RequestImpl : public Request {
 
         auto prot_filter = GetBindProtocols(properties_->bindToLocalAddress, ctx);
 
+        const Connection::Type protocol_type =
+            (parsed_url_.GetProtocol() == Url::Protocol::HTTPS ||
+             properties_->proxy.type == Request::Proxy::Type::HTTPS)
+            ? Connection::Type::HTTPS
+            : Connection::Type::HTTP;
+
         boost::asio::ip::tcp::resolver resolver(owner_.GetIoService());
         // Resolve the hostname
-        const auto ep_tuple = GetRequestEndpoint(); //{protocol_type, host, service=port}
+        const auto ep_tuple = GetRequestEndpoint(); //{host, service=port}
 
-        RESTC_CPP_LOG_TRACE_("Resolving " << get<1>(ep_tuple) << ":"
-            << get<2>(ep_tuple));
+        RESTC_CPP_LOG_TRACE_("Resolving " << get<0>(ep_tuple) << ":"
+            << get<1>(ep_tuple));
 
-        auto address_it = resolver.async_resolve(/*host*/ get<1>(ep_tuple),
-                                                 /*port*/ get<2>(ep_tuple),
+        auto address_it = resolver.async_resolve(/*host*/ get<0>(ep_tuple),
+                                                 /*port*/ get<1>(ep_tuple),
                                                  ctx.GetYield());
         const decltype(address_it) addr_end;
 
@@ -781,7 +781,7 @@ class RequestImpl : public Request {
             for(size_t retries = 0; retries < 8; ++retries) {
                 // Get a connection from the pool
                 auto connection = owner_.GetConnectionPool()->GetConnection(
-                    endpoint, /*protocol_type*/ get<0>(ep_tuple));
+                    endpoint, protocol_type);
 
                 // Connect if the connection is new.
                 if (connection->GetSocket().IsOpen()) {
diff --git a/src/SocketImpl.h b/src/SocketImpl.h
@@ -56,7 +56,7 @@ class SocketImpl : public Socket, protected ExceptionWrapper {
     }
 
     void AsyncConnect(const boost::asio::ip::tcp::endpoint& ep,
-					const std::string &host,
+                    const std::string &host,
                     bool tcpNodelay,
                     boost::asio::yield_context& yield) override {
         return WrapException<void>([&] {
diff --git a/src/TlsSocketImpl.h b/src/TlsSocketImpl.h
@@ -24,9 +24,12 @@ class TlsSocketImpl : public Socket, protected ExceptionWrapper {
 
     using ssl_socket_t = boost::asio::ssl::stream<boost::asio::ip::tcp::socket>;
 
-    TlsSocketImpl(boost::asio::io_service& io_service, shared_ptr<boost::asio::ssl::context> ctx)
+    TlsSocketImpl(boost::asio::io_service& io_service,
+            shared_ptr<boost::asio::ssl::context> ctx,
+            bool can_send_over_unupgraded_socket = false)
     {
         ssl_socket_ = std::make_unique<ssl_socket_t>(io_service, *ctx);
+        can_send_over_unupgraded_socket_ = can_send_over_unupgraded_socket;
     }
 
     boost::asio::ip::tcp::socket& GetSocket() override {
@@ -42,26 +45,36 @@ class TlsSocketImpl : public Socket, protected ExceptionWrapper {
     std::size_t AsyncReadSome(boost::asio::mutable_buffers_1 buffers,
                               boost::asio::yield_context& yield) override {
         return WrapException<std::size_t>([&] {
+            if (can_send_over_unupgraded_socket_)
+                return ssl_socket_->next_layer().async_read_some(buffers, yield);
             return ssl_socket_->async_read_some(buffers, yield);
         });
     }
 
     std::size_t AsyncRead(boost::asio::mutable_buffers_1 buffers,
                           boost::asio::yield_context& yield) override {
         return WrapException<std::size_t>([&] {
+            if (can_send_over_unupgraded_socket_)
+                return boost::asio::async_read(ssl_socket_->next_layer(), buffers, yield);
             return boost::asio::async_read(*ssl_socket_, buffers, yield);
         });
     }
 
     void AsyncWrite(const boost::asio::const_buffers_1& buffers,
                     boost::asio::yield_context& yield) override {
-        boost::asio::async_write(*ssl_socket_, buffers, yield);
+        if (can_send_over_unupgraded_socket_)
+            boost::asio::async_write(ssl_socket_->next_layer(), buffers, yield);
+        else
+            boost::asio::async_write(*ssl_socket_, buffers, yield);
     }
 
     void AsyncWrite(const write_buffers_t& buffers,
                     boost::asio::yield_context& yield) override {
         return WrapException<void>([&] {
-            boost::asio::async_write(*ssl_socket_, buffers, yield);
+            if (can_send_over_unupgraded_socket_)
+                boost::asio::async_write(ssl_socket_->next_layer(), buffers, yield);
+            else
+                boost::asio::async_write(*ssl_socket_, buffers, yield);
         });
     }
 
@@ -90,6 +103,7 @@ class TlsSocketImpl : public Socket, protected ExceptionWrapper {
             RESTC_CPP_LOG_TRACE_("AsyncConnect - Calling async_handshake");
             ssl_socket_->async_handshake(boost::asio::ssl::stream_base::client,
                                          yield);
+            can_send_over_unupgraded_socket_ = false;
 
             RESTC_CPP_LOG_TRACE_("AsyncConnect - Done");
         });
@@ -135,6 +149,7 @@ class TlsSocketImpl : public Socket, protected ExceptionWrapper {
 
 private:
     std::unique_ptr<ssl_socket_t> ssl_socket_;
+    bool can_send_over_unupgraded_socket_;
 };
 
 } // restc_cpp

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ class SocketImpl : public Socket, protected ExceptionWrapper {`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`void AsyncConnect(const boost::asio::ip::tcp::endpoint& ep,`
`59`		`- const std::string &host,`
	`59`	`+ const std::string &host,`
`60`	`60`	`bool tcpNodelay,`
`61`	`61`	`boost::asio::yield_context& yield) override {`
`62`	`62`	`return WrapException<void>([&] {`