Changed clang format style.

11 files changed, 462 insertions, 430 deletions

diff --git a/server/src/client/client.cpp b/server/src/client/client.cpp
index 5e28f26..b82b5a4 100644
--- a/server/src/client/client.cpp
+++ b/server/src/client/client.cpp
@@ -2,88 +2,91 @@
 #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();
+int tcp::client::stream(std::vector<char>& data)
+{
+    auto size = data.size();
 
-  auto networked_size = htonl(size);
-  write(&networked_size, sizeof(networked_size));
+    auto networked_size = htonl(size);
+    write(&networked_size, sizeof(networked_size));
 
-  // with 4kb chunk size, speed peaks at 90mb/s
-  constexpr size_t chunk_size = 4096;
-  size_t sent = 0;
+    // with 4kb chunk size, speed peaks at 90mb/s
+    constexpr size_t chunk_size = 4096;
+    size_t           sent       = 0;
 
-  while (size > 0) {
-    auto to_send = std::min(size, chunk_size);
+    while(size > 0) {
+        auto to_send = std::min(size, chunk_size);
 
-    int ret = write(&data[sent], to_send);
-    if (ret <= 0) {
-      break;
-    }
+        int ret = write(&data[sent], to_send);
+        if(ret <= 0) {
+            break;
+        }
 
-    sent += ret;
-    size -= ret;
-  }
+        sent += ret;
+        size -= ret;
+    }
 
-  return sent;
+    return sent;
 }
 
-int tcp::client::read_stream(std::vector<char> &out) {
-  size_t size;
-  read(&size, sizeof(size));
+int tcp::client::read_stream(std::vector<char>& out)
+{
+    size_t size;
+    read(&size, sizeof(size));
 
-  size = ntohl(size);
-  out.resize(size);
+    size = ntohl(size);
+    out.resize(size);
 
-  constexpr size_t chunk_size = 4096;
-  size_t total = 0;
+    constexpr size_t chunk_size = 4096;
+    size_t           total      = 0;
 
-  while (size > 0) {
-    auto to_read = std::min(size, chunk_size);
+    while(size > 0) {
+        auto to_read = std::min(size, chunk_size);
 
-    int ret = read(&out[total], to_read);
-    if (ret <= 0) {
-      break;
-    }
+        int ret = read(&out[total], to_read);
+        if(ret <= 0) {
+            break;
+        }
 
-    size -= ret;
-    total += ret;
-  }
+        size -= ret;
+        total += ret;
+    }
 
-  return total;
+    return total;
 }
\ No newline at end of file
diff --git a/server/src/client/client.h b/server/src/client/client.h
index f305638..91d826f 100644
--- a/server/src/client/client.h
+++ b/server/src/client/client.h
@@ -3,47 +3,51 @@
 
 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:
+        static constexpr int version = 1;
 
-  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 97eac24..922d768 100644
--- a/server/src/main.cpp
+++ b/server/src/main.cpp
@@ -3,56 +3,58 @@
 #include "util/commands.h"
 #include "server/server.h"
 
-int main(int argc, char *argv[]) {
-  io::init(false);
+int main(int argc, char* argv[])
+{
+    io::init(false);
 
-  tcp::server server("6666");
+    tcp::server server("6666");
 
-  server.start();
+    server.start();
 
-  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.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()));
 
-    io::logger->info("{} connected", ip);
-  });
+        io::logger->info("{} connected", ip);
+    });
 
-  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();
-                           });
+    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();
+            });
 
-    server.client_stack.erase(it);
-    client.cleanup();
+        server.client_stack.erase(it);
+        client.cleanup();
 
-    io::logger->info("{} disconnected", client.get_ip());
-  });
+        io::logger->info("{} disconnected", client.get_ip());
+    });
 
-  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;
+    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) {
-      io::logger->info("{} sent invalid packet", ip);
-      return;
-    }
+        if(!packet) {
+            io::logger->info("{} sent invalid packet", ip);
+            return;
+        }
 
-    if (packet_session != session) {
-      io::logger->info("{} sent wrong session id", ip);
-      return;
-    }
+        if(packet_session != session) {
+            io::logger->info("{} sent wrong session id", ip);
+            return;
+        }
 
-    io::logger->info("{} : {}", packet_session, packet.message);
+        io::logger->info("{} : {}", packet_session, packet.message);
 
-    tcp::packet_t resp(packet.message, tcp::packet_type::write, client.get_session());
-    client.write(resp);
-  });
+        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();
+    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 9ca991d..ac01cc6 100644
--- a/server/src/server/packet.h
+++ b/server/src/server/packet.h
@@ -1,46 +1,50 @@
 #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 e8e1ce5..997cd7a 100644
--- a/server/src/server/server.cpp
+++ b/server/src/server/server.cpp
@@ -2,143 +2,153 @@
 #include "../util/io.h"
 #include "server.h"
 
-bool tcp::server::start() {
-  io::logger->info("starting server on port {}...", m_port.data());
+bool 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 false;
 
-  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;
+    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);
+    memset(&hints, 0, sizeof hints);
 
-  hints.ai_family = AF_INET;
-  hints.ai_socktype = SOCK_STREAM;
-  hints.ai_protocol = IPPROTO_TCP;
-  hints.ai_flags = AI_PASSIVE;
+    hints.ai_family   = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_protocol = IPPROTO_TCP;
+    hints.ai_flags    = AI_PASSIVE;
 
-  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;
-  }
+    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;
+    }
 
-  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());
+    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());
 
-  m_status = true;
+    m_status = true;
 
-  return true;
+    return 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);
-  } else {
-    client cli(client_socket, ip);
-    if (!cli.init_ssl(m_ctx)) {
-      cli.cleanup();
-      return;
-    }
+void tcp::server::accept_client()
+{
+    if(!FD_ISSET(m_socket, &m_server_set))
+        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;
-    }
+    struct sockaddr_in addr;
+    socklen_t          len  = sizeof(addr);
+    const int client_socket = accept(m_socket, reinterpret_cast<sockaddr*>(&addr), &len);
 
-    connect_event.call(cli);
-    client_stack.emplace_back(cli);
-  }
+    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;
+        }
+
+        // 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 39b9580..533009f 100644
--- a/server/src/server/server.h
+++ b/server/src/server/server.h
@@ -4,51 +4,54 @@
 #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_status = false;
 
- 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} {}
-  ~server() = default;
+        server(const std::string_view port) : m_port{ port } {}
+        ~server() = default;
 
-  bool start();
-  select_status peek();
-  void accept_client();
-  void receive();
-  void stop();
+        bool          start();
+        select_status peek();
+        void          accept_client();
+        void          receive();
+        void          stop();
 
-  bool running() { return m_status; }
+        bool running() { return m_status; }
 
-  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;
-      }
-    }
-  }
-};
+        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 745aa14..b9a0bac 100644
--- a/server/src/server/ssl.h
+++ b/server/src/server/ssl.h
@@ -1,58 +1,60 @@
 #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();
-  }
-  ~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;
+    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();
     }
-
-    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() = 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;
     }
 
-    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; }
+    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 1e5ae0f..547a78c 100644
--- a/server/src/util/commands.h
+++ b/server/src/util/commands.h
@@ -1,21 +1,19 @@
 #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;
+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;
     }
-    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 e6f053d..766cc26 100644
--- a/server/src/util/events.h
+++ b/server/src/util/events.h
@@ -1,24 +1,27 @@
 #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 f2da690..9779fc8 100644
--- a/server/src/util/io.cpp
+++ b/server/src/util/io.cpp
@@ -3,41 +3,44 @@
 
 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();
 }
diff --git a/server/src/util/io.h b/server/src/util/io.h
index 7f6e3a8..e8ef3f0 100644
--- a/server/src/util/io.h
+++ b/server/src/util/io.h
@@ -1,8 +1,8 @@
 #pragma once
 
 namespace io {
-extern std::shared_ptr<spdlog::logger> logger;
+    extern std::shared_ptr<spdlog::logger> logger;
 
-void init(const bool &to_file);
-void read_file(const std::string_view name, std::vector<char> &out);
-};  // namespace io
+    void init(const bool& to_file);
+    void read_file(const std::string_view name, std::vector<char>& out);
+}; // namespace io