renaming files and classname for TcpListener

adding new CMake build file
vi .gitignore
oops

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" "tcplistener.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"
+)
+

headers/TcpListener.h

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

main.cpp

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

tcplistener.cpp

@@ -0,0 +1,95 @@
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <iostream>
+#include <string>
+
+#include <sys/socket.h>
+#include "headers/constants.h"
+#include "headers/tcplistener.h"
+int listening() { return socket(AF_INET, SOCK_STREAM, 0); }
+
+TcpListener::TcpListener(std::string ipAddress, int port,
+                         MessageReceivedHandler handler)
+    : m_ipAddress(ipAddress), m_port(port), MessageReceived(handler) {}
+
+// destructor
+TcpListener::~TcpListener() { cleanup(); }
+
+// Send message to client
+void TcpListener::sendMessage(int clientSocket, std::string msg) {
+  send(clientSocket, msg.c_str(), msg.size() + 1, 0);
+}
+
+// Initialize
+bool TcpListener::init() {
+  std::cout << "Initializing socket listener" << std::endl;
+  return true;
+}
+
+// Main process loop
+void TcpListener::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 TcpListener::cleanup() { std::cout << "Cleaning up" << std::endl; }
+
+int TcpListener::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 TcpListener::waitForConnection(int listening) {
+  int client = accept(listening, NULL, NULL);
+  return client;
+}