broken ssl

lib/anthracite.cpp

@@ -11,6 +11,8 @@
 #include <sys/socket.h>
 #include <thread>
 #include <unistd.h>
+#include "./socket/openssl_socket.hpp"
+#include <future>
 
 using namespace anthracite;
 
@@ -24,10 +26,10 @@ using std::chrono::duration_cast;
 using std::chrono::duration;
 using std::chrono::milliseconds;
 
-void handle_client(socket::anthracite_socket s, backends::backend& b, backends::file_backend& fb, std::mutex& thread_wait_mutex, std::condition_variable& thread_wait_condvar, int& active_threads)
+void handle_client(socket::anthracite_socket* s, backends::backend& b, backends::file_backend& fb, std::mutex& thread_wait_mutex, std::condition_variable& thread_wait_condvar, int& active_threads)
 {
     while (true) {
-        std::string raw_request = s.recv_message(http::HEADER_BYTES);
+        std::string raw_request = s->recv_message(http::HEADER_BYTES);
         
         // We're doing the start here even though it would ideally be done 
         // before the first line since if we leave the connection open for 
@@ -38,11 +40,11 @@ void handle_client(socket::anthracite_socket s, backends::backend& b, backends::
             break;
         }
 
-        http::request req(raw_request, s.get_client_ip());
+        http::request req(raw_request, s->get_client_ip());
         std::unique_ptr<http::response> resp = req.is_supported_version() ? b.handle_request(req) : fb.handle_error(http::status_codes::HTTP_VERSION_NOT_SUPPORTED);
         std::string header = resp->header_to_string();
-        s.send_message(header);
-        s.send_message(resp->content());
+        s->send_message(header);
+        s->send_message(resp->content());
 
         auto end = high_resolution_clock::now();
         auto ms_int = duration_cast<std::chrono::microseconds>(end-start);
@@ -53,7 +55,8 @@ void handle_client(socket::anthracite_socket s, backends::backend& b, backends::
             break;
         }
     }
-    s.close_conn();
+    s->close_conn();
+    delete s;
     {
         std::lock_guard<std::mutex> lock(thread_wait_mutex);
         active_threads--;
@@ -61,34 +64,60 @@ void handle_client(socket::anthracite_socket s, backends::backend& b, backends::
     thread_wait_condvar.notify_one();
 }
 
-int anthracite_main(int argc, char** argv, backends::backend& be)
-{
-    log::logger.initialize(log::LOG_LEVEL_INFO);
-    auto args = std::span(argv, size_t(argc));
-    int port_number = default_port;
+int listen_loop(int port_number, backends::backend& be, bool tls) {
+    socket::anthracite_socket* socket;
 
-    if (argc > 1) {
-        port_number = atoi(args[1]);
+    if (tls){
+        socket = new socket::openssl_socket(port_number);
+    } else {
+        socket = new socket::anthracite_socket(port_number);
     }
-    log::verbose << "Initializing Anthracite" << std::endl;
-    socket::anthracite_socket s(port_number);
-    backends::file_backend fb(argc > 2 ? args[2] : "./www");
-    log::verbose << "Initialization Complete" << std::endl;
-    log::info << "Listening for HTTP connections on port " << port_number << std::endl;
 
+    backends::file_backend fb("./www");
+    log::info << "Listening for " << (tls ? "HTTPS" : "HTTP" ) << " connections on port " << port_number << std::endl;
+     
     int active_threads = 0;
     std::mutex thread_wait_mutex;
     std::condition_variable thread_wait_condvar;
 
     while (true) {
-        s.wait_for_conn();
+        socket->wait_for_conn();
         std::unique_lock<std::mutex> lock(thread_wait_mutex);
         thread_wait_condvar.wait(lock, [active_threads] { return active_threads < max_worker_threads; });
         active_threads++;
-        std::thread(handle_client, s, std::ref(be), std::ref(fb), std::ref(thread_wait_mutex), std::ref(thread_wait_condvar), std::ref(active_threads)).detach();
+
+        socket::anthracite_socket* client_sock;
+    
+        if (tls){
+            client_sock = new socket::openssl_socket(*dynamic_cast<socket::openssl_socket*>(socket));
+        } else {
+            client_sock = new socket::anthracite_socket(*socket);
+        }
+
+        std::thread(handle_client, socket, std::ref(be), std::ref(fb), std::ref(thread_wait_mutex), std::ref(thread_wait_condvar), std::ref(active_threads)).detach();
     }
 
-    exit(0);
+    delete socket;
+}
+
+int anthracite_main(int argc, char** argv, backends::backend& be)
+{
+    log::logger.initialize(log::LOG_LEVEL_INFO);
+    auto args = std::span(argv, size_t(argc));
+
+    std::vector<std::thread> threads;
+
+    if (argc > 1) {
+        auto thread = std::thread(listen_loop, atoi(argv[1]), std::ref(be), false);
+        thread.detach();
+        threads.push_back(std::move(thread));
+    } if (argc > 2) {
+        auto thread = std::thread(listen_loop, atoi(argv[2]), std::ref(be), true);
+        thread.detach();
+        threads.push_back(std::move(thread));
+    }
+    std::promise<void>().get_future().wait();
+    return 0;
 }
 
 void log_request_and_response(http::request& req, std::unique_ptr<http::response>& resp, uint32_t micros)