removed unnecessary imports

slight restructuring

headers/interface/listen_interface.hpp

@@ -16,7 +16,9 @@
 class ListenInterface {
  public:
   virtual void onMessageReceived(int client_socket_fd,
-                                 std::weak_ptr<uint8_t[]> w_buffer_ptr) = 0;
+                                 std::weak_ptr<uint8_t[]> w_buffer_ptr,
+                                 ssize_t& size) = 0;
+  virtual void onConnectionClose(int client_socket_fd) = 0;
 };
 
 #endif  // __LISTEN_INTERFACE_H__

headers/socket_listener.hpp

@@ -1,12 +1,12 @@
-#ifndef __SOCKET_LISTENER_H__
-#define __SOCKET_LISTENER_H__
+#ifndef __SOCKET_LISTENER_HPP__
+#define __SOCKET_LISTENER_HPP__
 
 // Project libraries
-#include "interface/listen_interface.hpp"
-#include "interface/send_interface.hpp"
-#include "task_queue.hpp"
-#include "types.hpp"
-
+#include <interface/listen_interface.hpp>
+#include <interface/send_interface.hpp>
+#include <task_queue.hpp>
+#include <types.hpp>
+#include <constants.hpp>
 // System libraries
 #include <sys/socket.h>
 
@@ -35,12 +35,12 @@ class SocketListener : public SendInterface, public ListenInterface {
    */
   class MessageHandler {
    public:
-    MessageHandler(std::function<void()> cb) : m_cb(cb) {}
+    MessageHandler(std::function<void(ssize_t)> cb) : m_cb(cb) {}
 
-    void operator()() { m_cb(); }
+    void operator()(ssize_t size) { m_cb(size); }
 
    private:
-    std::function<void()> m_cb;
+    std::function<void(ssize_t)> m_cb;
   };
   // constructor
   SocketListener(int arg_num, char** args);
@@ -62,7 +62,7 @@ class SocketListener : public SendInterface, public ListenInterface {
 
   void sendMessage(int client_socket_fd, const char* message, size_t size);
 
-  MessageHandler createMessageHandler(std::function<void()> cb);
+  MessageHandler createMessageHandler(std::function<void(ssize_t)> cb);
   /**
    * Perform intialization work
    */
@@ -82,8 +82,11 @@ class SocketListener : public SendInterface, public ListenInterface {
   // private methods
   int createSocket();
 
-  virtual void onMessageReceived(
-      int client_socket_fd, std::weak_ptr<uint8_t[]> w_buffer_ptr) override;
+  virtual void onMessageReceived(int client_socket_fd,
+                                 std::weak_ptr<uint8_t[]> w_buffer_ptr,
+                                 ssize_t& size) override;
+
+  virtual void onConnectionClose(int client_socket_fd) override;
 
   int waitForConnection(int listening);
 
@@ -98,4 +101,4 @@ class SocketListener : public SendInterface, public ListenInterface {
   std::unique_ptr<TaskQueue> u_task_queue_ptr;
 };
 
-#endif  // __SOCKET_LISTENER_H__
+#endif  // __SOCKET_LISTENER_HPP__

headers/types.hpp

@@ -3,7 +3,7 @@
 
 #include <string>
 
-#define MAX_BUFFER_SIZE (49152)
+#define MAX_BUFFER_SIZE (4096)
 #define SMALL_BUFFER_SIZE (8192)
 
 template <typename MessageProcessor>

src/socket_listener.cpp

@@ -1,7 +1,5 @@
 // Project headers
-#include "../headers/socket_listener.hpp"
-
-#include "../headers/constants.hpp"
+#include <socket_listener.hpp>
 // System libraries
 #include <arpa/inet.h>
 #include <netdb.h>
@@ -10,16 +8,9 @@
 #include <sys/types.h>
 #include <unistd.h>
 // C++ Libraries
-#include <atomic>
-#include <chrono>
-#include <condition_variable>
-#include <functional>
 #include <iostream>
 #include <memory>
-#include <queue>
 #include <string>
-#include <thread>
-#include <vector>
 
 /**
  * Constructor
@@ -53,16 +44,21 @@ SocketListener::SocketListener(int arg_num, char** args) : m_port(-1) {
 SocketListener::~SocketListener() { cleanup(); }
 
 SocketListener::MessageHandler SocketListener::createMessageHandler(
-    std::function<void()> cb) {
+    std::function<void(ssize_t)> cb) {
   return MessageHandler(cb);
 }
 
 void SocketListener::onMessageReceived(int client_socket_fd,
-                                       std::weak_ptr<uint8_t[]> w_buffer_ptr) {
+                                       std::weak_ptr<uint8_t[]> w_buffer_ptr,
+                                       ssize_t& size) {
   std::cout << "This should be overridden" << std::endl;
   sendMessage(client_socket_fd, w_buffer_ptr);
 }
 
+void SocketListener::onConnectionClose(int client_socket_fd) {
+  std::cout << "This should be overridden" << std::endl;
+}
+
 /**
  * sendMessage
  * @method
@@ -119,24 +115,22 @@ void SocketListener::handleClientSocket(
   for (;;) {
     memset(s_buffer_ptr.get(), 0,
            MAX_BUFFER_SIZE);  // Zero the character buffer
-    int bytes_received = 0;
     // Receive and write incoming data to buffer and return the number of
     // bytes received
-    bytes_received =
-        recv(client_socket_fd, s_buffer_ptr.get(),
-             MAX_BUFFER_SIZE - 2,  // Leave room for null-termination
-             0);
-    s_buffer_ptr.get()[MAX_BUFFER_SIZE - 1] =
-        0;  // Null-terminate the character buffer
-    if (bytes_received > 0) {
-      std::cout << "Client " << client_socket_fd
-                << "\nBytes received: " << bytes_received
-                << "\nData: " << s_buffer_ptr.get() << std::endl;
+    ssize_t size = recv(client_socket_fd, s_buffer_ptr.get(),
+                        MAX_BUFFER_SIZE,  // Leave room for null-termination ?
+                        0);
+    //    s_buffer_ptr.get()[MAX_BUFFER_SIZE - 1] =
+    //        0;  // Null-terminate the character buffer
+    if (size > 0) {
+      std::cout << "Client " << client_socket_fd << "\nBytes received: " << size
+                << "\nData: " << std::hex << s_buffer_ptr.get() << std::endl;
       // Handle incoming message
-      message_handler();
+      message_handler(size);
     } else {
       std::cout << "Client " << client_socket_fd << " disconnected"
                 << std::endl;
+      onConnectionClose(client_socket_fd);
       // Zero the buffer again before closing
       memset(s_buffer_ptr.get(), 0, MAX_BUFFER_SIZE);
       break;
@@ -174,10 +168,12 @@ void SocketListener::run() {
       {
         std::shared_ptr<uint8_t[]> s_buffer_ptr(new uint8_t[MAX_BUFFER_SIZE]);
         std::weak_ptr<uint8_t[]> w_buffer_ptr(s_buffer_ptr);
-        std::function<void()> message_send_fn = [this, client_socket_fd,
-                                                 w_buffer_ptr]() {
-          this->onMessageReceived(client_socket_fd, w_buffer_ptr);
-        };
+        // TODO: Stop the use of this size variable, by changing the
+        // specification of handleClientSocket
+        std::function<void(ssize_t)> message_send_fn =
+            [this, client_socket_fd, w_buffer_ptr](ssize_t size) {
+              this->onMessageReceived(client_socket_fd, w_buffer_ptr, size);
+            };
         MessageHandler message_handler = createMessageHandler(message_send_fn);
         std::cout << "Pushing client to queue" << std::endl;
         u_task_queue_ptr->pushToQueue(

src/task_queue.cpp

@@ -1,4 +1,4 @@
-#include "../headers/task_queue.hpp"
+#include <task_queue.hpp>
 
 #include <iostream>