First Running Version

.gitignore

@@ -0,0 +1,7 @@
+build/
+debug-build/
+release-build/
+cmake-build-debug/
+.idea/
+
+example/build

CMakeLists.txt

@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.23)
+project(VWeb)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUGSOFT")
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+set(SOURCE_FILES
+        Source/EPollManager.cpp
+        Source/RequestHandler.cpp
+        Source/Server.cpp
+        Source/SocketManager.cpp
+        Source/ThreadPool.cpp
+        Source/Router.cpp
+        Source/MiddleWare.cpp
+        Source/Route.cpp
+        Source/StringUtils.cpp
+        Source/Cookie.cpp
+        Source/Session.cpp
+        Source/Response.cpp)
+include_directories(${CMAKE_SOURCE_DIR}/)
+add_library(VWeb ${SOURCE_FILES})
+
+set(mode release)
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(mode debug)
+endif ()
+set(target_file ${CMAKE_SOURCE_DIR}/dist/libVWeb.${mode}.a)
+add_custom_command(TARGET VWeb POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:VWeb> ${target_file})

Source/Cookie.cpp

@@ -0,0 +1,107 @@
+#include "StringUtils.h"
+
+#include <VWeb.h>
+
+namespace VWeb {
+void Cookies::Remove(const std::string &name) {
+  if (Data.contains(name))
+    Data.erase(name);
+}
+bool Cookies::Has(const std::string &name) const { return Data.contains(name); }
+std::string Cookies::TransformToHeader() {
+  std::stringstream view{};
+  for (auto &cookie : Data) {
+    auto &realCookie = cookie.second;
+    if (!realCookie.IsOld && !realCookie.Name.empty() &&
+        !realCookie.Value.empty())
+      CookieToString(view, realCookie);
+  }
+  return view.str();
+}
+
+void Cookies::CreateCookieFromString(const std::string &data) {
+  auto params = String::Split(data, ";");
+  Cookie cookie{};
+  int i = 0;
+  for (auto &param : params) {
+    auto split = String::Split(param, "=");
+    if (split.size() == 1) {
+      // we have a bool parameter
+      if (split[0] == "HttpOnly")
+        cookie.HttpOnly = true;
+      else if (split[0] == "Secure")
+        cookie.Secure = true;
+    } else {
+      if (i == 0) {
+        cookie.Name = split[0];
+        cookie.Value = split[1];
+      } else {
+        if (split[0] == "SameSite") {
+          if (split[1] == "None")
+            cookie.SameSite = CookieSameSite::None;
+          else if (split[1] == "Lax")
+            cookie.SameSite = CookieSameSite::Lax;
+          else if (split[1] == "Strict")
+            cookie.SameSite = CookieSameSite::Strict;
+        } else if (split[0] == "Path")
+          cookie.Path = split[1];
+        else if (split[0] == "Domain")
+          cookie.Domain = split[1];
+        else if (split[0] == "Max-Age")
+          cookie.MaxAge = String::ToNumber(split[1], 0);
+        else if (split[0] == "Expires")
+          cookie.Expires = split[1];
+      }
+    }
+    i++;
+  }
+  if (!cookie.Name.empty() && !cookie.Value.empty())
+    Data[cookie.Name] = std::move(cookie);
+}
+
+void Cookies::CreateOld(const std::string &name, const std::string &value) {
+  auto& cookie = Data[name];
+  cookie.Name = name;
+  cookie.Value = value;
+  cookie.IsOld = true;
+}
+
+void Cookies::CookieToString(std::stringstream &stream, Cookie &cookie) {
+  if (cookie.Name.empty() || cookie.Value.empty())
+    return;
+  std::stringstream view{};
+  // Cookie names that are starting with __Secure or __Host are Secure only
+  // Cookies!
+  if (cookie.Name.starts_with("__Secure"))
+    cookie.Secure = true;
+  if (cookie.Name.starts_with("__Host")) {
+    cookie.Secure = true;
+    if (cookie.Path.empty())
+      cookie.Path = "/";
+  }
+  view << "Set-Cookie: " << cookie.Name << "=" << cookie.Value;
+  if (!cookie.Expires.empty())
+    view << "; Expires=" << cookie.Expires;
+  if (cookie.MaxAge)
+    view << "; Max-Age=" << cookie.MaxAge;
+  if (!cookie.Domain.empty())
+    view << "; Domain=" << cookie.Domain;
+  if (!cookie.Path.empty())
+    view << "; Path=" << cookie.Path;
+  if (cookie.Secure || cookie.SameSite == CookieSameSite::None)
+    view << "; Secure";
+  if (cookie.HttpOnly)
+    view << "; HttpOnly";
+  if (cookie.SameSite != CookieSameSite::Invalid) {
+    std::string sameSiteValue;
+    switch (cookie.SameSite) {
+    case CookieSameSite::None: sameSiteValue = "None"; break;
+    case CookieSameSite::Strict: sameSiteValue = "Strict"; break;
+    case CookieSameSite::Lax: sameSiteValue = "Lax"; break;
+    default: break;
+    }
+    view << "; SameSite=" << sameSiteValue;
+  }
+  view << "\n";
+}
+} // namespace VWeb

Source/EPollManager.cpp

@@ -0,0 +1,35 @@
+#include <VWeb.h>
+namespace VWeb {
+EPollManager::EPollManager() {
+  m_EpollID = epoll_create1(0);
+  if (m_EpollID < 0)
+    exit(49);
+  unsigned int flags = fcntl(m_EpollID, F_GETFL, 0);
+  flags |= O_NONBLOCK;
+  fcntl(m_EpollID, F_SETFL, flags);
+}
+
+EPollManager::~EPollManager() { close(m_EpollID); }
+
+bool EPollManager::Dispatch(int sock, uint32_t eventType) const {
+  struct epoll_event event {
+    0
+  };
+  event.data.fd = sock;
+  event.events = eventType;
+  return epoll_ctl(m_EpollID, EPOLL_CTL_ADD, sock, &event) != -1;
+}
+
+bool EPollManager::UpdateEvents(int sock, uint32_t eventType) const {
+  struct epoll_event event {
+    0
+  };
+  event.data.fd = sock;
+  event.events = eventType;
+  return epoll_ctl(m_EpollID, EPOLL_CTL_MOD, sock, &event) != -1;
+}
+
+int EPollManager::Wait(int maxEvents, epoll_event *events) const {
+  return epoll_wait(m_EpollID, events, maxEvents, 10);
+}
+} // namespace VWeb

Source/MiddleWare.cpp

@@ -0,0 +1,33 @@
+#include <VWeb.h>
+
+namespace VWeb {
+void MiddleWareHandler::HandlePre(Ref<Request> &request) {
+  for (auto &[key, middleWare] : m_MiddleWares) {
+    middleWare->PreHandle(*request);
+  }
+}
+void MiddleWareHandler::HandlePost(Ref<Request> &request,
+                                   Ref<Response> &response) {
+  for (auto &[key, middleWare] : m_MiddleWares) {
+    middleWare->PostHandle(*request, *response);
+  }
+}
+void MiddleWareHandler::Shutdown(Ref<Request> &request,
+                                 Ref<Response> &response) {
+  for (auto &[key, middleWare] : m_MiddleWares) {
+    middleWare->Shutdown(*request, *response);
+  }
+}
+Ref<MiddleWare> MiddleWareHandler::GetById(const char *id) {
+  return m_MiddleWares[id];
+}
+Ref<MiddleWare> MiddleWareHandler::SetById(const char *id,
+                                           const Ref<MiddleWare> &middleWare) {
+  m_MiddleWares[id] = middleWare;
+  return middleWare;
+}
+void MiddleWareHandler::RemoveById(const char *id) {
+  if (m_MiddleWares.contains(id))
+    m_MiddleWares.erase(id);
+}
+} // namespace VWeb

Source/RequestHandler.cpp

@@ -0,0 +1,99 @@
+#include "StringUtils.h"
+
+#include <VWeb.h>
+
+namespace VWeb {
+
+HttpMethod StringToHTTPMethod(std::string &method) {
+  static std::unordered_map<std::string, HttpMethod> s_StringToMethodMap{
+      {"get", HttpMethod::GET},         {"head", HttpMethod::HEAD},
+      {"options", HttpMethod::OPTIONS}, {"post", HttpMethod::POST},
+      {"put", HttpMethod::PUT},         {"patch", HttpMethod::PATCH},
+      {"delete", HttpMethod::DELETE},   {"fallback", HttpMethod::FALLBACK},
+  };
+  String::ToLowerCase(method);
+  if (s_StringToMethodMap.contains(method))
+    return s_StringToMethodMap[method];
+  return s_StringToMethodMap["fallback"];
+}
+
+bool ParseRequest(Ref<Request> &request) {
+  std::istringstream resp(request->Body);
+  std::string line;
+  std::string::size_type index;
+
+  while (std::getline(resp, line) && line != "\r") {
+    index = line.find(':', 0);
+    if (index != std::string::npos) {
+      auto key = line.substr(0, index);
+      String::Trim(key);
+      request->Header(key).Add(String::TrimCopy(line.substr(index + 1)));
+    } else if (line.find("HTTP")) {
+      auto headers = String::Split(line, " ");
+      if (headers.size() != 3)
+        return false;
+      request->Method = StringToHTTPMethod(headers[0]);
+      request->URI = String::UrlDecode(headers[1]);
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+struct RequestJob : public WorkerJob {
+  Ref<Request> MRequest{};
+  Ref<Router> MRouter{};
+  Ref<MiddleWareHandler> MMiddleWareHandler{};
+  RequestHandler *MRequestHandler{nullptr};
+
+  void Execute() override {
+    if (!ParseRequest(MRequest)) {
+      fprintf(stderr, "[Request] >> Request failed to parse\n");
+      SocketUtils::Close(MRequest->ID);
+      return;
+    }
+    MRequest->CookieData = CreateRef<Cookies>();
+    MRequest->SessionData = CreateRef<Session>();
+    MMiddleWareHandler->HandlePre(MRequest);
+    auto response = MRouter->HandleRoute(MRequest);
+    MMiddleWareHandler->HandlePost(MRequest, response);
+    auto content = response->GetResponse();
+    MRequestHandler->AddSendResponse(
+        {0, (ssize_t)content.size(), MRequest->ID, content});
+    MMiddleWareHandler->Shutdown(MRequest, response);
+  }
+};
+RequestHandler::RequestHandler(const Ref<SocketManager> &manager)
+    : m_SocketManager(manager), m_MiddleWare(CreateRef<MiddleWareHandler>()) {
+  m_MiddleWare = CreateRef<MiddleWareHandler>();
+}
+void RequestHandler::InitThreads(int count) {
+  m_Pool.SetThreadCount(count);
+  m_Pool.Create();
+}
+void RequestHandler::AddRequest(Ref<Request> &request) {
+  if (m_Router) {
+    auto job = CreateRef<RequestJob>();
+    job->MRequest = request;
+    job->MMiddleWareHandler = m_MiddleWare;
+    job->MRequestHandler = this;
+    job->MRouter = m_Router;
+    m_Pool.Dispatch(job);
+  }
+}
+void RequestHandler::Stop() {
+  m_Pool.Stop();
+}
+void RequestHandler::SetRouter(Ref<Router> &router) {
+  m_Router = router;
+}
+void RequestHandler::AddSendResponse(SendData sendData) {
+  auto id = sendData.SocketID;
+  m_Server->m_OutRequest.Add(id, sendData);
+  if (!m_SocketManager->SetSendListen(id)) {
+    SocketUtils::Close(id);
+    m_Server->m_OutRequest.Remove(id);
+  }
+}
+} // namespace VWeb

Source/Response.cpp

@@ -0,0 +1,112 @@
+#include <VWeb.h>
+
+namespace VWeb {
+// clang-format off
+static std::unordered_map<HttpStatusCode, std::string> s_HTTPCodeToString = {
+    {HttpStatusCode::Continue, "100 Continue"},
+    {HttpStatusCode::SwitchingProtocols, "101 Switching Protocols"},
+    {HttpStatusCode::Processing, "102 Processing"},
+    {HttpStatusCode::EarlyHints, "103 Early Hints"},
+    {HttpStatusCode::OK, "200 OK"},
+    {HttpStatusCode::Created, "201 Created"},
+    {HttpStatusCode::Accepted, "202 Accepted"},
+    {HttpStatusCode::NonAuthoritativeInformation,"203 Non-Authoritative Information"},
+    {HttpStatusCode::NoContent, "204 No Content"},
+    {HttpStatusCode::ResetContent, "205 Reset Content"},
+    {HttpStatusCode::PartialContent, "206 Partial Content"},
+    {HttpStatusCode::MultiStatus, "207 Multi-Status"},
+    {HttpStatusCode::AlreadyReported, "208 Already Reported"},
+    {HttpStatusCode::IMUsed, "226 IM Used"},
+    {HttpStatusCode::MultipleChoices, "300 Multiple Choices"},
+    {HttpStatusCode::MovedPermanently, "301 Moved Permanently"},
+    {HttpStatusCode::Found, "302 Found"},
+    {HttpStatusCode::SeeOther, "303 See Other"},
+    {HttpStatusCode::NotModified, "304 Not Modified"},
+    {HttpStatusCode::UseProxy, "305 Use Proxy"},
+    {HttpStatusCode::TemporaryRedirect, "307 Temporary Redirect"},
+    {HttpStatusCode::PermanentRedirect, "308 Permanent Redirect"},
+    {HttpStatusCode::BadRequest, "400 Bad Request"},
+    {HttpStatusCode::Unauthorized, "401 Unauthorized"},
+    {HttpStatusCode::PaymentRequired, "402 Payment Required"},
+    {HttpStatusCode::Forbidden, "403 Forbidden"},
+    {HttpStatusCode::NotFound, "404 Not Found"},
+    {HttpStatusCode::MethodNotAllowed, "405 Method Not Allowed"},
+    {HttpStatusCode::NotAcceptable, "406 Not Acceptable"},
+    {HttpStatusCode::ProxyAuthenticationRequired,"407 Proxy Authentication Required"},
+    {HttpStatusCode::RequestTimeout, "408 Request Timeout"},
+    {HttpStatusCode::Conflict, "409 Conflict"},
+    {HttpStatusCode::Gone, "410 Gone"},
+    {HttpStatusCode::LengthRequired, "411 Length Required"},
+    {HttpStatusCode::PreconditionFailed, "412 Precondition Failed"},
+    {HttpStatusCode::PayloadTooLarge, "413 Payload Too Large"},
+    {HttpStatusCode::URITooLong, "414 URI Too Long"},
+    {HttpStatusCode::UnsupportedMediaType, "415 Unsupported Media Type"},
+    {HttpStatusCode::RangeNotSatisfiable, "416 Range Not Satisfiable"},
+    {HttpStatusCode::ExpectationFailed, "417 Expectation Failed"},
+    {HttpStatusCode::ImATeapot, "418 I'm a teapot"},
+    {HttpStatusCode::UnprocessableEntity, "422 Unprocessable Entity"},
+    {HttpStatusCode::Locked, "423 Locked"},
+    {HttpStatusCode::FailedDependency, "424 Failed Dependency"},
+    {HttpStatusCode::UpgradeRequired, "426 Upgrade Required"},
+    {HttpStatusCode::PreconditionRequired, "428 Precondition Required"},
+    {HttpStatusCode::TooManyRequests, "429 Too Many Requests"},
+    {HttpStatusCode::RequestHeaderFieldsTooLarge,"431 Request Header Fields Too Large"},
+    {HttpStatusCode::UnavailableForLegalReasons,"451 Unavailable For Legal Reasons"},
+    {HttpStatusCode::InternalServerError, "500 Internal Server Error"},
+    {HttpStatusCode::NotImplemented, "501 Not Implemented"},
+    {HttpStatusCode::BadGateway, "502 Bad Gateway"},
+    {HttpStatusCode::ServiceUnavailable, "503 Service Unavailable"},
+    {HttpStatusCode::GatewayTimeout, "504 Gateway Time-out"},
+    {HttpStatusCode::HTTPVersionNotSupported, "505 HTTP Version Not Supported"},
+    {HttpStatusCode::VariantAlsoNegotiates, "506 Variant Also Negotiates"},
+    {HttpStatusCode::InsufficientStorage, "507 Insufficient Storage"},
+    {HttpStatusCode::LoopDetected, "508 Loop Detected"},
+    {HttpStatusCode::NotExtended, "510 Not Extended"},
+    {HttpStatusCode::NetworkAuthenticationRequired,"511 Network Authentication Required"}
+};
+// clang-format on
+std::string Response::GetResponse() {
+  std::string content = m_Content.str();
+  auto headData = TransformHeaders(content);
+
+  auto outContent = std::string(headData + content);
+  Length = content.length();
+  return outContent;
+}
+void Response::SetHeader(const std::string &key, const std::string &value) {
+  m_Headers[key].Set(value);
+}
+void Response::SetHeader(const std::string &key, ParameterValue &value) {
+  m_Headers[key] = value;
+}
+void Response::AddHeaders(const std::string &key,
+                          const Vector<std::string> &values) {
+  auto &element = m_Headers[key];
+  for (const auto &value : values)
+    element.Add(value);
+}
+void Response::AddHeader(const std::string &key, const std::string &value) {
+  m_Headers[key].Add(value);
+}
+void Response::SetType(const std::string &type) { m_Type = type; }
+void Response::AddContent(const std::string &data) { m_Content << data; }
+void Response::SetStatus(HttpStatusCode statusCode) { Status = statusCode; }
+void Response::SetMethod(HttpMethod method) { Method = method; }
+
+void Response::Reset() { m_Content.clear(); }
+
+std::string Response::TransformHeaders(const std::string &content) {
+  std::ostringstream stream;
+  stream << "HTTP/1.1 " << s_HTTPCodeToString[Status] << "\n";
+  stream << "content-type: " << m_Type << "\n";
+  stream << "content-length: " << content.length() << "\n";
+  for (auto &[key, value] : m_Headers) {
+    for (auto &val : value.Values()) {
+      stream << key << ": " << val << "\n";
+    }
+  }
+  stream << CookieData->TransformToHeader();
+  stream << "\n";
+  return stream.str();
+}
+} // namespace VWeb

Source/Route.cpp

@@ -0,0 +1,83 @@
+#include <VWeb.h>
+#include <algorithm>
+
+
+namespace VWeb {
+
+#define stringify(name) {name, std::string(#name).replace(0,12,"")}
+static std::unordered_map<HttpMethod, std::string> s_HttpMethodToString = {
+    stringify(HttpMethod::HEAD),
+    stringify(HttpMethod::GET),
+    stringify(HttpMethod::OPTIONS),
+    stringify(HttpMethod::POST),
+    stringify(HttpMethod::PUT),
+    stringify(HttpMethod::PATCH),
+    stringify(HttpMethod::DELETE),
+    stringify(HttpMethod::FALLBACK)
+};
+#undef stringify
+
+Route::Route(std::initializer_list<HttpMethod> methods) {
+  m_AllowedMethods = methods;
+  m_AllowAll = false;
+  m_AllowedMethods.push_back(HttpMethod::HEAD);
+  m_AllowedMethods.push_back(HttpMethod::OPTIONS);
+}
+bool Route::Execute(const Request &request, Response &response) {
+  switch (request.Method) {
+  case HttpMethod::GET:
+  case HttpMethod::HEAD: return Get(request, response);
+  case HttpMethod::POST: return Post(request, response);
+  case HttpMethod::PUT: return Put(request, response);
+  case HttpMethod::OPTIONS: return Options(request, response);
+  case HttpMethod::PATCH: return Patch(request, response);
+  case HttpMethod::DELETE: return Delete(request, response);
+  default: return Fallback(request, response);
+  }
+}
+bool Route::Get(const Request &request, Response &response) {
+  return true;
+}
+bool Route::Post(const Request &request, Response &response) {
+  return true;
+}
+bool Route::Put(const Request &request, Response &response) {
+  return true;
+}
+bool Route::Patch(const Request &request, Response &response) {
+  return true;
+}
+bool Route::Delete(const Request &request, Response &response) {
+  return true;
+}
+bool Route::Options(const Request &request, Response &response) {
+  std::stringstream str{};
+  bool isFirst = true;
+  if (m_AllowAll) {
+    for (auto &[key, value] : s_HttpMethodToString) {
+      if (!isFirst)
+        str << ", ";
+      str << value;
+      isFirst = false;
+    }
+  } else {
+    for (auto &method : m_AllowedMethods) {
+      if (!isFirst)
+        str << ", ";
+      str << s_HttpMethodToString[method];
+      isFirst = false;
+    }
+  }
+  response.SetHeader("Allow", str.str());
+  return true;
+}
+bool Route::Fallback(const Request &request, Response &response) {
+  return true;
+}
+bool Route::IsAllowed(const Request &request) { return true; }
+bool Route::SupportsMethod(const Request &request) {
+  return m_AllowAll ||
+         std::find(m_AllowedMethods.begin(), m_AllowedMethods.end(),
+                   request.Method) != m_AllowedMethods.end();
+}
+} // namespace VWeb

Source/Router.cpp

@@ -0,0 +1,97 @@
+#include "StringUtils.h"
+
+#include <VWeb.h>
+#include <type_traits>
+
+namespace VWeb {
+
+template <typename E> constexpr auto to_underlying(E e) noexcept {
+  return static_cast<std::underlying_type_t<E>>(e);
+}
+
+class ErrorRoute : public Route {
+public:
+  bool Execute(const Request &request, Response &response) override {
+    response.Reset();
+    response << "Unhandled Error: Status "
+             << std::to_string(to_underlying(response.Status));
+    response.SetType("text/plain");
+    return true;
+  }
+};
+
+Router::Router() { m_Routes["@"] = CreateRef<ErrorRoute>(); }
+
+void Router::AddRoute(const std::string &name, const Ref<Route> &route) {
+  m_Routes[name] = route;
+}
+
+Ref<Route> &Router::GetRoute(const std::string &name) { return m_Routes[name]; }
+
+void Router::DeleteRoute(const std::string &name) {
+  if (m_Routes.contains(name)) {
+    m_Routes.erase(name);
+  }
+}
+
+Ref<Response> Router::HandleRoute(Ref<Request> &request) {
+  auto response = CreateRef<Response>();
+  auto route = FindRoute(request);
+  response->CookieData = request->CookieData;
+  response->Method = request->Method;
+  if (!route) {
+    response->SetStatus(HttpStatusCode::NotFound);
+    m_Routes["@"]->Execute(*request, *response);
+    return response;
+  }
+
+  if (!route->IsAllowed(*request)) {
+    response->SetStatus(HttpStatusCode::Forbidden);
+    m_Routes["@"]->Execute(*request, *response);
+    return response;
+  }
+
+  if (!route->Execute(*request, *response)) {
+    std::string rKey = "@" + std::to_string(to_underlying(response->Status));
+    m_Routes.contains(rKey) ? m_Routes[rKey]->Execute(*request, *response)
+                            : m_Routes["@"]->Execute(*request, *response);
+  }
+  return response;
+}
+
+Ref<Route> Router::FindRoute(Ref<Request> &request) {
+  auto &url = request->URI;
+  if (m_Routes.contains(url.data())) {
+    auto &route = m_Routes.at(url.data());
+    if (route->SupportsMethod(*request))
+      return route;
+  }
+  if (url.starts_with("@"))
+    return nullptr;
+
+  auto split = String::Split(url.data(), "/");
+  if (split.size() > 1) {
+    AddToArgs(request, split);
+    while (split.size() > 1) {
+      std::string nUrl = String::Join(split, "/");
+      if (m_Routes.contains(nUrl)) {
+        auto &route = m_Routes[nUrl];
+        if (route->SupportsMethod(*request))
+          return route;
+      }
+      AddToArgs(request, split);
+    }
+  }
+  if (m_Routes.contains("/")) {
+    auto &route = m_Routes["/"];
+    if (route->SupportsMethod(*request))
+      return route;
+  }
+  return nullptr;
+}
+
+void Router::AddToArgs(Ref<Request> &request, Vector<std::string> &items) {
+  request->URLParameters.push_back(items[items.size() - 1]);
+  items.pop_back();
+}
+} // namespace VWeb

Source/Server.cpp

@@ -0,0 +1,135 @@
+#include <VWeb.h>
+#include <cstring>
+
+namespace VWeb {
+Server::Server() {
+  m_Router = CreateRef<Router>();
+  m_ServerConfig = CreateRef<ServerConfig>();
+  m_ServerConfig->EPoll = CreateRef<EPollManager>();
+  m_ServerConfig->Socket = CreateRef<SocketManager>(m_ServerConfig);
+  m_RequestHandler = CreateRef<RequestHandler>(m_ServerConfig->Socket);
+  m_RequestHandler->m_Server = this;
+};
+void Server::LoadSharedLibs() {
+  // @TODO: LOAD .so files inside sub-folder
+}
+void Server::Start() {
+  m_ServerConfig->Socket->Init();
+  if (m_ServerConfig->Socket->IsErrored())
+    return;
+  m_RequestHandler->SetRouter(m_Router);
+  m_RequestHandler->InitThreads(m_ServerConfig->WorkerThreads);
+  m_WorkerThread = CreateRef<std::thread>(&Server::Execute, this);
+  fprintf(stdout, "[VWeb] Running Server On: 0.0.0.0:%d\n",
+          m_ServerConfig->Port);
+}
+void Server::AddRoute(const std::string &path, const Ref<Route> &route) {
+  m_Router->AddRoute(path, route);
+}
+void Server::RemoveRoute(const std::string &path) {
+  m_Router->DeleteRoute(path);
+}
+void Server::Execute() {
+  constexpr size_t MAX_EVENTS = 5000;
+  struct epoll_event events[MAX_EVENTS];
+  int sockID = m_ServerConfig->Socket->ID();
+  for (;;) {
+    if (m_IsExit)
+      break;
+    int eventCount = m_ServerConfig->EPoll->Wait(MAX_EVENTS, events);
+    for (int i = 0; i < eventCount; ++i) {
+      auto &event = events[i];
+      if ((event.events & EPOLLERR) || (event.events & EPOLLHUP)) {
+        m_RawRequest.Remove(event.data.fd);
+        SocketUtils::Close(event.data.fd);
+        continue;
+      }
+      if (event.events & EPOLLOUT) {
+        OutgoingExecute(events[i]);
+      }
+      if (event.data.fd == sockID) {
+        IncomingExecute(event);
+      } else if (event.events & EPOLLIN) {
+        HandleRequestReading(event);
+      }
+    }
+  }
+}
+
+void Server::OutgoingExecute(epoll_event &event) {
+  if (!m_OutRequest.Has(event.data.fd)) {
+    m_ServerConfig->Socket->SetReadListen(event.data.fd);
+    return;
+  }
+  auto &sendData = m_OutRequest.Get(event.data.fd);
+  auto returnVal = SocketUtils::Write(sendData);
+  if (returnVal == WriteState::ERRORED || returnVal == WriteState::OK) {
+    SocketUtils::WriteDone(sendData.SocketID);
+    m_OutRequest.Remove(event.data.fd);
+  }
+}
+
+void Server::IncomingExecute(epoll_event &event) {
+  for (;;) {
+    auto req = m_ServerConfig->Socket->Handle();
+    if (req.ReturnValue == EPollReturns::BREAK ||
+        req.ReturnValue == EPollReturns::FAILURE)
+      break;
+    else if (req.ReturnValue == EPollReturns::OK) {
+      if (!m_RawRequest.Add(req.SockId, req))
+        SocketUtils::Close(req.SockId);
+    } else
+      continue;
+  }
+}
+void Server::HandleRequestReading(epoll_event &event) {
+  int fd = event.data.fd;
+  if (!m_RawRequest.Has(fd)) {
+    SocketUtils::Close(fd);
+    return;
+  }
+  auto &data = m_RawRequest.Get(fd);
+  char buf[m_ServerConfig->BufferSize];
+  bool isFinished = false;
+  for (;;) {
+    memset(buf, 0, sizeof(buf));
+    ssize_t nBytes = recv(fd, buf, m_ServerConfig->BufferSize, 0);
+    if (nBytes < 0) {
+      if (errno == EAGAIN || errno == EWOULDBLOCK) {
+        if (isFinished)
+          CreateRequest(fd);
+        break;
+      } else {
+        m_RawRequest.Remove(fd);
+        SocketUtils::Close(fd);
+        break;
+      }
+    } else if (nBytes == 0) {
+      m_RawRequest.Remove(fd);
+      SocketUtils::Close(fd);
+    } else {
+      if (m_ServerConfig->MaxBufferSize != -1 &&
+          data.CurrentBytes + nBytes > m_ServerConfig->MaxBufferSize) {
+        data.Data.clear();
+        data.Data << "GET @431 HTTP/1.1";
+        CreateRequest(fd);
+        break;
+      }
+      data.Data << buf;
+      data.CurrentBytes += nBytes;
+      if (nBytes < m_ServerConfig->BufferSize - 1) {
+        isFinished = true;
+        continue;
+      }
+    }
+  }
+}
+void Server::CreateRequest(int sockID) {
+  Accept &meAccept = m_RawRequest.Get(sockID);
+  auto request = CreateRef<Request>();
+  request->ID = meAccept.SockId;
+  request->Body = meAccept.Data.str();
+  m_RawRequest.Remove(sockID);
+  m_RequestHandler->AddRequest(request);
+}
+} // namespace VWeb

Source/Session.cpp

@@ -0,0 +1,20 @@
+#include <VWeb.h>
+
+namespace VWeb {
+bool Session::IsValid() {
+  auto call = std::chrono::system_clock::now();
+  auto time =
+      std::chrono::duration_cast<std::chrono::seconds>(call - m_LastCall)
+          .count();
+  return time < TTLSeconds;
+}
+
+void Session::Update() { m_LastCall = std::chrono::system_clock::now(); }
+
+void Session::Remove(const std::string &key) {
+  if (m_Data.contains(key))
+    m_Data.erase(key);
+}
+
+bool Session::Has(const std::string &key) { return m_Data.contains(key); }
+} // namespace VWeb

Source/SocketManager.cpp

@@ -0,0 +1,102 @@
+#include <VWeb.h>
+
+namespace VWeb {
+#pragma region VWebSocketUtils
+bool SocketUtils::MakeAsync(int socketId) {
+  int flags = fcntl(socketId, F_GETFL, 0);
+  if (flags == -1)
+    return false;
+  if (fcntl(socketId, F_SETFL, flags | O_NONBLOCK) == -1)
+    return false;
+  return true;
+}
+bool SocketUtils::Add(int socketId) { return MakeAsync(socketId); }
+bool SocketUtils::Close(int socketId) { return close(socketId) >= 0; }
+bool SocketUtils::WriteDone(int socketId) {
+  return shutdown(socketId, SHUT_WR) != -1;
+}
+WriteState SocketUtils::Write(VWeb::SendData &sendData) {
+  const char *buf = sendData.Content.c_str();
+  ssize_t n;
+  while (sendData.Size > 0) {
+    n = send(sendData.SocketID, buf + sendData.Offset, sendData.Size, 0);
+    if (n < 0) {
+      if (errno == EAGAIN || errno == EWOULDBLOCK)
+        return WriteState::EPOLL;
+      fprintf(stderr, "[SocketUtils::Write] >> Im Errored\n");
+      return WriteState::ERRORED;
+    }
+    sendData.Offset += n;
+    sendData.Size -= n;
+  }
+  return WriteState::OK;
+}
+#pragma endregion VWebSocketUtils
+
+#pragma region VWebSocketManager
+SocketManager::SocketManager(const Ref<VWeb::ServerConfig> &serverConfig)
+    : m_ServerConfig(serverConfig) {}
+SocketManager::~SocketManager() { close(m_SocketID); }
+Accept SocketManager::Handle() {
+  Accept requestReturn{};
+  int client =
+      accept(m_SocketID, (sockaddr *)&m_Address, (socklen_t *)&m_AddressLength);
+  if (client < 0) {
+    if (errno == EAGAIN || errno == EWOULDBLOCK)
+      requestReturn.ReturnValue = EPollReturns::BREAK;
+    else
+      requestReturn.ReturnValue = EPollReturns::FAILURE;
+  } else {
+    requestReturn.SockId = client;
+    requestReturn.ReturnValue = EPollReturns::FAILURE;
+    if (SocketUtils::Add(client) &&
+        m_ServerConfig->EPoll->Dispatch(client, EPOLLIN | EPOLLET)) {
+      requestReturn.ReturnValue = EPollReturns::OK;
+    } else {
+      SocketUtils::Close(client);
+    }
+  }
+  return requestReturn;
+}
+
+bool SocketManager::SetSendListen(int socketID) {
+  return m_ServerConfig->EPoll->UpdateEvents(socketID, EPOLLOUT | EPOLLET);
+}
+bool SocketManager::SetReadListen(int socketID) {
+  return m_ServerConfig->EPoll->UpdateEvents(socketID, EPOLLIN | EPOLLET);
+}
+void SocketManager::Init() {
+  if ((m_SocketID = socket(AF_INET, SOCK_STREAM, 0)) == 0)
+    return Errored("Cannot Create Socket");
+
+  auto trues = 1;
+  struct timeval tv {
+    1, 0
+  };
+  setsockopt(m_SocketID, SOL_SOCKET, SO_REUSEADDR, &trues, sizeof(int));
+  setsockopt(m_SocketID, SOL_SOCKET, SO_REUSEPORT, &trues, sizeof(int));
+  setsockopt(m_SocketID, SOL_SOCKET, SOCK_CLOEXEC, &trues, sizeof(int));
+  setsockopt(m_SocketID, SOL_SOCKET, SOCK_NONBLOCK, &trues, sizeof(int));
+  setsockopt(m_SocketID, SOL_SOCKET, SO_RCVTIMEO, (const char *)&tv, sizeof tv);
+
+  m_Address.sin_family = AF_INET;
+  m_Address.sin_addr.s_addr = htonl(INADDR_ANY);
+  m_Address.sin_port = htons(m_ServerConfig->Port);
+
+  if (bind(m_SocketID, (struct sockaddr *)&m_Address, m_AddressLength) < 0)
+    return Errored("Cannot Bind Socket");
+  SocketUtils::MakeAsync(m_SocketID);
+  if (listen(m_SocketID, SOMAXCONN) < 0)
+    return Errored("Socket Failed to Listen");
+
+  if (!m_ServerConfig->EPoll->Dispatch(m_SocketID,EPOLLIN | EPOLLET | EPOLLOUT))
+    return Errored("Cannot Add Event");
+}
+void SocketManager::Errored(const std::string &data) {
+  if (m_SocketID > 0)
+    close(m_SocketID);
+  fprintf(stderr, "%s\n", data.c_str());
+  m_IsErrored = true;
+}
+#pragma endregion VWebSocketManager
+} // namespace VWeb

Source/StringUtils.cpp

@@ -0,0 +1,86 @@
+#include "StringUtils.h"
+
+#include <algorithm>
+#include <sstream>
+
+namespace VWeb {
+
+static void StringLeftTrim(std::string &s) {
+  s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
+            return !std::isspace(ch);
+          }));
+}
+
+static void StringRightTrim(std::string &s) {
+  s.erase(std::find_if(s.rbegin(), s.rend(),
+                       [](unsigned char ch) { return !std::isspace(ch); })
+              .base(),
+          s.end());
+}
+
+std::vector<std::string> String::Split(const std::string &s,
+                                       const std::string &delimiter) {
+  size_t pos_start = 0, pos_end, delim_len = delimiter.length();
+  std::string token;
+  std::vector<std::string> res;
+
+  while ((pos_end = s.find(delimiter, pos_start)) != std::string::npos) {
+    token = s.substr(pos_start, pos_end - pos_start);
+    pos_start = pos_end + delim_len;
+    res.push_back(token);
+  }
+
+  res.push_back(s.substr(pos_start));
+  return res;
+}
+int String::ToNumber(std::string &string, int def) {
+  char *pEnd;
+  long val = std::strtol(string.c_str(), &pEnd, 10);
+  if (pEnd == string)
+    return def;
+  return (int)val;
+}
+
+std::string String::Join(const std::vector<std::string> &items,
+                         const std::string &delimiter) {
+  std::stringstream string;
+  for (size_t i = 0; i < items.size(); ++i) {
+    if (i != 0)
+      string << delimiter;
+    string << items[i];
+  }
+  return string.str();
+}
+
+void String::Trim(std::string &value) {
+  StringLeftTrim(value);
+  StringRightTrim(value);
+}
+std::string String::TrimCopy(const std::string &value) {
+  auto val = value;
+  Trim(val);
+  return val;
+}
+
+void String::ToLowerCase(std::string &value) {
+  std::transform(value.begin(), value.end(), value.begin(),
+                 [](unsigned char c) { return std::tolower(c); });
+}
+std::string String::UrlDecode(const std::string &val) {
+  std::string ret;
+  char ch;
+  size_t i;
+  unsigned int ii;
+  for (i = 0; i < val.length(); i++) {
+    if (int(val[i]) == 37) {
+      char *pEnd;
+      ii = std::strtoul(val.substr(i + 1, 2).c_str(), &pEnd, 16);
+      ch = static_cast<char>(ii);
+      ret += ch;
+      i = i + 2;
+    } else
+      ret += val[i];
+  }
+  return (ret);
+}
+} // namespace VWeb

Source/StringUtils.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <vector>
+#include <string>
+
+namespace VWeb {
+class String {
+public:
+  static std::vector<std::string> Split(const std::string& s,
+                                        const std::string& delimiter);
+  static std::string Join(const std::vector<std::string>& items, const std::string& delimiter);
+  static int ToNumber(std::string& string, int def);
+  static void ToLowerCase(std::string& value);
+  static void Trim(std::string& value);
+  static std::string TrimCopy(const std::string& value);
+  static std::string UrlDecode(const std::string& value);
+};
+}

Source/ThreadPool.cpp

@@ -0,0 +1,43 @@
+#include <VWeb.h>
+#include <thread>
+
+namespace VWeb {
+ThreadPool::ThreadPool(const std::string &name) : m_Name(name) {}
+void ThreadPool::Create() {
+  if (m_IsCreated)
+    return;
+  m_IsDone = false;
+  m_IsCreated = true;
+  m_Queue.Open();
+  for (int i = 0; i < m_ThreadCount; ++i) {
+    m_Threads.push_back(std::thread(&ThreadPool::Execute, this));
+  };
+  printf("[ThreadPool] >> Created %d Threads for Pool \"%s\"\n", m_ThreadCount, m_Name.c_str());
+}
+void ThreadPool::Stop() {
+  m_IsDone = true;
+  m_Queue.Flush();
+  for (int i = 0; i < m_ThreadCount; ++i)
+    m_Threads[i].join();
+}
+void ThreadPool::Dispatch(const Ref<WorkerJob> &job) { m_Queue.Push(job); }
+void ThreadPool::SetThreadCount(int count) {
+  if (m_IsCreated)
+    return;
+  m_ThreadCount =
+      count == -1 ? (int)std::thread::hardware_concurrency() : count;
+}
+
+void ThreadPool::Execute() {
+  if (!m_IsCreated)
+    return;
+  while (auto queueItem = m_Queue.WaitAndPop()) {
+    if (!queueItem.has_value() || m_Queue.IsClosed())
+      continue;
+    auto &item = queueItem.value();
+    if (item == nullptr)
+      continue;
+    item->Execute();
+  }
+}
+} // namespace VWeb

VWeb.h

@@ -0,0 +1,573 @@
+#pragma once
+
+#include <cassert>
+#include <condition_variable>
+#include <fcntl.h>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <netinet/in.h>
+#include <optional>
+#include <queue>
+#include <sstream>
+#include <sys/epoll.h>
+#include <sys/socket.h>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+namespace VWeb {
+
+template <typename T> using Ref = std::shared_ptr<T>;
+template <typename T> using Vector = std::vector<T>;
+template <typename T, typename... Args>
+constexpr Ref<T> CreateRef(Args &&...args) {
+  return std::make_shared<T>(std::forward<Args>(args)...);
+}
+typedef std::mutex Mutex;
+
+#pragma region SAFESTRUCTS
+template <typename T, typename S> struct SafeMap {
+  explicit SafeMap(size_t maxSize = -1UL) : m_MaxSize(maxSize), m_End(false){};
+  bool Add(const T &t, S &x) {
+    std::unique_lock<std::mutex> lck(m_Mutex);
+    while (m_Data.size() == m_MaxSize && !m_End)
+      return false;
+    assert(!m_End);
+    m_Data.emplace(t, std::move(x));
+    return true;
+  };
+  bool Add(T &&t, S &&x) {
+    std::unique_lock<std::mutex> lck(m_Mutex);
+    while (m_Data.size() == m_MaxSize && !m_End)
+      return false;
+    assert(!m_End);
+    m_Data.push(std::move(t));
+    return true;
+  };
+  void Remove(T t) {
+    std::unique_lock<std::mutex> lck(m_Mutex);
+    if (m_Data.empty() || m_End)
+      return;
+    if (m_Data.contains(t))
+      m_Data.erase(t);
+    m_CVFull.notify_one();
+  };
+  void Clear() {
+    std::unique_lock<std::mutex> lck(m_Mutex);
+    std::unordered_map<T, S> empty;
+    std::swap(m_Data, empty);
+    m_CVFull.notify_all();
+  };
+  bool Has(T t) {
+    std::unique_lock<std::mutex> lck(m_Mutex);
+    return m_Data.contains(t);
+  };
+  S &Get(T t) {
+    std::unique_lock<std::mutex> lck(m_Mutex);
+    return m_Data[t];
+  };
+  int Size() { return m_Data.size(); };
+
+private:
+  std::unordered_map<T, S> m_Data{};
+  std::mutex m_Mutex{};
+  std::condition_variable m_CVFull{};
+  const size_t m_MaxSize{};
+  std::atomic<bool> m_End{};
+};
+
+template <typename T> struct SafeQueue {
+  explicit SafeQueue(size_t maxSize = -1UL)
+      : m_MaxSize(maxSize),
+        m_End(false){};
+  void Push(const T &t) {
+    std::unique_lock<std::mutex> lck(m_Mutex);
+    while (m_Queue.size() == m_MaxSize && !m_End)
+      m_CVFull.wait(lck);
+    assert(!m_End);
+    m_Queue.push(std::move(t));
+    m_CVEmpty.notify_one();
+  };
+  void Push(T &&t) {
+    std::unique_lock<std::mutex> lck(m_Mutex);
+    while (m_Queue.size() == m_MaxSize && !m_End)
+      m_CVFull.wait(lck);
+    assert(!m_End);
+    m_Queue.push(std::move(t));
+    m_CVEmpty.notify_one();
+  };
+  void Open() {
+    m_End = false;
+    std::lock_guard<std::mutex> lck(m_Mutex);
+    m_CVEmpty.notify_all();
+    m_CVFull.notify_all();
+  };
+  void Close() {
+    m_End = true;
+    std::lock_guard<std::mutex> lck(m_Mutex);
+    m_CVEmpty.notify_all();
+    m_CVFull.notify_all();
+  };
+  void Clear() {
+    std::unique_lock<std::mutex> lck(m_Mutex);
+    std::queue<T> empty;
+    std::swap(m_Queue, empty);
+    m_CVEmpty.notify_all();
+    m_CVFull.notify_all();
+  };
+  std::optional<T> Pop() {
+    std::unique_lock<std::mutex> lck(m_Mutex);
+    if (m_Queue.empty() || m_End)
+      return {};
+    T t = std::move(m_Queue.front());
+    m_Queue.pop();
+    m_CVFull.notify_one();
+    return t;
+  };
+  std::optional<T> WaitAndPop() {
+    std::unique_lock<std::mutex> lck(m_Mutex);
+    while (m_Queue.empty() && !m_End)
+      m_CVEmpty.wait(lck);
+    if (m_Queue.empty() || m_End)
+      return {};
+    T t = std::move(m_Queue.front());
+    m_Queue.pop();
+    m_CVFull.notify_one();
+    return t;
+  };
+  bool IsClosed() { return m_End; }
+  int Size() { return m_Queue.size(); }
+  std::queue<T> &GetQueue() { return m_Queue; }
+  void Flush() {
+    while (!m_Queue.empty())
+      m_CVEmpty.notify_one();
+    m_End = true;
+    m_CVEmpty.notify_all();
+  }
+
+private:
+  std::queue<T> m_Queue;
+  std::mutex m_Mutex;
+  std::condition_variable m_CVEmpty, m_CVFull;
+  const size_t m_MaxSize;
+  std::atomic<bool> m_End;
+};
+#pragma endregion SAFESTRUCTS
+#pragma region THREADING
+struct WorkerJob {
+  virtual ~WorkerJob() = default;
+  virtual void Execute() = 0;
+};
+class ThreadPool {
+public:
+  explicit ThreadPool(const std::string &name);
+  void SetThreadCount(int);
+  void Dispatch(const Ref<WorkerJob> &);
+  void Create();
+  void Stop();
+  void Execute();
+
+protected:
+  std::string m_Name;
+  int m_ThreadCount{1};
+  bool m_IsCreated{false};
+  Vector<std::thread> m_Threads{};
+  SafeQueue<Ref<WorkerJob>> m_Queue;
+  bool m_IsDone{false};
+};
+#pragma endregion THREADING
+#pragma region VWEB
+enum class EPollReturns { OK = 0, BREAK, FAILURE };
+
+class EPollManager;
+class SocketManager;
+struct ServerConfig {
+  int Port{9020};
+  int MaxBufferSize{-1};
+  int BufferSize{16384};
+  int WorkerThreads{-1};
+  int MaxEvents{5000};
+  bool AllowSharedLibs{true};
+  Ref<EPollManager> EPoll{nullptr};
+  Ref<SocketManager> Socket{nullptr};
+  std::string ErrorDir;
+  std::string MimeFiles;
+};
+struct Accept {
+  EPollReturns ReturnValue{EPollReturns::OK};
+  std::stringstream Data{};
+  ssize_t CurrentBytes;
+  int SockId{-1};
+};
+class EPollManager {
+public:
+  EPollManager();
+  ~EPollManager();
+  [[nodiscard]] bool Dispatch(int sock, uint32_t eventType = EPOLLIN) const;
+  [[nodiscard]] bool UpdateEvents(int sock, uint32_t eventType = EPOLLIN) const;
+  int Wait(int idx, epoll_event *events) const;
+
+protected:
+  int m_EpollID{-1};
+};
+
+struct SendData {
+  ssize_t Offset{0};
+  ssize_t Size{0};
+  int SocketID{0};
+  std::string Content;
+};
+
+enum class WriteState { OK = 0, EPOLL, ERRORED };
+
+class SocketUtils {
+public:
+  static bool MakeAsync(int socketId);
+  static bool Add(int socketId);
+  static bool Close(int socketId);
+  static bool WriteDone(int socketId);
+  static WriteState Write(SendData &);
+};
+class SocketManager {
+public:
+  explicit SocketManager(const Ref<ServerConfig> &);
+  ~SocketManager();
+  Accept Handle();
+  bool SetSendListen(int socketID);
+  bool SetReadListen(int socketID);
+  Ref<ServerConfig> &GetServerConfig() { return m_ServerConfig; }
+  [[nodiscard]] int ID() const { return m_SocketID; }
+  [[nodiscard]] bool IsErrored() const { return m_IsErrored; }
+  void Init();
+
+protected:
+  void Errored(const std::string &data);
+
+  int m_SocketID{};
+  Ref<ServerConfig> m_ServerConfig{};
+  struct sockaddr_in m_Address {
+    0
+  };
+  int m_AddressLength{sizeof(m_Address)};
+  bool m_IsErrored{false};
+};
+
+class RequestHandler;
+class Response;
+class Router;
+class Route;
+class Server {
+public:
+  Server();
+  // Will Load SharedLibs from subdirectory
+  // This will allow that VWeb will run as Standalone and will load .so files
+  // without recompiling itself
+  void LoadSharedLibs();
+  void Start();
+  void Join() { m_WorkerThread->join(); }
+  void Stop() { m_IsExit = true; }
+  Ref<Router> &GetRouter() { return m_Router; }
+  Ref<ServerConfig> &GetServerConfig() { return m_ServerConfig; }
+  void AddRoute(const std::string &path, const Ref<Route> &route);
+  void RemoveRoute(const std::string &path);
+
+protected:
+  void Execute();
+  void OutgoingExecute(epoll_event &event);
+  void IncomingExecute(epoll_event &event);
+  void HandleRequestReading(epoll_event &event);
+  void CreateRequest(int sockID);
+
+protected:
+  Ref<Router> m_Router;
+  Ref<ServerConfig> m_ServerConfig;
+  Ref<RequestHandler> m_RequestHandler;
+  SafeMap<int, Accept> m_RawRequest{60000};
+  SafeMap<int, SendData> m_OutRequest{60000};
+  Ref<std::thread> m_WorkerThread;
+  Mutex m_Mutex;
+  bool m_IsExit{false};
+
+protected:
+  friend RequestHandler;
+};
+#pragma region VWEB_ROUTING
+using ms = std::chrono::duration<double, std::milli>;
+struct SessionData {
+  virtual ~SessionData() = default;
+};
+struct Session {
+  std::string Id;
+  long TTLSeconds = 1440; // 24 minutes 1440 seconds
+  bool IsValid();
+  void Update();
+  void Remove(const std::string &key);
+  bool Has(const std::string &key);
+  Ref<SessionData> &operator[](const std::string &key) { return m_Data[key]; }
+
+protected:
+  std::chrono::time_point<std::chrono::system_clock, ms> m_LastCall =
+      std::chrono::system_clock::now();
+  std::unordered_map<std::string, Ref<SessionData>> m_Data;
+};
+enum class HttpStatusCode : int {
+  Continue = 100,
+  SwitchingProtocols = 101,
+  Processing = 102,
+  EarlyHints = 103,
+  OK = 200,
+  Created = 201,
+  Accepted = 202,
+  NonAuthoritativeInformation = 203,
+  NoContent = 204,
+  ResetContent = 205,
+  PartialContent = 206,
+  MultiStatus = 207,
+  AlreadyReported = 208,
+  IMUsed = 226,
+  MultipleChoices = 300,
+  MovedPermanently = 301,
+  Found = 302,
+  SeeOther = 303,
+  NotModified = 304,
+  UseProxy = 305,
+  TemporaryRedirect = 307,
+  PermanentRedirect = 308,
+  BadRequest = 400,
+  Unauthorized = 401,
+  PaymentRequired = 402,
+  Forbidden = 403,
+  NotFound = 404,
+  MethodNotAllowed = 405,
+  NotAcceptable = 406,
+  ProxyAuthenticationRequired = 407,
+  RequestTimeout = 408,
+  Conflict = 409,
+  Gone = 410,
+  LengthRequired = 411,
+  PreconditionFailed = 412,
+  PayloadTooLarge = 413,
+  URITooLong = 414,
+  UnsupportedMediaType = 415,
+  RangeNotSatisfiable = 416,
+  ExpectationFailed = 417,
+  ImATeapot = 418,
+  UnprocessableEntity = 422,
+  Locked = 423,
+  FailedDependency = 424,
+  UpgradeRequired = 426,
+  PreconditionRequired = 428,
+  TooManyRequests = 429,
+  RequestHeaderFieldsTooLarge = 431,
+  UnavailableForLegalReasons = 451,
+  InternalServerError = 500,
+  NotImplemented = 501,
+  BadGateway = 502,
+  ServiceUnavailable = 503,
+  GatewayTimeout = 504,
+  HTTPVersionNotSupported = 505,
+  VariantAlsoNegotiates = 506,
+  InsufficientStorage = 507,
+  LoopDetected = 508,
+  NotExtended = 510,
+  NetworkAuthenticationRequired = 511
+};
+enum class HttpMethod {
+  GET = 0,
+  HEAD,
+  OPTIONS,
+  POST,
+  PUT,
+  PATCH,
+  DELETE,
+  FALLBACK
+};
+enum class CookieSameSite { Invalid = 0, Strict, Lax, None };
+struct Cookie {
+  std::string Name;
+  std::string Value;
+  std::string Expires;
+  int MaxAge{};
+  std::string Domain;
+  std::string Path;
+  bool Secure{};
+  bool HttpOnly{};
+  CookieSameSite SameSite{CookieSameSite::Invalid};
+  bool IsOld = false;
+};
+struct Cookies {
+public:
+  void Remove(const std::string &name);
+  bool Has(const std::string &name) const;
+  Cookie &Get(const std::string &name) { return Data[name]; };
+  std::string TransformToHeader();
+  void CreateCookieFromString(const std::string &data);
+  void CreateOld(const std::string &name, const std::string &value);
+
+  std::unordered_map<std::string, Cookie> Data;
+  Cookie &operator[](const std::string &name) { return Data[name]; }
+
+protected:
+  static void CookieToString(std::stringstream &stream, Cookie &cookie);
+};
+struct ParameterValue {
+  void Add(const std::string &item) { m_Data.push_back(item); }
+  void Set(const std::string &item) {
+    m_Data.clear();
+    m_Data.push_back(item);
+  }
+  std::string &Get(int item) { return m_Data[item]; }
+  std::string &GetFirst() { return Get(0); }
+  size_t Size() { return m_Data.size(); }
+  Vector<std::string> &Values() { return m_Data; }
+
+protected:
+  Vector<std::string> m_Data{};
+};
+
+struct Request {
+public:
+  int ID;
+  std::string Body;
+  HttpMethod Method{HttpMethod::GET};
+  std::string URI;
+  Ref<Session> SessionData;
+  Ref<Cookies> CookieData;
+  Cookie &GetCookie(const std::string &key) { return CookieData->Get(key); };
+  ParameterValue &Parameter(const std::string &key) { return Parameters[key]; }
+  bool HasParameter(const std::string &key) const {
+    return Parameters.contains(key);
+  }
+  std::string &FirstOf(const std::string &key) {
+    return Parameters[key].GetFirst();
+  }
+  ParameterValue &Header(const std::string &key) { return Parameters[key]; }
+  std::unordered_map<std::string, ParameterValue> Parameters;
+  std::unordered_map<std::string, ParameterValue> Headers;
+  Vector<std::string> URLParameters;
+};
+class Response {
+public:
+  size_t Length{0};
+  Ref<Cookies> CookieData{nullptr};
+  Ref<Session> SessionData{nullptr};
+  HttpStatusCode Status{HttpStatusCode::OK};
+  HttpMethod Method{HttpMethod::GET};
+
+public:
+  std::string GetResponse();
+  void SetHeader(const std::string &key, ParameterValue &value);
+  void SetHeader(const std::string &key, const std::string &value);
+  void AddHeaders(const std::string &key, const Vector<std::string> &values);
+  void AddHeader(const std::string &key, const std::string &value);
+  void SetType(const std::string &type);
+  void AddContent(const std::string &data);
+  void SetStatus(HttpStatusCode);
+  void SetMethod(HttpMethod);
+  void Reset();
+  Response &operator<<(const std::string &data) {
+    m_Content << data;
+    return *this;
+  }
+
+protected:
+  std::string TransformHeaders(const std::string &content);
+  std::string m_Type{"text/html"};
+  std::stringstream m_Content;
+  std::unordered_map<std::string, ParameterValue> m_Headers;
+};
+class MiddleWareHandler;
+class RequestHandler {
+public:
+  explicit RequestHandler(const Ref<SocketManager> &manager);
+  void InitThreads(int count);
+  void AddRequest(Ref<Request> &request);
+  void Stop();
+  void SetRouter(Ref<Router> &router);
+  void AddSendResponse(SendData);
+  Ref<MiddleWareHandler> &Middleware() { return m_MiddleWare; }
+
+protected:
+  Ref<Router> m_Router{nullptr};
+  Ref<SocketManager> m_SocketManager{nullptr};
+  Server *m_Server{nullptr};
+  SafeQueue<Ref<Request>> m_Requests{};
+  ThreadPool m_Pool{"RequestHandler"};
+  Ref<MiddleWareHandler> m_MiddleWare{nullptr};
+  friend Server;
+};
+
+class Route {
+public:
+  Route() = default;
+  virtual ~Route() = default;
+  Route(std::initializer_list<HttpMethod>);
+  virtual bool Execute(const Request &request, Response &response);
+  virtual bool Get(const Request &request, Response &response);
+  virtual bool Post(const Request &request, Response &response);
+  virtual bool Put(const Request &request, Response &response);
+  virtual bool Patch(const Request &request, Response &response);
+  virtual bool Delete(const Request &request, Response &response);
+  bool Options(const Request &request, Response &response);
+  virtual bool Fallback(const Request &request, Response &response);
+  bool SupportsMethod(const Request &request);
+  virtual bool IsAllowed(const Request &request);
+
+protected:
+  bool m_AllowAll{true};
+  Vector<HttpMethod> m_AllowedMethods;
+  friend Router;
+};
+
+class Router {
+public:
+  Router();
+  void AddRoute(const std::string &name, const Ref<Route> &route);
+  Ref<Route> &GetRoute(const std::string &name);
+  void DeleteRoute(const std::string &name);
+
+  Ref<Response> HandleRoute(Ref<Request> &request);
+  Ref<Route> FindRoute(Ref<Request> &request);
+  static void AddToArgs(Ref<Request> &request, Vector<std::string> &items);
+
+protected:
+  std::unordered_map<std::string, Ref<Route>> m_Routes;
+};
+
+struct MiddleWare {
+  int Pos{0};
+  virtual void PreHandle(Request &){};
+  virtual void PostHandle(Request &, Response &){};
+  virtual void Shutdown(Request &, Response &){};
+  bool operator<(const MiddleWare *rhs) const { return Pos < rhs->Pos; }
+};
+
+class MiddleWareHandler {
+public:
+  void HandlePre(Ref<Request> &);
+  void HandlePost(Ref<Request> &, Ref<Response> &);
+  void Shutdown(Ref<Request> &, Ref<Response> &);
+
+public:
+  template <class T> Ref<MiddleWare> Get() { return GetById(typeid(T).name()); }
+  template <class T> void Set(Ref<MiddleWare> &instance) {
+    auto &type = typeid(T);
+    if (type.before(typeid(MiddleWare)))
+      SetById(type.name(), instance);
+  }
+  template <class T> Ref<MiddleWare> Create() {
+    return SetById(typeid(T).name(), CreateRef<T>());
+  }
+  template <class T> void Remove() { RemoveById(typeid(T).name()); }
+
+protected:
+  Ref<MiddleWare> GetById(const char *id);
+  Ref<MiddleWare> SetById(const char *id, const Ref<MiddleWare> &);
+  void RemoveById(const char *id);
+  std::map<std::string, Ref<MiddleWare>> m_MiddleWares;
+};
+
+#pragma endregion VWEB_ROUTING
+#pragma endregion VWEB
+} // namespace VWeb

_clang-format

@@ -0,0 +1,18 @@
+---
+BasedOnStyle: LLVM
+AlignAfterOpenBracket: Align
+AlignEscapedNewlines: Right
+AlignOperands: true
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Always
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortIfStatementsOnASingleLine: Never
+BinPackArguments: true
+BinPackParameters: true
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+FixNamespaceComments: true
+IncludeBlocks: Regroup

example/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 3.17)
+project(VWeb_Example)
+set(CMAKE_CXX_STANDARD 20)
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+add_executable(VWeb_Example main.cpp)
+
+include_directories(${CMAKE_SOURCE_DIR}/..)
+
+set(mode release)
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(mode debug)
+endif ()
+set(vweb_lib ${CMAKE_SOURCE_DIR}/../dist/libVWeb.${mode}.a)
+target_link_libraries(VWeb_Example Threads::Threads ${vweb_lib})

example/main.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+#include <VWeb.h>
+
+class BigDataRoute : public VWeb::Route {
+public:
+  bool Execute(const VWeb::Request &request, VWeb::Response &response) override {
+    response << "<pre>\n";
+    for (int i = 0; i < 100; ++i)
+      response << "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.\n";
+    response << "</pre>";
+    return true;
+  }
+};
+int main() {
+  VWeb::Server server;
+  server.AddRoute("/test", VWeb::CreateRef<BigDataRoute>());
+  server.Start();
+  server.Join();
+  return 0;
+}