10 files changed, 423 insertions, 461 deletions

diff --git a/server/src/client/client.cpp b/server/src/client/client.cpp
index b82b5a4..4313e85 100644
--- a/server/src/client/client.cpp
+++ b/server/src/client/client.cpp
@@ -2,91 +2,88 @@
 #include "../util/io.h"
 #include "client.h"
 
-bool tcp::client::init_ssl(SSL_CTX* server_ctx)
-{
-    m_ssl = SSL_new(server_ctx);
-    if(!m_ssl) {
-        io::logger->error("failed to create ssl on client {}.", m_ip);
-        return false;
-    }
-
-    int ret = SSL_set_fd(m_ssl, m_socket);
-    if(ret <= 0) {
-        io::logger->error("failed to set descriptor on client {}.", m_ip);
-        return false;
-    }
-
-    ret = SSL_accept(m_ssl);
-
-    if(ret <= 0) {
-        int err = SSL_get_error(m_ssl, ret);
-        io::logger->error("client {} failed to accept ssl, return code {}", m_ip, err);
-        return false;
-    }
-
-    return true;
+bool tcp::client::init_ssl(SSL_CTX* server_ctx) {
+  m_ssl = SSL_new(server_ctx);
+  if (!m_ssl) {
+    io::logger->error("failed to create ssl on client {}.", m_ip);
+    return false;
+  }
+
+  int ret = SSL_set_fd(m_ssl, m_socket);
+  if (ret <= 0) {
+    io::logger->error("failed to set descriptor on client {}.", m_ip);
+    return false;
+  }
+
+  ret = SSL_accept(m_ssl);
+
+  if (ret <= 0) {
+    int err = SSL_get_error(m_ssl, ret);
+    io::logger->error("client {} failed to accept ssl, return code {}", m_ip,
+                      err);
+    return false;
+  }
+
+  return true;
 }
 
-void tcp::client::gen_session()
-{
-    std::random_device                 r;
-    std::default_random_engine         e1(r());
-    std::uniform_int_distribution<int> gen(33, 126);
+void tcp::client::gen_session() {
+  std::random_device r;
+  std::default_random_engine e1(r());
+  std::uniform_int_distribution<int> gen(33, 126);
 
-    for(int i = 0; i < session_id_len; i++) {
-        auto k = static_cast<char>(gen(e1));
-        m_session_id.insert(m_session_id.end(), k);
-    }
+  for (int i = 0; i < session_id_len; i++) {
+    auto k = static_cast<char>(gen(e1));
+    m_session_id.insert(m_session_id.end(), k);
+  }
 }
 
-int tcp::client::stream(std::vector<char>& data)
-{
-    auto size = data.size();
-
-    auto networked_size = htonl(size);
-    write(&networked_size, sizeof(networked_size));
+int tcp::client::stream(std::vector<char>& data) {
+  auto size = data.size();
 
-    // with 4kb chunk size, speed peaks at 90mb/s
-    constexpr size_t chunk_size = 4096;
-    size_t           sent       = 0;
+  auto networked_size = htonl(size);
+  write(&networked_size, sizeof(networked_size));
 
-    while(size > 0) {
-        auto to_send = std::min(size, chunk_size);
+  // with 4kb chunk size, speed peaks at 90mb/s
+  constexpr size_t chunk_size = 4096;
+  size_t sent = 0;
 
-        int ret = write(&data[sent], to_send);
-        if(ret <= 0) {
-            break;
-        }
+  while (size > 0) {
+    auto to_send = std::min(size, chunk_size);
 
-        sent += ret;
-        size -= ret;
+    int ret = write(&data[sent], to_send);
+    if (ret <= 0) {
+      break;
     }
 
-    return sent;
-}
+    sent += ret;
+    size -= ret;
+  }
 
-int tcp::client::read_stream(std::vector<char>& out)
-{
-    size_t size;
-    read(&size, sizeof(size));
+  return sent;
+}
 
-    size = ntohl(size);
-    out.resize(size);
+int tcp::client::read_stream(std::vector<char>& out) {
+  size_t size;
+  read(&size, sizeof(size));
 
-    constexpr size_t chunk_size = 4096;
-    size_t           total      = 0;
+  size = ntohl(size);
+  out.resize(size);
 
-    while(size > 0) {
-        auto to_read = std::min(size, chunk_size);
+  constexpr size_t chunk_size = 4096;
+  size_t total = 0;
 
-        int ret = read(&out[total], to_read);
-        if(ret <= 0) {
-            break;
-        }
+  while (size > 0) {
+    auto to_read = std::min(size, chunk_size);
 
-        size -= ret;
-        total += ret;
+    int ret = read(&out[total], to_read);
+    if (ret <= 0) {
+      break;
     }
 
-    return total;
+    size -= ret;
+    total += ret;
+  }
+
+  return total;
 }
\ No newline at end of file
diff --git a/server/src/client/client.h b/server/src/client/client.h
index 91d826f..07269ff 100644
--- a/server/src/client/client.h
+++ b/server/src/client/client.h
@@ -3,51 +3,45 @@
 
 namespace tcp {
 
-    class client {
-        int  m_socket;
-        SSL* m_ssl;
+class client {
+  int m_socket;
+  SSL* m_ssl;
 
-        time_t m_time;
+  time_t m_time;
 
-        std::string m_ip;
-        std::string m_session_id;
+  std::string m_ip;
+  std::string m_session_id;
 
-    public:
-        static constexpr int version = 1;
+ public:
+  client() : m_socket{-1} {};
+  client(const int& socket, const std::string_view ip)
+      : m_socket{std::move(socket)}, m_ip{ip}, m_ssl{nullptr} {}
+  ~client() = default;
 
-        client() : m_socket{ -1 } {};
-        client(const int& socket, const std::string_view ip)
-            : m_socket{ std::move(socket) }, m_ip{ ip }, m_ssl{ nullptr }
-        {}
-        ~client() = default;
+  bool init_ssl(SSL_CTX* server_ctx);
 
-        bool init_ssl(SSL_CTX* server_ctx);
+  void cleanup() {
+    close(m_socket);
+    SSL_shutdown(m_ssl);
+    SSL_free(m_ssl);
+  }
 
-        void cleanup()
-        {
-            close(m_socket);
-            SSL_shutdown(m_ssl);
-            SSL_free(m_ssl);
-        }
+  int write(void* data, size_t size) { return SSL_write(m_ssl, data, size); }
 
-        int write(void* data, size_t size) { return SSL_write(m_ssl, data, size); }
+  int write(const packet_t& packet) {
+    if (!packet) return 0;
+    return SSL_write(m_ssl, packet.message.data(), packet.message.size());
+  }
 
-        int write(const packet_t& packet)
-        {
-            if(!packet)
-                return 0;
-            return SSL_write(m_ssl, packet.message.data(), packet.message.size());
-        }
+  int read(void* data, size_t size) { return SSL_read(m_ssl, data, size); }
 
-        int read(void* data, size_t size) { return SSL_read(m_ssl, data, size); }
+  int stream(std::vector<char>& data);
+  int read_stream(std::vector<char>& out);
 
-        int stream(std::vector<char>& data);
-        int read_stream(std::vector<char>& out);
+  void gen_session();
 
-        void gen_session();
-
-        int  get_socket() { return m_socket; }
-        auto get_ip() { return m_ip; }
-        auto get_session() { return m_session_id; }
-    };
-}; // namespace tcp
\ No newline at end of file
+  int get_socket() { return m_socket; }
+  auto get_ip() { return m_ip; }
+  auto get_session() { return m_session_id; }
+};
+};  // namespace tcp
\ No newline at end of file
diff --git a/server/src/main.cpp b/server/src/main.cpp
index 922d768..a9c2973 100644
--- a/server/src/main.cpp
+++ b/server/src/main.cpp
@@ -3,58 +3,59 @@
 #include "util/commands.h"
 #include "server/server.h"
 
-int main(int argc, char* argv[])
-{
-    io::init(false);
+constexpr std::string_view client_version{"0.1.0"};
 
-    tcp::server server("6666");
+int main(int argc, char* argv[]) {
+  io::init(false);
 
-    server.start();
+  tcp::server server("6666");
 
-    server.connect_event.add([&](tcp::client& client) {
-        auto ip = client.get_ip();
-        client.gen_session();
-        client.write(tcp::packet_t(std::to_string(client.version),
-                                   tcp::packet_type::write,
-                                   client.get_session()));
+  server.start();
 
-        io::logger->info("{} connected", ip);
-    });
+  server.connect_event.add([&](tcp::client& client) {
+    auto ip = client.get_ip();
+    client.gen_session();
+    client.write(tcp::packet_t(client_version,
+                               tcp::packet_type::write, client.get_session()));
 
-    server.disconnect_event.add([&](tcp::client& client) {
-        auto it = std::find_if(
-            server.client_stack.begin(), server.client_stack.end(), [&](tcp::client& c) {
-                return client.get_socket() == client.get_socket();
-            });
+    io::logger->info("{} connected", ip);
+  });
 
-        server.client_stack.erase(it);
-        client.cleanup();
+  server.disconnect_event.add([&](tcp::client& client) {
+    auto it = std::find_if(server.client_stack.begin(),
+                           server.client_stack.end(), [&](tcp::client& c) {
+                             return client.get_socket() == client.get_socket();
+                           });
 
-        io::logger->info("{} disconnected", client.get_ip());
-    });
+    server.client_stack.erase(it);
+    client.cleanup();
 
-    server.receive_event.add([&](tcp::packet_t& packet, tcp::client& client) {
-        auto session        = client.get_session();
-        auto packet_session = packet.session_id;
-        auto ip             = client.get_ip();
-        auto message        = packet.message;
+    io::logger->info("{} disconnected", client.get_ip());
+  });
 
-        if(!packet) {
-            io::logger->info("{} sent invalid packet", ip);
-            return;
-        }
+  server.receive_event.add([&](tcp::packet_t& packet, tcp::client& client) {
+    auto session = client.get_session();
+    auto packet_session = packet.session_id;
+    auto ip = client.get_ip();
+    auto message = packet.message;
 
-        if(packet_session != session) {
-            io::logger->info("{} sent wrong session id", ip);
-            return;
-        }
+    if (!packet) {
+      io::logger->info("{} sent invalid packet", ip);
+      return;
+    }
 
-        io::logger->info("{} : {}", packet_session, packet.message);
+    if (packet_session != session) {
+      io::logger->info("{} sent wrong session id", ip);
+      return;
+    }
 
-        tcp::packet_t resp(packet.message, tcp::packet_type::write, client.get_session());
-        client.write(resp);
-    });
+    io::logger->info("{} : {}", packet_session, packet.message);
 
-    std::thread t{ tcp::server::monitor, std::ref(server) };
-    t.join();
+    tcp::packet_t resp(packet.message, tcp::packet_type::write,
+                       client.get_session());
+    client.write(resp);
+  });
+
+  std::thread t{tcp::server::monitor, std::ref(server)};
+  t.join();
 }
diff --git a/server/src/server/packet.h b/server/src/server/packet.h
index ac01cc6..b31f033 100644
--- a/server/src/server/packet.h
+++ b/server/src/server/packet.h
@@ -1,50 +1,46 @@
 #pragma once
 
 namespace tcp {
-    constexpr size_t session_id_len = 10;
-    constexpr size_t message_len    = 256 + session_id_len;
-
-    enum packet_type : int { write = 0, read };
-
-    struct packet_t {
-        std::string message;
-        char        action;
-        std::string session_id;
-
-        packet_t() {}
-        packet_t(const std::string_view msg,
-                 const packet_type&     type,
-                 std::string_view       session = "")
-        {
-            if(type == read) {
-                if(msg.size() < session_id_len) {
-                    io::logger->error("packet message invalid!");
-                    return;
-                }
-
-                session_id = msg.substr(0, session_id_len);
-
-                action  = msg[session_id_len];
-                message = msg.substr(session_id_len);
-            }
-            else {
-                if(msg.size() > message_len) {
-                    io::logger->error("packet message exceeds limit");
-                    return;
-                }
-
-                session_id = session;
-
-                message = fmt::format("{}{}", session_id, msg);
-            }
-        }
-
-        ~packet_t()
-        {
-            message.clear();
-            session_id.clear();
-        }
-
-        operator bool() const { return !message.empty() && !session_id.empty(); }
-    };
-}; // namespace tcp
+constexpr size_t session_id_len = 10;
+constexpr size_t message_len = 256 + session_id_len;
+
+enum packet_type : int { write = 0, read };
+
+struct packet_t {
+  std::string message;
+  char action;
+  std::string session_id;
+
+  packet_t() {}
+  packet_t(const std::string_view msg, const packet_type& type,
+           std::string_view session = "") {
+    if (type == read) {
+      if (msg.size() < session_id_len) {
+        io::logger->error("packet message invalid!");
+        return;
+      }
+
+      session_id = msg.substr(0, session_id_len);
+
+      action = msg[session_id_len];
+      message = msg.substr(session_id_len);
+    } else {
+      if (msg.size() > message_len) {
+        io::logger->error("packet message exceeds limit");
+        return;
+      }
+
+      session_id = session;
+
+      message = fmt::format("{}{}", session_id, msg);
+    }
+  }
+
+  ~packet_t() {
+    message.clear();
+    session_id.clear();
+  }
+
+  operator bool() const { return !message.empty() && !session_id.empty(); }
+};
+};  // namespace tcp
diff --git a/server/src/server/server.cpp b/server/src/server/server.cpp
index 997cd7a..b0383bd 100644
--- a/server/src/server/server.cpp
+++ b/server/src/server/server.cpp
@@ -2,153 +2,141 @@
 #include "../util/io.h"
 #include "server.h"
 
-bool tcp::server::start()
-{
-    io::logger->info("starting server on port {}...", m_port.data());
+void tcp::server::start() {
+  io::logger->info("starting server on port {}...", m_port.data());
 
-    ssl ctx("ssl/server.crt", "ssl/server.key", "ssl/rootCA.crt");
-    if(!ctx.init())
-        return false;
+  ssl ctx("ssl/server.crt", "ssl/server.key", "ssl/rootCA.crt");
+  if (!ctx.init()) return;
 
-    m_ctx = std::move(ctx.get_context());
+  m_ctx = std::move(ctx.get_context());
 
-    m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    if(m_socket < 0) {
-        io::logger->critical("failed to create socket.");
-        return false;
-    }
-    struct addrinfo hints, *addrinfo = nullptr;
-
-    memset(&hints, 0, sizeof hints);
+  m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  if (m_socket < 0) {
+    io::logger->critical("failed to create socket.");
+    return;
+  }
+  struct addrinfo hints, *addrinfo = nullptr;
 
-    hints.ai_family   = AF_INET;
-    hints.ai_socktype = SOCK_STREAM;
-    hints.ai_protocol = IPPROTO_TCP;
-    hints.ai_flags    = AI_PASSIVE;
+  memset(&hints, 0, sizeof hints);
 
-    int ret = getaddrinfo(nullptr, m_port.data(), &hints, &addrinfo);
-    if(ret != 0) {
-        io::logger->critical("failed to get address info.");
-        close(m_socket);
-        return false;
-    }
+  hints.ai_family = AF_INET;
+  hints.ai_socktype = SOCK_STREAM;
+  hints.ai_protocol = IPPROTO_TCP;
+  hints.ai_flags = AI_PASSIVE;
 
-    ret = bind(m_socket, addrinfo->ai_addr, addrinfo->ai_addrlen);
-    if(ret < 0) {
-        io::logger->critical("failed to bind port.");
-        close(m_socket);
-        return false;
-    }
-    io::logger->info("port bound.");
-    freeaddrinfo(addrinfo);
-
-    ret = listen(m_socket, SOMAXCONN);
-    if(ret < 0) {
-        io::logger->critical("failed to listen on port {}.", m_port.data());
-        close(m_socket);
-        return false;
-    }
-    io::logger->info("listening on {}.", m_port.data());
+  int ret = getaddrinfo(nullptr, m_port.data(), &hints, &addrinfo);
+  if (ret != 0) {
+    io::logger->critical("failed to get address info.");
+    close(m_socket);
+    return;
+  }
 
-    m_status = true;
+  ret = bind(m_socket, addrinfo->ai_addr, addrinfo->ai_addrlen);
+  if (ret < 0) {
+    io::logger->critical("failed to bind port.");
+    close(m_socket);
+    return;
+  }
+  io::logger->info("port bound.");
+  freeaddrinfo(addrinfo);
+
+  ret = listen(m_socket, SOMAXCONN);
+  if (ret < 0) {
+    io::logger->critical("failed to listen on port {}.", m_port.data());
+    close(m_socket);
+    return;
+  }
+  io::logger->info("listening on {}.", m_port.data());
 
-    return true;
+  m_active = true;
 }
 
-tcp::select_status tcp::server::peek()
-{
-    FD_ZERO(&m_server_set);
-    FD_SET(m_socket, &m_server_set);
+tcp::select_status tcp::server::peek() {
+  FD_ZERO(&m_server_set);
+  FD_SET(m_socket, &m_server_set);
 
-    int maxfd = m_socket;
+  int maxfd = m_socket;
 
-    for(auto& c : client_stack) {
-        const int s = c.get_socket();
-        FD_SET(s, &m_server_set);
+  for (auto& c : client_stack) {
+    const int s = c.get_socket();
+    FD_SET(s, &m_server_set);
 
-        maxfd = std::max(maxfd, s);
-    }
+    maxfd = std::max(maxfd, s);
+  }
 
-    struct timeval tv;
-    tv.tv_sec  = 1;
-    tv.tv_usec = 0;
+  struct timeval tv;
+  tv.tv_sec = 1;
+  tv.tv_usec = 0;
 
-    const int ret = select(maxfd + 1, &m_server_set, nullptr, nullptr, &tv);
-    if(ret < 0) {
-        io::logger->error("select error : {}", strerror(errno));
-        return tcp::select_status::error;
-    }
+  const int ret = select(maxfd + 1, &m_server_set, nullptr, nullptr, &tv);
+  if (ret < 0) {
+    io::logger->error("select error : {}", strerror(errno));
+    return tcp::select_status::error;
+  }
 
-    if(ret == 0) {
-        return tcp::select_status::standby;
-    }
+  if (ret == 0) {
+    return tcp::select_status::standby;
+  }
 
-    return tcp::select_status::ready;
+  return tcp::select_status::ready;
 }
 
-void tcp::server::accept_client()
-{
-    if(!FD_ISSET(m_socket, &m_server_set))
-        return;
-
-    struct sockaddr_in addr;
-    socklen_t          len  = sizeof(addr);
-    const int client_socket = accept(m_socket, reinterpret_cast<sockaddr*>(&addr), &len);
-
-    const auto ip = inet_ntoa(addr.sin_addr);
-    if(client_socket < 0) {
-        io::logger->warn("{} failed to accept.", ip);
-        close(client_socket);
+void tcp::server::accept_client() {
+  if (!FD_ISSET(m_socket, &m_server_set)) return;
+
+  struct sockaddr_in addr;
+  socklen_t len = sizeof(addr);
+  const int client_socket =
+      accept(m_socket, reinterpret_cast<sockaddr*>(&addr), &len);
+
+  const auto ip = inet_ntoa(addr.sin_addr);
+  if (client_socket < 0) {
+    io::logger->warn("{} failed to accept.", ip);
+    close(client_socket);
+  } else {
+    client cli(client_socket, ip);
+    if (!cli.init_ssl(m_ctx)) {
+      cli.cleanup();
+      return;
     }
-    else {
-        client cli(client_socket, ip);
-        if(!cli.init_ssl(m_ctx)) {
-            cli.cleanup();
-            return;
-        }
-
-        // check for an existing connection
-        auto it = std::find_if(client_stack.begin(), client_stack.end(), [&](client& c) {
-            return c.get_ip() == ip;
-        });
-        if(it != client_stack.end()) {
-            io::logger->info("{} is already connected, dropping...", ip);
-            cli.cleanup();
-            return;
-        }
-
-        connect_event.call(cli);
-        client_stack.emplace_back(cli);
+
+    // check for an existing connection
+    auto it = std::find_if(client_stack.begin(), client_stack.end(),
+                           [&](client& c) { return c.get_ip() == ip; });
+    if (it != client_stack.end()) {
+      io::logger->info("{} is already connected, dropping...", ip);
+      cli.cleanup();
+      return;
     }
+
+    connect_event.call(cli);
+    client_stack.emplace_back(cli);
+  }
 }
 
-void tcp::server::receive()
-{
-    std::array<char, message_len> buf;
-    for(auto& c : client_stack) {
-        const int socket = c.get_socket();
+void tcp::server::receive() {
+  std::array<char, message_len> buf;
+  for (auto& c : client_stack) {
+    const int socket = c.get_socket();
 
-        if(!FD_ISSET(socket, &m_server_set))
-            continue;
+    if (!FD_ISSET(socket, &m_server_set)) continue;
 
-        buf.fill(0);
+    buf.fill(0);
 
-        const int read = c.read(&buf[0], buf.size());
-        if(read > 0) {
-            std::string msg(buf.data(), read);
+    const int read = c.read(&buf[0], buf.size());
+    if (read > 0) {
+      std::string msg(buf.data(), read);
 
-            tcp::packet_t packet(msg, tcp::packet_type::read);
+      tcp::packet_t packet(msg, tcp::packet_type::read);
 
-            receive_event.call(packet, c);
-        }
-        else {
-            disconnect_event.call(c);
-        }
+      receive_event.call(packet, c);
+    } else {
+      disconnect_event.call(c);
     }
+  }
 }
 
-void tcp::server::stop()
-{
-    io::logger->info("stopping server on port {}.", m_port);
-    close(m_socket);
+void tcp::server::stop() {
+  io::logger->info("stopping server on port {}.", m_port);
+  close(m_socket);
 }
\ No newline at end of file
diff --git a/server/src/server/server.h b/server/src/server/server.h
index 533009f..9d594a0 100644
--- a/server/src/server/server.h
+++ b/server/src/server/server.h
@@ -4,54 +4,50 @@
 #include "ssl.h"
 
 namespace tcp {
-    constexpr uint8_t server_version = 0;
+constexpr uint8_t server_version = 0;
 
-    enum select_status : int { error = 0, standby, ready };
+enum select_status : int { error = 0, standby, ready };
 
-    class server {
-        int              m_socket;
-        std::string_view m_port;
+class server {
+  int m_socket;
+  std::string_view m_port;
 
-        fd_set   m_server_set;
-        SSL_CTX* m_ctx;
+  fd_set m_server_set;
+  SSL_CTX* m_ctx;
 
-        std::atomic<bool> m_status = false;
+  std::atomic<bool> m_active;
 
-    public:
-        std::vector<tcp::client> client_stack;
+ public:
+  std::vector<tcp::client> client_stack;
 
+  event<client&> connect_event;
+  event<packet_t&, client&> receive_event;
+  event<client&> disconnect_event;
 
-        event<client&>            connect_event;
-        event<packet_t&, client&> receive_event;
-        event<client&>            disconnect_event;
+  server(const std::string_view port) : m_port{port}, m_active{false} {}
+  ~server() = default;
 
-        server(const std::string_view port) : m_port{ port } {}
-        ~server() = default;
+  void start();
+  select_status peek();
+  void accept_client();
+  void receive();
+  void stop();
 
-        bool          start();
-        select_status peek();
-        void          accept_client();
-        void          receive();
-        void          stop();
+  operator bool() const { return m_active; }
 
-        bool running() { return m_status; }
+  static void monitor(server& srv) {
+    while (srv) {
+      auto ret = srv.peek();
+      if (ret == select_status::ready) {
+        srv.accept_client();
+        srv.receive();
+      } else if (ret == select_status::standby) {
+        // check for timeout
+      } else {
+        break;
+      }
+    }
+  }
+};
 
-        static void monitor(server& srv)
-        {
-            while(srv.running()) {
-                auto ret = srv.peek();
-                if(ret == select_status::ready) {
-                    srv.accept_client();
-                    srv.receive();
-                }
-                else if(ret == select_status::standby) {
-                    // check for timeout
-                }
-                else {
-                    break;
-                }
-            }
-        }
-    };
-
-}; // namespace tcp
+};  // namespace tcp
diff --git a/server/src/server/ssl.h b/server/src/server/ssl.h
index b9a0bac..30a4faa 100644
--- a/server/src/server/ssl.h
+++ b/server/src/server/ssl.h
@@ -1,60 +1,57 @@
 #pragma once
 
 class ssl {
-    std::string_view m_cert, m_key, m_ca;
-    std::string      m_passphrase;
-    SSL_CTX*         m_ctx;
-
-public:
-    ssl(const std::string_view cert,
-        const std::string_view key,
-        const std::string_view ca = "")
-        : m_cert{ cert }, m_key{ key }, m_ca{ ca }, m_ctx{ nullptr }
-    {
-        SSL_library_init();
+  std::string_view m_cert, m_key, m_ca;
+  std::string m_passphrase;
+  SSL_CTX* m_ctx;
+
+ public:
+  ssl(const std::string_view cert, const std::string_view key,
+      const std::string_view ca = "")
+      : m_cert{cert}, m_key{key}, m_ca{ca}, m_ctx{nullptr} {
+    SSL_library_init();
+  }
+  ~ssl() = default;
+
+  bool init() {
+    m_ctx = SSL_CTX_new(TLS_server_method());
+    if (!m_ctx) {
+      io::logger->error("failed to create ssl context.");
+      return false;
     }
-    ~ssl() = default;
-
-    bool init()
-    {
-        m_ctx = SSL_CTX_new(TLS_server_method());
-        if(!m_ctx) {
-            io::logger->error("failed to create ssl context.");
-            return false;
-        }
-
-        int res = SSL_CTX_use_certificate_chain_file(m_ctx, m_cert.data());
-        if(res != 1) {
-            io::logger->error("failed to load certificate.");
-            return false;
-        }
-
-        if(!m_passphrase.empty())
-            SSL_CTX_set_default_passwd_cb_userdata(m_ctx, m_passphrase.data());
-
-        res = SSL_CTX_use_PrivateKey_file(m_ctx, m_key.data(), SSL_FILETYPE_PEM);
-        if(res != 1) {
-            io::logger->error("failed to load private key.");
-            return false;
-        }
-
-        res = SSL_CTX_check_private_key(m_ctx);
-        if(res != 1) {
-            io::logger->error("failed to verify private key.");
-            return false;
-        }
-
-        res = SSL_CTX_load_verify_locations(m_ctx, m_ca.data(), nullptr);
-        if(res != 1) {
-            io::logger->error("failed to load root ca.");
-            return false;
-        }
-
-        SSL_CTX_set_verify(m_ctx, SSL_VERIFY_PEER, 0);
-
-        return true;
+
+    int res = SSL_CTX_use_certificate_chain_file(m_ctx, m_cert.data());
+    if (res != 1) {
+      io::logger->error("failed to load certificate.");
+      return false;
+    }
+
+    if (!m_passphrase.empty())
+      SSL_CTX_set_default_passwd_cb_userdata(m_ctx, m_passphrase.data());
+
+    res = SSL_CTX_use_PrivateKey_file(m_ctx, m_key.data(), SSL_FILETYPE_PEM);
+    if (res != 1) {
+      io::logger->error("failed to load private key.");
+      return false;
+    }
+
+    res = SSL_CTX_check_private_key(m_ctx);
+    if (res != 1) {
+      io::logger->error("failed to verify private key.");
+      return false;
+    }
+
+    res = SSL_CTX_load_verify_locations(m_ctx, m_ca.data(), nullptr);
+    if (res != 1) {
+      io::logger->error("failed to load root ca.");
+      return false;
     }
 
-    void  set_passphrase(const std::string_view phrase) { m_passphrase = phrase; }
-    auto& get_context() { return m_ctx; }
+    SSL_CTX_set_verify(m_ctx, SSL_VERIFY_PEER, 0);
+
+    return true;
+  }
+
+  void set_passphrase(const std::string_view phrase) { m_passphrase = phrase; }
+  auto& get_context() { return m_ctx; }
 };
diff --git a/server/src/util/commands.h b/server/src/util/commands.h
index 547a78c..3648df2 100644
--- a/server/src/util/commands.h
+++ b/server/src/util/commands.h
@@ -1,19 +1,18 @@
 #pragma once
 
 class commands {
-    using func = std::function<void()>;
-    std::unordered_map<std::string_view, func> m_cmds;
+  using func = std::function<void()>;
+  std::unordered_map<std::string_view, func> m_cmds;
 
-public:
-    bool parse_input(const std::string_view str)
-    {
-        auto it = m_cmds.find(str);
-        if(it != m_cmds.end()) {
-            it->second();
-            return true;
-        }
-        return false;
+ public:
+  bool parse_input(const std::string_view str) {
+    auto it = m_cmds.find(str);
+    if (it != m_cmds.end()) {
+      it->second();
+      return true;
     }
+    return false;
+  }
 
-    void add(const std::string_view cmd, const func& cb) { m_cmds[cmd] = cb; }
+  void add(const std::string_view cmd, const func& cb) { m_cmds[cmd] = cb; }
 };
diff --git a/server/src/util/events.h b/server/src/util/events.h
index 766cc26..e6f053d 100644
--- a/server/src/util/events.h
+++ b/server/src/util/events.h
@@ -1,27 +1,24 @@
 #pragma once
 
-template<typename... Args>
+template <typename... Args>
 class event {
-    using func_type = std::function<void(Args...)>;
+  using func_type = std::function<void(Args...)>;
 
-    std::mutex           event_lock;
-    std::list<func_type> m_funcs;
+  std::mutex event_lock;
+  std::list<func_type> m_funcs;
 
-public:
-    void add(const func_type& func)
-    {
-        std::lock_guard<std::mutex> lock(event_lock);
+ public:
+  void add(const func_type& func) {
+    std::lock_guard<std::mutex> lock(event_lock);
 
-        m_funcs.emplace_back(std::move(func));
-    }
+    m_funcs.emplace_back(std::move(func));
+  }
 
-    void call(Args... params)
-    {
-        std::lock_guard<std::mutex> lock(event_lock);
+  void call(Args... params) {
+    std::lock_guard<std::mutex> lock(event_lock);
 
-        for(auto& func : m_funcs) {
-            if(func)
-                func(std::forward<Args>(params)...);
-        }
+    for (auto& func : m_funcs) {
+      if (func) func(std::forward<Args>(params)...);
     }
+  }
 };
diff --git a/server/src/util/io.cpp b/server/src/util/io.cpp
index 9779fc8..aff8a53 100644
--- a/server/src/util/io.cpp
+++ b/server/src/util/io.cpp
@@ -3,44 +3,41 @@
 
 std::shared_ptr<spdlog::logger> io::logger;
 
-void io::init(const bool& to_file)
-{
-    auto sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    sink->set_pattern("[%R][%^%l%$] %v");
+void io::init(const bool& to_file) {
+  auto sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+  sink->set_pattern("[%R][%^%l%$] %v");
 
-    auto file_sink =
-        std::make_shared<spdlog::sinks::basic_file_sink_mt>("server.log", true);
+  auto file_sink =
+      std::make_shared<spdlog::sinks::basic_file_sink_mt>("server.log", true);
 
-    std::vector<spdlog::sink_ptr> log_sinks;
-    log_sinks.emplace_back(sink);
+  std::vector<spdlog::sink_ptr> log_sinks;
+  log_sinks.emplace_back(sink);
 
-    if(to_file)
-        log_sinks.emplace_back(file_sink);
+  if (to_file) log_sinks.emplace_back(file_sink);
 
-    logger =
-        std::make_shared<spdlog::logger>("server", log_sinks.begin(), log_sinks.end());
-    spdlog::register_logger(logger);
+  logger = std::make_shared<spdlog::logger>("server", log_sinks.begin(),
+                                            log_sinks.end());
+  spdlog::register_logger(logger);
 
-    spdlog::flush_every(std::chrono::seconds(1));
+  spdlog::flush_every(std::chrono::seconds(1));
 }
 
-void io::read_file(const std::string_view name, std::vector<char>& out)
-{
-    std::ifstream file(name.data());
-    if(!file.good()) {
-        io::logger->error("failed to load {}.", name.data());
-        return;
-    }
+void io::read_file(const std::string_view name, std::vector<char>& out) {
+  std::ifstream file(name.data());
+  if (!file.good()) {
+    io::logger->error("failed to load {}.", name.data());
+    return;
+  }
 
-    file.unsetf(std::ios::skipws);
+  file.unsetf(std::ios::skipws);
 
-    file.seekg(0, std::ios::end);
-    const size_t size = file.tellg();
-    file.seekg(0, std::ios::beg);
+  file.seekg(0, std::ios::end);
+  const size_t size = file.tellg();
+  file.seekg(0, std::ios::beg);
 
-    out.resize(size);
+  out.resize(size);
 
-    file.read(out.data(), size);
+  file.read(out.data(), size);
 
-    file.close();
+  file.close();
 }