bye felicia (nghttp2/wslay)

Author: dr7ana

.clang-format

@@ -66,20 +66,22 @@ IncludeBlocks: Regroup
 IncludeCategories:
   - Regex: '".+\.h'
     Priority: 2
-  - Regex: '^<(event2|ngtcp2)'
+  - Regex: '^<wshttp'
     Priority: 3
-  - Regex: '<winsock2\.h>'
+  - Regex: '^<(event2|ngtcp2)'
     Priority: 4
-  - Regex: '<windows\.h>'
+  - Regex: '<winsock2\.h>'
     Priority: 5
-  - Regex: '^<CLI'
+  - Regex: '<windows\.h>'
     Priority: 6
-  - Regex: '^<catch2'
+  - Regex: '^<CLI'
     Priority: 7
-  - Regex: '^<.*\.h(pp)?>$'
+  - Regex: '^<catch2'
     Priority: 8
-  - Regex: '(<)(.)+(>)'
+  - Regex: '^<.*\.h(pp)?>$'
     Priority: 9
+  - Regex: '(<)(.)+(>)'
+    Priority: 10
 
 # spacing
 SpaceBeforeParens: ControlStatements

.gitmodules

@@ -1,9 +1,3 @@
-[submodule "external/nghttp2"]
-	path = external/nghttp2
-	url = https://github.com/nghttp2/nghttp2.git
-[submodule "external/wslay"]
-	path = external/wslay
-	url = https://github.com/tatsuhiro-t/wslay.git
 [submodule "external/spdlog"]
 	path = external/spdlog
 	url = https://github.com/gabime/spdlog.git

external/CMakeLists.txt

@@ -4,29 +4,11 @@ find_package(Git)
 if(GIT_FOUND)
     message(STATUS "Checking submodules")
     include(check_submodule)
+    check_submodule(ada)
     check_submodule(libevent)
-    check_submodule(nghttp2)
     check_submodule(spdlog)
-    check_submodule(wslay)
 endif()
 
-# nghttp2
-set(WITH_NEVERBLEED OFF CACHE BOOL "" FORCE)
-set(WITH_MRUBY OFF CACHE BOOL "" FORCE)
-set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
-set(BUILD_STATIC_LIBS ON CACHE BOOL "" FORCE)
-set(ENABLE_DOC OFF CACHE BOOL "" FORCE)
-set(ENABLE_HTTP3 OFF CACHE BOOL "" FORCE)
-set(ENABLE_LIB_ONLY ON CACHE BOOL "" FORCE) # toggles off ENABLE_APP and ENABLE_EXAMPLES
-add_subdirectory(nghttp2 EXCLUDE_FROM_ALL)
-
-# wslay
-set(WSLAY_CONFIGURE_INSTALL OFF CACHE BOOL "" FORCE)
-set(WSLAY_STATIC ON CACHE BOOL "" FORCE)
-set(WSLAY_SHARED OFF CACHE BOOL "" FORCE)
-add_subdirectory(wslay EXCLUDE_FROM_ALL)
-add_library(wslay::wslay ALIAS wslay)
-
 # spdlog
 set(SPDLOG_FMT_EXTERNAL_HO ON CACHE BOOL "" FORCE)
 add_subdirectory(spdlog EXCLUDE_FROM_ALL)

external/nghttp2

@@ -8,8 +8,6 @@
 #include "wshttp/listener.hpp"
 #include "wshttp/loop.hpp"
 #include "wshttp/request.hpp"
-#include "wshttp/session.hpp"
 #include "wshttp/ssl.hpp"
-#include "wshttp/stream.hpp"
 #include "wshttp/types.hpp"
 #include "wshttp/utils.hpp"

external/wslay

@@ -172,7 +172,7 @@ namespace wshttp
     {
         constexpr ip_address(uint16_t p = 0) : _ip{}, _port{p} {}
 
-        explicit ip_address(struct sockaddr* in);
+        explicit ip_address(const struct sockaddr* in);
 
         template <ip_type T>
         constexpr explicit ip_address(T v4, uint16_t p) : _ip{v4}, _port{p}

include/wshttp.hpp

@@ -1,15 +1,17 @@
 #pragma once
 
+#include "address.hpp"
 #include "dns.hpp"
 #include "format.hpp"
 #include "loop.hpp"
-#include "session.hpp"
+#include "request.hpp"
 
 namespace wshttp
 {
     using namespace wshttp::literals;
 
     struct ssl_creds;
+    class listener;
 
     namespace dns
     {
@@ -71,7 +73,7 @@ namespace wshttp
         std::unordered_map<uint16_t, std::shared_ptr<listener>> _listeners{};
 
         // sessions managing outbound https connections
-        std::unordered_map<domain_host, std::shared_ptr<outbound_node>> _outbounds{};
+        // std::unordered_map<domain_host, std::shared_ptr<outbound_node>> _outbounds{};
 
         std::atomic<bool> _close_immediately{false};
 
@@ -94,35 +96,37 @@ namespace wshttp
             });
         }
 
-        template <typename... Opt>
-        bool connect(std::string_view url, Opt&&... opts)
-        {
-            return call_get([&]() {
-                auto _uri = uri::parse(url);
-                if (not _uri)
-                    throw std::invalid_argument{"Failed to parse input url: {}"_format(url)};
+        // template <typename... Opt>
+        // bool connect(std::string_view url, Opt&&... opts)
+        // {
+        //     return call_get([&]() {
+        //         auto _uri = uri::parse(url);
+        //         if (not _uri)
+        //             throw std::invalid_argument{"Failed to parse input url: {}"_format(url)};
 
-                auto [itr, b] = _outbounds.try_emplace(_uri.host_url(), nullptr);
+        //         auto [itr, b] = _outbounds.try_emplace(_uri.host_url(), nullptr);
 
-                if (not b)
-                    throw std::invalid_argument{
-                            "Cannot create outbound node for input: {} -- node already exists!"_format(url)};
+        //         if (not b)
+        //             throw std::invalid_argument{
+        //                     "Cannot create outbound node for input: {} -- node already exists!"_format(url)};
 
-                itr->second = make_shared<outbound_node>(*this, std::move(_uri), std::forward<Opt>(opts)...);
+        //         itr->second = make_shared<outbound_node>(*this, std::move(_uri), std::forward<Opt>(opts)...);
 
-                if (not itr->second)
-                    throw std::runtime_error{"Node construction is fucked"};
+        //         if (not itr->second)
+        //             throw std::runtime_error{"Node construction is fucked"};
 
-                return true;
-            });
-        }
+        //         return true;
+        //     });
+        // }
 
         void test_parse_method(std::string url);
 
         const std::shared_ptr<event_loop>& loop() { return _loop; }
 
         void set_shutdown_immediate(bool b = true) { _close_immediately = b; }
 
+        bool in_event_loop() const { return _loop->in_event_loop(); }
+
       protected:
         template <typename T, typename Callable>
         std::shared_ptr<T> shared_ptr(T* obj, Callable&& deleter)
@@ -136,17 +140,18 @@ namespace wshttp
             return _loop->template make_shared<T>(std::forward<Args>(args)...);
         }
 
-        void close_node(domain_host d);
         void close_listener(uint16_t p);
 
-        bool in_event_loop() const { return _loop->in_event_loop(); }
-
         void shutdown_endpoint();
 
         SSL_CTX* inbound_ctx();
 
         SSL_CTX* outbound_ctx();
 
+        struct event_base* ev_base() { return loop()->loop().get(); }
+
+        struct evhttp* make_evhttp();
+
       private:
         void handle_ep_opt(std::shared_ptr<ssl_creds> c);
 

include/wshttp/address.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "address.hpp"
+#include "loop.hpp"
 #include "ssl.hpp"
 
 extern "C" {
@@ -19,23 +20,29 @@ namespace wshttp
       public:
         local_node(ip_address l) : _local{std::move(l)} {}
 
-        virtual SSL* new_ssl() = 0;
+        virtual bufferevent* new_nev() = 0;
         virtual void close() = 0;
     };
 
     class app_context;
     class endpoint;
-    class inbound_session;
+    struct inbound_request;
 
     namespace deleters
     {
         struct _evconnlistener
         {
             inline void operator()(::evconnlistener* e) const { ::evconnlistener_free(e); }
         };
+
+        struct _evhttp
+        {
+            inline void operator()(::evhttp* e) const { return evhttp_free(e); }
+        };
     }  // namespace deleters
 
     using tcp_listener = std::shared_ptr<evconnlistener>;
+    using evhttp_ptr = std::unique_ptr<::evhttp, deleters::_evhttp>;
 
     class listener
     {
@@ -44,7 +51,7 @@ namespace wshttp
         friend class event_loop;
         friend struct listen_callbacks;
 
-        explicit listener(endpoint& e, uint16_t p) : _ep{e}, _local{p} { _init_internals(); }
+        explicit listener(endpoint& e, uint16_t p);
 
       public:
         listener() = delete;
@@ -56,14 +63,19 @@ namespace wshttp
         ip_address _local{};
         int _fd{-1};
 
-        tcp_listener _tcp;
+        // tcp_listener _tcp;
+        evhttp_ptr _evh;
 
         // key: remote address, value: session ptr
-        std::unordered_map<ip_address, std::shared_ptr<inbound_session>> _sessions;
+        std::unordered_map<ip_address, std::shared_ptr<inbound_request>> _sessions;
 
-        void _init_internals();
+        // void _init_internals();
 
       protected:
+        int accept_request(struct evhttp_request* req);
+
+        bufferevent* new_bev();
+
         SSL* new_ssl();
 
         void close_all();

include/wshttp/endpoint.hpp

@@ -16,10 +16,6 @@ extern "C" {
 
 namespace wshttp
 {
-    using Job = std::function<void()>;
-    using loop_ptr = std::shared_ptr<::event_base>;
-    using caller_id_t = uint16_t;
-
     class event_loop;
 
     namespace deleters
@@ -30,7 +26,10 @@ namespace wshttp
         };
     }  // namespace deleters
 
+    using Job = std::function<void()>;
+    using loop_ptr = std::shared_ptr<::event_base>;
     using event_ptr = std::unique_ptr<::event, deleters::_event>;
+    using caller_id_t = uint16_t;
 
     struct ev_watcher
     {