Finished session id on client and server.

Started expirementing with ways to send version.
Finished packet wrapper completely.
Small code and formatting changes.

11 files changed, 83 insertions, 76 deletions

diff --git a/client/src/client/client.cpp b/client/src/client/client.cpp
index 9c290ff..4846440 100644
--- a/client/src/client/client.cpp
+++ b/client/src/client/client.cpp
@@ -32,21 +32,13 @@ bool tcp::client::start(const std::string_view server_ip, const uint16_t port) {
 
   if (ret != 1) {
     ret = SSL_get_error(m_server_ssl, ret);
-    io::logger->error("failed to connect to server. {}", ret);
+    io::logger->error("ssl connection failed, code {}", ret);
     return false;
   }
 
   return true;
 }
 
-bool tcp::client::set_session() {
-  m_session_id.resize(tcp::session_id_len);
-
-  int ret = read(&m_session_id[0], tcp::session_id_len);
-  if(ret != tcp::session_id_len) return false;
-  return true;
-}
-
 int tcp::client::read_stream(std::vector<char> &out) {
   size_t size;
   read(&size, sizeof(size));
diff --git a/client/src/client/client.h b/client/src/client/client.h
index 3092c20..326bae6 100644
--- a/client/src/client/client.h
+++ b/client/src/client/client.h
@@ -4,7 +4,7 @@
 #include "packet.h"
 
 namespace tcp {
-
+  
 enum client_state : uint8_t { idle = 0, active, standby };
 
 class client {
@@ -14,14 +14,21 @@ class client {
   SSL *m_server_ssl;
   SSL_CTX *m_ssl_ctx;
 
-  std::string m_session_id;
  public:
+  static constexpr int version = 0;
+  std::string session_id;
   event<packet_t &> receive_event;
 
   client() : m_socket{-1}, m_state{0} {}
 
   bool start(const std::string_view server_ip, const uint16_t port);
 
+  int write(const packet_t &packet) {
+    if (!packet) return 0;
+    return SSL_write(m_server_ssl, packet.message.data(),
+                     packet.message.size());
+  }
+
   int write(void *data, size_t size) {
     return SSL_write(m_server_ssl, data, size);
   }
@@ -33,15 +40,16 @@ class client {
   int read_stream(std::vector<char> &out);
   int stream(std::vector<char> &data);
 
-  bool set_session();
-
   int get_socket() { return m_socket; }
-  bool is_active() { return m_state == client_state::active; }
-  void set_state(const uint8_t &state) { m_state = state; }
+  void set_state(const uint8_t state) { m_state = state; }
+
+  operator bool() const { return m_state == client_state::active; }
 
   static void monitor(client &client) {
-    std::array<char, 4096> buf;
-    while (client.is_active()) {
+    while (!client) std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+    std::array<char, message_len> buf;
+    while (client) {
       int ret = client.read(&buf[0], buf.size());
       if (ret <= 0) {
         io::logger->error("connection lost.");
diff --git a/client/src/client/packet.h b/client/src/client/packet.h
index d60eae7..0a67303 100644
--- a/client/src/client/packet.h
+++ b/client/src/client/packet.h
@@ -2,6 +2,7 @@
 
 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 };
 
@@ -9,10 +10,14 @@ struct packet_t {
   std::string message;
   char action;
   std::string session_id;
+  int id;
 
   packet_t() {}
-  packet_t(const std::string_view msg, const packet_type &type, std::string_view session = "") {
+  packet_t(const std::string_view msg, const packet_type &type,
+           std::string_view session = "") {
     if (type == read) {
+      ++id;
+
       if (msg.size() < session_id_len) {
         io::logger->error("packet message invalid!");
         return;
@@ -26,11 +31,21 @@ struct packet_t {
       session_id = session;
 
       message = fmt::format("{}{}", session_id, msg);
+      
+      if(msg.size() > message_len) {
+        io::logger->error("packet message exceeds limit");
+        message.clear();
+        session_id.clear();
+        return;
+      }
     }
   }
 
-  operator bool() const {
-    return !message.empty() && !session_id.empty();
+  ~packet_t() {
+    message.clear();
+    session_id.clear();
   }
+
+  operator bool() const { return !message.empty() && !session_id.empty(); }
 };
 };  // namespace tcp
diff --git a/client/src/main.cpp b/client/src/main.cpp
index 7177511..48a4e19 100644
--- a/client/src/main.cpp
+++ b/client/src/main.cpp
@@ -4,48 +4,37 @@
 
 int main(int argc, char *argv[]) {
   io::init();
-  
+
   tcp::client client;
 
-  if (client.start("127.0.0.1", 6666)) {
-    if(!client.set_session()) {
-      io::logger->error("failed to set session id.");
-      return 0;
-    }
+  std::thread t{tcp::client::monitor, std::ref(client)};
+  t.detach();
 
+  if (client.start("127.0.0.1", 6666)) {
     io::logger->info("connected.");
     client.set_state(tcp::client_state::active);
   }
 
   client.receive_event.add([&](tcp::packet_t &packet) {
-    if(!packet)
-      return;
-
-    io::logger->info(packet.message);
-    if(packet.message == "stream") {
-      std::vector<char> dat;
-      client.read_stream(dat);
+    if (!packet) return;
 
-      std::ofstream o("out");
-      o.write(dat.data(), dat.size());
-      o.close();
+    // first packet is the session id and current version
+    if (packet.id == 1) {
+      client.session_id = packet.session_id;
+      
     }
-  });
 
-  std::thread t{tcp::client::monitor, std::ref(client)};
+    io::logger->info("{}:{}->{}", packet.id, packet.session_id, packet.message);
+  });
 
-  while (client.is_active()) {
+  while (client) {
     std::string p;
     getline(std::cin, p);
 
-    tcp::packet_t packet(p, tcp::packet_type::write, "1234567890");
-
-    int ret = client.write(packet.message.data(), packet.message.size());
+    int ret = client.write(
+        tcp::packet_t(p, tcp::packet_type::write, client.session_id));
     if (ret <= 0) {
       break;
     }
-
   }
-
-  t.join();
 }
diff --git a/server/src/client/client.cpp b/server/src/client/client.cpp
index 18818e7..5e28f26 100644
--- a/server/src/client/client.cpp
+++ b/server/src/client/client.cpp
@@ -32,7 +32,7 @@ void tcp::client::gen_session() {
   std::default_random_engine e1(r());
   std::uniform_int_distribution<int> gen(33, 126);
 
-  for(int i = 0; i < session_id_len; i++) {
+  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);
   }
diff --git a/server/src/client/client.h b/server/src/client/client.h
index b54cd22..f305638 100644
--- a/server/src/client/client.h
+++ b/server/src/client/client.h
@@ -2,7 +2,6 @@
 #include "../server/packet.h"
 
 namespace tcp {
-constexpr uint8_t client_version = 0;
 
 class client {
   int m_socket;
@@ -14,6 +13,8 @@ class client {
   std::string m_session_id;
 
  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} {}
@@ -28,9 +29,12 @@ class client {
   }
 
   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 read(void *data, size_t size) { return SSL_read(m_ssl, data, size); }
 
   int stream(std::vector<char> &data);
diff --git a/server/src/main.cpp b/server/src/main.cpp
index 1727458..97eac24 100644
--- a/server/src/main.cpp
+++ b/server/src/main.cpp
@@ -12,20 +12,11 @@ int main(int argc, char *argv[]) {
 
   server.connect_event.add([&](tcp::client &client) {
     auto ip = client.get_ip();
-
-    io::logger->info("{} connected", ip);
-
-    // generate unique client session
     client.gen_session();
+    client.write(tcp::packet_t(std::to_string(client.version), tcp::packet_type::write,
+                               client.get_session()));
 
-    auto session = client.get_session();
-
-    io::logger->info("generated session id {} for {}", session,
-                     ip);
-
-    // send the assigned session id to client
-    tcp::packet_t packet(session, tcp::packet_type::write);
-    client.write(packet);
+    io::logger->info("{} connected", ip);
   });
 
   server.disconnect_event.add([&](tcp::client &client) {
@@ -51,19 +42,15 @@ int main(int argc, char *argv[]) {
       return;
     }
 
-    if(packet_session != session) {
+    if (packet_session != session) {
       io::logger->info("{} sent wrong session id", ip);
       return;
     }
 
     io::logger->info("{} : {}", packet_session, packet.message);
 
-    tcp::packet_t resp("stream", tcp::packet_type::write, client.get_session());
+    tcp::packet_t resp(packet.message, tcp::packet_type::write, client.get_session());
     client.write(resp);
-
-    std::vector<char> out;
-    io::read_file("test.dll", out);
-    client.stream(out);
   });
 
   std::thread t{tcp::server::monitor, std::ref(server)};
diff --git a/server/src/server/packet.h b/server/src/server/packet.h
index d60eae7..9ca991d 100644
--- a/server/src/server/packet.h
+++ b/server/src/server/packet.h
@@ -2,6 +2,7 @@
 
 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 };
 
@@ -11,7 +12,8 @@ struct packet_t {
   std::string session_id;
 
   packet_t() {}
-  packet_t(const std::string_view msg, const packet_type &type, std::string_view session = "") {
+  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!");
@@ -23,14 +25,22 @@ struct packet_t {
       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);
     }
   }
 
-  operator bool() const {
-    return !message.empty() && !session_id.empty();
+  ~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 e0262d7..e8e1ce5 100644
--- a/server/src/server/server.cpp
+++ b/server/src/server/server.cpp
@@ -117,7 +117,7 @@ void tcp::server::accept_client() {
 }
 
 void tcp::server::receive() {
-  std::array<char, 4096> buf;
+  std::array<char, message_len> buf;
   for (auto &c : client_stack) {
     const int socket = c.get_socket();
 
diff --git a/server/src/util/io.cpp b/server/src/util/io.cpp
index 1f9bca6..f2da690 100644
--- a/server/src/util/io.cpp
+++ b/server/src/util/io.cpp
@@ -3,18 +3,20 @@
 
 std::shared_ptr<spdlog::logger> io::logger;
 
-void io::init(const bool &trunc) {
-	auto sink =
-      std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+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", trunc);
+  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);
-  log_sinks.emplace_back(file_sink);
 
-  logger = std::make_shared<spdlog::logger>("server", log_sinks.begin(), log_sinks.end());
+  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);
 
   spdlog::flush_every(std::chrono::seconds(1));
diff --git a/server/src/util/io.h b/server/src/util/io.h
index 437b465..7f6e3a8 100644
--- a/server/src/util/io.h
+++ b/server/src/util/io.h
@@ -3,6 +3,6 @@
 namespace io {
 extern std::shared_ptr<spdlog::logger> logger;
 
-void init(const bool &trunc);
+void init(const bool &to_file);
 void read_file(const std::string_view name, std::vector<char> &out);
 };  // namespace io