Finished session id on client and server.

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

4 files changed, 49 insertions, 45 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();
 }