Merge pull request #1 from adventurist/overridable

Modernizing and making more extensible

.gitignore

@@ -0,0 +1,6 @@
+Makefile
+CMakeCache.txt
+CMakeFiles
+*.cmake
+tags
+ws_server

CMakeLists.txt

@@ -1,7 +1,10 @@
 cmake_minimum_required(VERSION 2.8)
-
-set(SOURCES "main.cpp" "TcpListener.cpp")
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall")
-
 project(ws_server)
+
+set(SOURCES "main.cpp" "socket_listener.cpp")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -std=c++17")
 add_executable(${PROJECT_NAME} ${SOURCES})
+target_include_directories(${PROJECT_NAME} PRIVATE
+  "headers"
+)
+

README.md

@@ -0,0 +1,3 @@
+# WS Server
+
+Websocket server implementation written from scratch, with help from ...

TcpListener.cpp

@@ -1,105 +0,0 @@
-#include <iostream>
-#include <sys/types.h>
-#include <unistd.h>
-#include <netdb.h>
-#include <arpa/inet.h>
-#include <string.h>
-#include <string>
-
-#include "headers/TcpListener.h"
-#include "headers/constants.h"
-#include <sys/socket.h>
-int listening () {
-    return socket(AF_INET, SOCK_STREAM, 0);
-}
-
-CTcpListener::CTcpListener(std::string ipAddress, int port, MessageReceivedHandler handler)
-  : m_ipAddress(ipAddress), m_port(port), MessageReceived(handler) {
-
-}
-
-
-    // destructor
-CTcpListener::~CTcpListener() {
-  cleanup();
-}
-
-// Send message to client
-void CTcpListener::sendMessage(int clientSocket, std::string msg) {
-  send(clientSocket, msg.c_str(), msg.size() +1, 0);
-}
-
-// Initialize
-bool CTcpListener::init() {
-  std::cout << "Initializing socket listener" << std::endl;
-  return true;
-}
-
-// Main process loop
-void CTcpListener::run() {
-
-  char* buf[MAX_BUFFER_SIZE];
-
-  while (true) {
-    int listening = createSocket();
-
-    if (listening == SOCKET_ERROR) {
-      std::cout << "Socket error: shutting down server" << std::endl;
-      break;
-    }
-    int socket = waitForConnection(listening);
-
-    if (socket != SOCKET_ERROR) {
-      close(listening);
-
-      while (true) {
-        memset(buf, 0, MAX_BUFFER_SIZE);
-        int bytesReceived = 0;
-        bytesReceived = recv(socket, buf, MAX_BUFFER_SIZE, 0);
-        if (bytesReceived > 0) {
-            const char* constString = (const char*) buf;
-            std::cout << "Received: " << constString << std::endl;
-            MessageReceived(this, socket, std::string(constString));
-        } else {
-            std::cout << "client disconnected" << std::endl;
-            break;
-        }
-      }
-      close(socket);
-    }
-  }
-}
-
-// Cleanup
-void CTcpListener::cleanup() {
-  std::cout << "Cleaning up" << std::endl;
-}
-
-int CTcpListener::createSocket() {
-  int listening = socket(AF_INET, SOCK_STREAM, 0);
-
-  if (listening != SOCKET_ERROR) {
-
-    sockaddr_in hint;
-    hint.sin_family = AF_INET;
-    hint.sin_port = htons(m_port);
-    inet_pton(AF_INET, m_ipAddress.c_str(), &hint.sin_addr);
-
-    int bindOk = bind(listening, (sockaddr*)&hint, sizeof(hint));
-    if (bindOk != SOCKET_ERROR) {
-      int listenOk = listen(listening, SOMAXCONN);
-      if (listenOk == SOCKET_ERROR) {
-        return -1;
-      }
-    } else {
-      return -1;
-    }
-  }
-
-  return listening;
-}
-
-int CTcpListener::waitForConnection(int listening) {
-  int client = accept(listening, NULL, NULL);
-  return client;
-}

headers/TcpListener.h

@@ -1,42 +0,0 @@
-#include <string>
-#include <sys/socket.h>
-
-#define MAX_BUFFER_SIZE (49152)
-class CTcpListener;
-
-typedef void (*MessageReceivedHandler)(CTcpListener* listener, int socketId, std::string msg);
-
-class CTcpListener {
-  public:
-    // constructor
-    CTcpListener(std::string ipAddress, int port, MessageReceivedHandler handler);
-
-    // destructor
-    ~CTcpListener();
-
-    // public methods
-
-    // Send message to client
-    void sendMessage(int clientSocket, std::string msg);
-
-    // Initialize
-    bool init();
-
-    // Main process loop
-    void run();
-
-    // Cleanup
-    void cleanup();
-
-
-  private:
-  // private methods
-  int createSocket();
-
-  int waitForConnection(int listening);
-
-  // private members
-  std::string             m_ipAddress;
-  int                     m_port;
-  MessageReceivedHandler  MessageReceived;
-};

headers/constants.h

@@ -1,7 +1,17 @@
-#if !defined(TRX_SOCKET_CONSTANTS)
+#ifndef __CONSTANTS_H__
+#define __CONSTANTS_H__
+#ifndef TRX_SOCKET_CONSTANTS
 #define TRX_SOCKET_CONSTANTS 1
-
-int const SOCKET_ERROR = -1;
-int const SOCKET_OK = 0;
+/**
+ * Values used when attempting to open a socket
+ */
+const int SOCKET_ERROR = -1;
+const int SOCKET_OK = 0;
+/**
+ * Values used when listening for connections to a socket
+ */
+const int WAIT_SOCKET_FAILURE = -1;
+const int WAIT_SOCKET_SUCCESS = 0;
 
 #endif
+#endif  // __CONSTANTS_H__

headers/listen_interface.h

@@ -0,0 +1,11 @@
+#ifndef __LISTEN_INTERFACE_H__
+#define __LISTEN_INTERFACE_H__
+
+#include <string>
+
+class ListenInterface {
+ public:
+  virtual void onMessageReceived(int socket_id, std::string message) = 0;
+};
+
+#endif  // __LISTEN_INTERFACE_H__

headers/send_interface.h

@@ -0,0 +1,11 @@
+#ifndef __SEND_INTERFACE_H__
+#define __SEND_INTERFACE_H__
+
+#include <string>
+
+class SendInterface {
+  public:
+    virtual void sendMessage(int client_socket_fd, std::string message) = 0;
+};
+
+#endif  // __SEND_INTERFACE_H__

headers/socket_listener.h

@@ -0,0 +1,58 @@
+#ifndef __SOCKET_LISTENER_H__
+#define __SOCKET_LISTENER_H__
+// Project libraries
+#include "listen_interface.h"
+#include "send_interface.h"
+
+// System libraries
+#include <sys/socket.h>
+
+// C++ Libraries
+#include <string>
+
+#define MAX_BUFFER_SIZE (49152)
+
+class SocketListener : public ListenInterface, public SendInterface {
+ public:
+  // constructor
+  SocketListener(std::string ipAddress, int port);
+
+  // destructor
+  ~SocketListener();
+
+  /**
+   * Send a message to a client socket described by its file descriptor
+   * @param[in] {int} client_socket_fd The client socket file descriptor
+   * @param[in] {std::string} The message to be sent
+   */
+  virtual void sendMessage(int client_socket_fd, std::string message) override;
+
+  /**
+   * Perform intialization work
+   */
+  bool init();
+
+  /**
+   * Main message loop
+   */
+  void run();
+
+  /**
+   * Perform any cleanup work
+   */
+  void cleanup();
+
+  virtual void onMessageReceived(int socket_id, std::string message) override;
+
+ private:
+  // private methods
+  int createSocket();
+
+  int waitForConnection(int listening);
+
+  // private members
+  std::string m_ip_address;
+  int m_port;
+};
+
+#endif  // __SOCKET_LISTENER_H__

main.cpp

@@ -1,11 +1,9 @@
 #include <iostream>
 #include <string>
-#include "headers/TcpListener.h"
+#include "headers/socket_listener.h"
 
-void Listener_MessageReceived(CTcpListener* listener, int client, std::string msg);
-
-int main () {
-  CTcpListener server("0.0.0.0", 9009, Listener_MessageReceived);
+int main() {
+  SocketListener server("0.0.0.0", 9009);
 
   if (server.init()) {
     server.run();
@@ -13,6 +11,3 @@ int main () {
   return 0;
 }
 
-void Listener_MessageReceived(CTcpListener* listener, int client, std::string msg) {
-  listener->sendMessage(client, msg);
-}

socket_listener.cpp

@@ -0,0 +1,163 @@
+// Project headers
+#include "headers/socket_listener.h"
+
+#include "headers/constants.h"
+// System libraries
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+// C++ Libraries
+#include <iostream>
+#include <string>
+
+/**
+ * Constructor
+ * Initialize with ip_address and port
+ */
+SocketListener::SocketListener(std::string ip_address, int port)
+    : m_ip_address(ip_address), m_port(port) {}
+
+/**
+ * Destructor
+ * TODO: Determine if we should make buffer a class member
+ */
+SocketListener::~SocketListener() { cleanup(); }
+
+/**
+ * sendMessage
+ * @method
+ * Send a null-terminated array of characters, supplied as a const char pointer,
+ * to a client socket described by its file descriptor
+ */
+void SocketListener::sendMessage(int client_socket_fd, std::string message) {
+  send(client_socket_fd, message.c_str(), message.size() + 1, 0);
+}
+
+/**
+ * init
+ * TODO: Initialize buffer memory, if buffer is to be a class member
+ */
+bool SocketListener::init() {
+  std::cout << "Initializing socket listener" << std::endl;
+  return true;
+}
+
+/**
+ * run
+ * @method
+ * Main message loop
+ * TODO: Implement multithreading
+ */
+void SocketListener::run() {
+  // Declare, define and initialize a character buffer
+  char buf[MAX_BUFFER_SIZE] = {};
+  // Begin listening loop
+  while (true) {
+    // Call system to open a listening socket, and return its file descriptor
+    int listening_socket_fd = createSocket();
+
+    if (listening_socket_fd == SOCKET_ERROR) {
+      std::cout << "Socket error: shutting down server" << std::endl;
+      break;
+    }
+    // wait for a client connection and get its socket file descriptor
+    int client_socket_fd = waitForConnection(listening_socket_fd);
+
+    if (client_socket_fd != SOCKET_ERROR) {
+      // Destroy listening socket and deallocate its file descriptor. Only use
+      // the client socket now.
+      close(listening_socket_fd);
+      std::string buffer_string{};  // Initialize a string buffer
+      while (true) {
+        memset(buf, 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, buf,
+                 MAX_BUFFER_SIZE - 2,  // Leave room for null-termination
+                 0);
+        buf[MAX_BUFFER_SIZE - 1] = 0;  // Null-terminate the character buffer
+        if (bytes_received > 0) {
+          buffer_string += buf;
+          std::cout << "Bytes received: " << bytes_received << "\nData: " << buf
+                    << std::endl;
+          // Handle incoming message
+          onMessageReceived(client_socket_fd, std::string(buf));
+        } else {
+          std::cout << "client disconnected" << std::endl;
+          break;
+        }
+      }
+      // Zero the buffer again before closing
+      memset(buf, 0, MAX_BUFFER_SIZE);
+      // TODO: Determine if we should free memory, or handle as class member
+      close(client_socket_fd);  // Destroy client socket and deallocate its fd
+    }
+  }
+}
+
+/**
+ * cleanUp
+ * @method
+ * TODO: Determine if we should be cleaning up buffer memory
+ */
+void SocketListener::cleanup() { std::cout << "Cleaning up" << std::endl; }
+/**
+ * createSocket
+ * Open a listening socket and return its file descriptor
+ */
+int SocketListener::createSocket() {
+  /* Call the system to open a socket passing arguments for
+   ipv4 family, tcp type and no additional protocol info */
+  int listening_socket_fd = socket(AF_INET, SOCK_STREAM, 0);
+
+  if (listening_socket_fd != SOCKET_ERROR) {
+    // Create socket structure to hold address and type
+    sockaddr_in socket_struct;
+    socket_struct.sin_family = AF_INET;  // ipv4
+    socket_struct.sin_port =
+        htons(m_port);  // convert byte order of port value from host to network
+    inet_pton(AF_INET, m_ip_address.c_str(),  // convert address to binary
+              &socket_struct.sin_addr);
+    // Bind local socket address to socket file descriptor
+    int bind_result = bind(
+        listening_socket_fd,         // TODO: Use C++ cast on next line?
+        (sockaddr *)&socket_struct,  // cast socket_struct to more generic type
+        sizeof(socket_struct));
+    if (bind_result != SOCKET_ERROR) {
+      // Listen for connections to socket and allow up to max number of
+      // connections for queue
+      int listen_result = listen(listening_socket_fd, SOMAXCONN);
+      if (listen_result == SOCKET_ERROR) {
+        return WAIT_SOCKET_FAILURE;
+      }
+    } else {
+      return WAIT_SOCKET_FAILURE;
+    }
+  }
+  return listening_socket_fd;  // Return socket file descriptor
+}
+/**
+ * waitForConnection
+ * @method
+ * Takes first connection on queue of pending connections, creates a new socket
+ * and returns its file descriptor
+ */
+int SocketListener::waitForConnection(int listening_socket) {
+  int client_socket_fd = accept(listening_socket, NULL, NULL);
+  return client_socket_fd;
+}
+/**
+ * onMessageReceived
+ * @method
+ * @override
+ * Handle messages successfully received from a client socket
+ */
+void SocketListener::onMessageReceived(int socket_id, std::string message) {
+  sendMessage(socket_id, message);
+}
+