Finished session/user id generation.

7 files changed, 87 insertions, 58 deletions

diff --git a/client/src/client/client.cpp b/client/src/client/client.cpp
index e224a95..9688543 100644
--- a/client/src/client/client.cpp
+++ b/client/src/client/client.cpp
@@ -39,6 +39,14 @@ bool tcp::client::start(const std::string_view server_ip, const uint16_t port) {
   return true;
 }
 
+bool tcp::client::set_uid() {
+  m_uid.resize(tcp::uid_len);
+
+  int ret = read(&m_uid[0], tcp::uid_len);
+  if(ret != tcp::uid_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 34e761b..992cae6 100644
--- a/client/src/client/client.h
+++ b/client/src/client/client.h
@@ -5,11 +5,7 @@
 
 namespace tcp {
 
-enum client_state : uint8_t {
-	idle = 0,
-	active,
-	standby
-};
+enum client_state : uint8_t { idle = 0, active, standby };
 
 class client {
   int m_socket;
@@ -18,6 +14,7 @@ class client {
   SSL *m_server_ssl;
   SSL_CTX *m_ssl_ctx;
 
+  std::string m_uid;
  public:
   event<packet_t &> receive_event;
 
@@ -34,9 +31,10 @@ class client {
   }
 
   int read_stream(std::vector<char> &out);
-  
   int stream(std::vector<char> &data);
 
+  bool set_uid();
+
   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; }
diff --git a/client/src/main.cpp b/client/src/main.cpp
index c94a866..a9fecec 100644
--- a/client/src/main.cpp
+++ b/client/src/main.cpp
@@ -8,6 +8,11 @@ int main(int argc, char *argv[]) {
   tcp::client client;
 
   if (client.start("127.0.0.1", 6666)) {
+    if(!client.set_uid()) {
+      io::logger->error("failed to set session id.");
+      return 0;
+    }
+
     io::logger->info("connected.");
     client.set_state(tcp::client_state::active);
   }
@@ -16,6 +21,7 @@ int main(int argc, char *argv[]) {
     if(!packet)
       return;
 
+    io::logger->info(packet.message);
     if(packet.message == "stream") {
       std::vector<char> dat;
       client.read_stream(dat);
diff --git a/server/src/client/client.cpp b/server/src/client/client.cpp
index 782017f..c4b4ed6 100644
--- a/server/src/client/client.cpp
+++ b/server/src/client/client.cpp
@@ -17,67 +17,73 @@ bool tcp::client::init_ssl(SSL_CTX *server_ctx) {
 
   ret = SSL_accept(m_ssl);
 
-  long result = SSL_get_verify_result(m_ssl);
-
-  auto str = X509_verify_cert_error_string(result);
-  io::logger->info("verify returned {}", str);
-
   if (ret <= 0) {
     int err = SSL_get_error(m_ssl, ret);
     io::logger->error("client {} failed to accept ssl, return code {}", m_ip,
-                     err);
+                      err);
     return false;
   }
 
   return true;
 }
 
-int tcp::client::stream(std::vector<char> &data) {
-    auto size = data.size();
+void tcp::client::gen_uid() {
+  std::random_device r;
+  std::default_random_engine e1(r());
+  std::uniform_int_distribution<int> gen(33, 126);
 
-    auto networked_size = htonl(size);
-    write(&networked_size, sizeof(networked_size));
+  for(int i = 0; i < uid_len; i++) {
+    auto k = static_cast<char>(gen(e1));
+    m_uid.insert(m_uid.end(), k);
+  }
+}
 
-    // with 4kb chunk size, speed peaks at 90mb/s
-    constexpr size_t chunk_size = 4096;
-    size_t sent = 0;
+int tcp::client::stream(std::vector<char> &data) {
+  auto size = data.size();
 
-    while(size > 0) {
-      auto to_send = std::min(size, chunk_size);
+  auto networked_size = htonl(size);
+  write(&networked_size, sizeof(networked_size));
 
-      int ret = write(&data[sent], to_send);
-      if(ret <= 0) {
-        break;
-      }
+  // with 4kb chunk size, speed peaks at 90mb/s
+  constexpr size_t chunk_size = 4096;
+  size_t sent = 0;
 
-      sent += ret;
-      size -= ret;
+  while (size > 0) {
+    auto to_send = std::min(size, chunk_size);
+
+    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;
+}
+
+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;
-    
-    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;
-  }
\ No newline at end of file
+    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 28094ba..106b2c1 100644
--- a/server/src/client/client.h
+++ b/server/src/client/client.h
@@ -28,17 +28,18 @@ class client {
   }
 
   int write(void *data, size_t size) { return SSL_write(m_ssl, data, size); }
-
+  int write(const packet_t &packet) {
+    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);
-
   int read_stream(std::vector<char> &out);
 
-  void set_uid(const std::string_view uid_str) { m_uid = uid_str; }
+  void gen_uid();
 
-  int &get_socket() { return m_socket; }
-  auto &get_ip() { return m_ip; }
-  auto &get_uid() { return m_uid; }
+  int get_socket() { return m_socket; }
+  auto get_ip() { return m_ip; }
+  auto get_uid() { return m_uid; }
 };
 };  // namespace tcp
\ No newline at end of file
diff --git a/server/src/main.cpp b/server/src/main.cpp
index 21cad38..1dfdb39 100644
--- a/server/src/main.cpp
+++ b/server/src/main.cpp
@@ -12,12 +12,23 @@ int main(int argc, char *argv[]) {
 
   server.connect_event.add([&](tcp::client &client) {
     io::logger->info("{} connected.", client.get_ip());
+
+    // generate unique client uid
+    client.gen_uid();
+
+    io::logger->info("generated session id {} for {}", client.get_uid(),
+                     client.get_ip());
+
+    // send the assigned uid to client
+    tcp::packet_t packet(client.get_uid(), tcp::packet_type::write);
+    client.write(packet);
   });
 
   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();
-    });
+    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();
@@ -31,12 +42,11 @@ int main(int argc, char *argv[]) {
     io::logger->info("{} : {}", packet.uid.data(), packet.message);
 
     tcp::packet_t resp("stream", tcp::packet_type::write, "1234567890");
-    client.write(resp.message.data(), resp.message.size());
+    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/server.cpp b/server/src/server/server.cpp
index b140665..e0262d7 100644
--- a/server/src/server/server.cpp
+++ b/server/src/server/server.cpp
@@ -128,7 +128,7 @@ void tcp::server::receive() {
     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);
 
       receive_event.call(packet, c);