Renamed uid to session id.

4 files changed, 45 insertions, 30 deletions

diff --git a/server/src/client/client.cpp b/server/src/client/client.cpp
index c4b4ed6..18818e7 100644
--- a/server/src/client/client.cpp
+++ b/server/src/client/client.cpp
@@ -27,14 +27,14 @@ bool tcp::client::init_ssl(SSL_CTX *server_ctx) {
   return true;
 }
 
-void tcp::client::gen_uid() {
+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 < uid_len; i++) {
+  for(int i = 0; i < session_id_len; i++) {
     auto k = static_cast<char>(gen(e1));
-    m_uid.insert(m_uid.end(), k);
+    m_session_id.insert(m_session_id.end(), k);
   }
 }
 
diff --git a/server/src/client/client.h b/server/src/client/client.h
index 106b2c1..b54cd22 100644
--- a/server/src/client/client.h
+++ b/server/src/client/client.h
@@ -11,7 +11,7 @@ class client {
   time_t m_time;
 
   std::string m_ip;
-  std::string m_uid;
+  std::string m_session_id;
 
  public:
   client() : m_socket{-1} {};
@@ -36,10 +36,10 @@ class client {
   int stream(std::vector<char> &data);
   int read_stream(std::vector<char> &out);
 
-  void gen_uid();
+  void gen_session();
 
   int get_socket() { return m_socket; }
   auto get_ip() { return m_ip; }
-  auto get_uid() { return m_uid; }
+  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 1dfdb39..1727458 100644
--- a/server/src/main.cpp
+++ b/server/src/main.cpp
@@ -11,16 +11,20 @@ int main(int argc, char *argv[]) {
   server.start();
 
   server.connect_event.add([&](tcp::client &client) {
-    io::logger->info("{} connected.", client.get_ip());
+    auto ip = client.get_ip();
 
-    // generate unique client uid
-    client.gen_uid();
+    io::logger->info("{} connected", ip);
 
-    io::logger->info("generated session id {} for {}", client.get_uid(),
-                     client.get_ip());
+    // generate unique client session
+    client.gen_session();
 
-    // send the assigned uid to client
-    tcp::packet_t packet(client.get_uid(), tcp::packet_type::write);
+    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);
   });
 
@@ -33,15 +37,28 @@ int main(int argc, char *argv[]) {
     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) {
-    if (!packet) return;
+    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_session != session) {
+      io::logger->info("{} sent wrong session id", ip);
+      return;
+    }
 
-    io::logger->info("{} : {}", packet.uid.data(), packet.message);
+    io::logger->info("{} : {}", packet_session, packet.message);
 
-    tcp::packet_t resp("stream", tcp::packet_type::write, "1234567890");
+    tcp::packet_t resp("stream", tcp::packet_type::write, client.get_session());
     client.write(resp);
 
     std::vector<char> out;
diff --git a/server/src/server/packet.h b/server/src/server/packet.h
index 09eaf1d..d60eae7 100644
--- a/server/src/server/packet.h
+++ b/server/src/server/packet.h
@@ -1,38 +1,36 @@
 #pragma once
 
 namespace tcp {
-constexpr size_t uid_len = 10;
+constexpr size_t session_id_len = 10;
 
 enum packet_type : int { write = 0, read };
 
 struct packet_t {
   std::string message;
   char action;
-  std::string uid;
+  std::string session_id;
 
   packet_t() {}
-  packet_t(const std::string msg, const packet_type &type, std::string userid = "") {
+  packet_t(const std::string_view msg, const packet_type &type, std::string_view session = "") {
     if (type == read) {
-      if (msg.size() < uid_len) {
-        io::logger->error("client packet message invalid!");
+      if (msg.size() < session_id_len) {
+        io::logger->error("packet message invalid!");
         return;
       }
 
-      uid = msg.substr(0, uid_len);
+      session_id = msg.substr(0, session_id_len);
 
-      action = msg[uid_len];
-      message = msg.substr(uid_len);
+      action = msg[session_id_len];
+      message = msg.substr(session_id_len);
     } else {
-      uid = userid;
+      session_id = session;
 
-      message = fmt::format("{}{}", uid, msg);
+      message = fmt::format("{}{}", session_id, msg);
     }
   }
 
-  
-
   operator bool() const {
-    return !message.empty() && !uid.empty();
+    return !message.empty() && !session_id.empty();
   }
 };
 };  // namespace tcp