Add signal handling

ctest/main.cpp

@@ -12,8 +12,13 @@
 #include <tuple>
 #include <utility>
 #include <complex>
+#include <csignal>
 #include <common/callback.hpp>
 
+
+bool registerSignalHandler(void);             // registers a Control-c handler
+void signalHandler(int signal);               // The Control-C handler
+
 class Info
 {
   public:
@@ -104,6 +109,11 @@ void Monitor::doCallback(CallbackData<Info> &callbackData)
 
 int main(int argc, char ** argv)
 {
+    registerSignalHandler();
+    while(true)
+    {
+      // do stuff
+    }
     // std::vector<int> myBigVec(10000000, 2011);
     // std::vector<std::string> s1;
     // std::vector<std::string> s2;
@@ -114,21 +124,42 @@ int main(int argc, char ** argv)
     // s2 = std::move(s1);
 
 
-  Monitor monitor;
+  // Monitor monitor;
-//  SmartPointer<B> b(::new B(),PointerDisposition::Delete);
+  // SmartPointer<B> b(true);
-  SmartPointer<B> b(true);
+  // Callback<B,Info> callback(&(*b),&B::callback);
-  Callback<B,Info> callback(&(*b),&B::callback);
+  // monitor.setCallback(callback);
-  monitor.setCallback(callback);
 
-  Info info;
+  // Info info;
-  info.setMessage("Hello");
+  // info.setMessage("Hello");
 
-  CallbackData<Info> callbackData(info);
+  // CallbackData<Info> callbackData(info);
-  monitor.doCallback(callbackData);
+  // monitor.doCallback(callbackData);
 
 }
 
+/// @brief The signal handler
+void signalHandler(int signal)
+{
+  std::cout << "Received signal " << signal << std::endl;
+  exit(signal);
+}
 
+/// @brief Method that registers the signal handler
+/// @param  
+bool registerSignalHandler(void)
+{
+  struct sigaction sa;
+  sa.sa_handler = signalHandler; 
+  sigemptyset(&sa.sa_mask);   // Clear the mask of blocked signals
+  sa.sa_flags = 0;            // No special flags
+
+  if (-1==sigaction(SIGINT, &sa, nullptr))
+  {
+    std::cerr << "Error registering SIGINT handler." << std::endl;
+    return false;
+  }  
+  return true;
+}
 
 
 

sstp/clientsocketsender.cpp

@@ -1,5 +1,8 @@
 #include <sstp/clientsocketsender.hpp>
 
+/// @brief Establish a connection to the socket specified by ipAddress and port
+/// @param ipAddress The ipAddress
+/// @param port  The port
 ClientSocketSender::ClientSocketSender(String ipAddress, int port)
 : mIPAddress(ipAddress), mPort(port)
 {
@@ -26,11 +29,15 @@ ClientSocketSender::ClientSocketSender(String ipAddress, int port)
     }
 }
 
+
+/// @brief Close the connection on destruction
 ClientSocketSender::~ClientSocketSender()
 {
   close();
 }
 
+/// @brief Closes the connection
+/// @param  
 void ClientSocketSender::close(void)
 {
   if(-1!=mSocket)
@@ -40,6 +47,9 @@ void ClientSocketSender::close(void)
   }
 }
   
+/// @brief Send the specified file through the connection
+/// @param pathFileName The file to send
+/// @return Returns true if successful
 bool ClientSocketSender::sendFile(String &pathFileName)
 {
   Profiler profiler;

sstp/clientsocketsender.hpp

@@ -1,5 +1,5 @@
-#ifndef _LISTENER_CLIENTSOCKETSENDER_HPP_
+#ifndef _SSTP_CLIENTSOCKETSENDER_HPP_
-#define _LISTENER_CLIENTSOCKETSENDER_HPP_
+#define _SSTP_CLIENTSOCKETSENDER_HPP_
 #include <stdio.h>
 #include <iostream>
 #include <sys/types.h>
@@ -21,8 +21,7 @@ class ClientSocketSender
   bool sendFile(String &pathFileName);
   bool isOkay(void);
   private:
-//    static constexpr int BUFFER_LENGTH=65536;
+    static constexpr int BUFFER_LENGTH=1048576; // This buffer length is used for both reading the file and also the packet transmission length 
-    static constexpr int BUFFER_LENGTH=1048576;
     void close(void);
     bool sendPacketIndicator(DWORD bytesToSend);
     bool sendPacket(Array<char> &buffer,DWORD bytesToSend);

sstp/main.cpp

@@ -4,6 +4,7 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <unistd.h>
+#include <csignal>
 #include <arpa/inet.h>
 #include <thread>
 #include <vector>
@@ -15,22 +16,27 @@
 #include <sstp/socketserver.hpp>
 #include <sstp/clientsocketsender.hpp>
 
-// https://www.man7.org/linux/man-pages/man2/accept.2.html
+void handleServer(Block<String> &commands);   // handler for server mode
-
+void handleClient(Block<String> &commands);   // handler for client mode
-void handleServer(Block<String> &commands);
+bool registerSignalHandler(void);             // registers a Control-c handler
-void handleClient(Block<String> &commands);
+void signalHandler(int signal);               // The Control-C handler
 
 /// @brief 
 /// @param argc 
 /// @param argv [0] program. [1] SERVERMODE {port} [2] CLIENTMODE {serveripaddress} {serverport} SEND {FileName}
-/// @return 
+/// @return -1:Error 1:Success
 int main(int argc, char **argv)
 {
   int returnCode(0);
   Profiler profiler;
-  String version = "1.00";
+  String version = "0.1.0.3";   // major version, minor version, patch, build
 
   std::cout << "sstp version " << version.str() << std::endl;  
+  if(!registerSignalHandler())
+  {
+    std::cout << "Unable to register CTRL-C handler" << std::endl;
+    return -1;
+  }
   try
   {
     if(argc<2)
@@ -77,7 +83,36 @@ int main(int argc, char **argv)
   return returnCode;
 }
 
+/// @brief The signal handler
+/// TODO: If we are sending then we need to destroy the sender, if we are listening then we need to destroy the listener
+/// Currently we exit the app without cleaning anything up.
+void signalHandler(int signal)
+{
+  std::cout << "SSTP Received signal " << signal << std::endl;
+  exit(signal);
+}
+
+/// @brief Method that registers the signal handler
+/// @param  
+bool registerSignalHandler(void)
+{
+  struct sigaction sa;
+  sa.sa_handler = signalHandler; 
+  sigemptyset(&sa.sa_mask);   // Clear the mask of blocked signals
+  sa.sa_flags = 0;            // No special flags
+
+  if (-1==sigaction(SIGINT, &sa, nullptr))
+  {
+    std::cerr << "Error registering SIGINT handler." << std::endl;
+    return false;
+  }  
+  return true;
+}
+
+
 /// @brief [0]=program [1]=SERVERMODE [2]={port}
+/// @Note Currently this method will never return.  The application is terminate with CTRL-C.  Ideally, we would exit is some cleaner fashion
+/// perhaps by implementing a CTRL-C hook and then destroying the SocketServer properly by calling it's destructor.  See SocketServer::~SocketServer()
 /// @param commands 
 void handleServer(Block<String> &commands)
 {
@@ -91,7 +126,7 @@ void handleServer(Block<String> &commands)
   int port = commands[2].toInt();
   std::cout << commands[1] << ":" << commands[2] << std::endl;
   SocketServer socketServer(commands[2].toInt());
-  socketServer.listen();
+  socketServer.listen();    
   std::cout << "Done, total took " << Utility::formatNumber(profiler.end()) << "(ms)" << std::endl;
 }
 

sstp/socketconnectionreceiver.cpp

@@ -2,15 +2,41 @@
 #include <common/utility.hpp>
 #include <common/stringbuffer.hpp>
 
+
+SocketConnectionReceiver::SocketConnectionReceiver()
+: mSocket(-1), mIsRunnable(true)
+{
+}
+
+
+/// @brief After a connection has been accepted the SocketConnectionReceiver is initialized with the incoming socket
+/// @param socket 
+/// @param internalSocketAddress 
 SocketConnectionReceiver::SocketConnectionReceiver(int socket, sockaddr_in internalSocketAddress)
-: mSocket(socket), mInternalSocketAddress(internalSocketAddress)
+: mSocket(socket), mInternalSocketAddress(internalSocketAddress), mIsRunnable(true)
 {
 }
 
+/// @brief Initialize a SocketConnectionReceiver.
+/// @param socket 
+/// @param internalSocketAddress 
+void SocketConnectionReceiver::initialize(int socket, sockaddr_in internalSocketAddress)
+{
+  close();
+  mSocket=socket;
+  mInternalSocketAddress = internalSocketAddress;
+}
+
+
+/// @brief The destructor will close the socket
 SocketConnectionReceiver::~SocketConnectionReceiver()
-{
+{ 
+  isRunnable(false);
+  close();
 }
 
+/// @brief Close the socket and set the mSocket variable to -1
+/// @param  
 void SocketConnectionReceiver::close(void)
 {
   if(-1==mSocket)return;
@@ -19,10 +45,12 @@ void SocketConnectionReceiver::close(void)
   mSocket=-1;
 }
 
+/// @brief The threadFunction will handle the lifetime of the socket connection.  When a QUIT is received the socket will be closed and the thread method will exit
+/// @param data 
 void SocketConnectionReceiver::threadFunction(int data)
 {
   String line;
-  while(true)
+  while(mIsRunnable)
   {
     readLine(line);
     if(0==line.length())
@@ -30,7 +58,11 @@ void SocketConnectionReceiver::threadFunction(int data)
       std::cout << "Received an empty command" << std::endl;
       break;
     }
-    if(line=="QUIT" || line=="quit")break;
+    if(line=="QUIT" || line=="quit")
+    {
+      handleQuit();
+      break;
+    }
     Block<String> commands = line.split('|');
     if(0==commands.size())continue;
     commands[0].upper();
@@ -49,9 +81,9 @@ void SocketConnectionReceiver::threadFunction(int data)
 
 /// @brief The client wants to put a file.  put {filename} {lengthbytes}
 /// @param commands [0]=PUT, [1]=filename, [2]=total length
-/// This will read PCKT {length}.
+/// This message contains PUT|{filename}|{lengthbytes} followed by as many PCKT|{length} packets as needed to read the entire file contents and save to disk
-/// The connection will continue reading and writing until it receives PCKT 0
+/// The connection will continue reading packets and saving data to disk until it receives PCKT 0 which signals the end of transmission
-/// @return 
+/// @return true or false
 bool SocketConnectionReceiver::handlePut(Block<String> &commands)
 {
   Profiler profiler;
@@ -61,6 +93,7 @@ bool SocketConnectionReceiver::handlePut(Block<String> &commands)
   String fileName;
   size_t fileLength;
   size_t totalBytesRead=0;
+  size_t totalPacketsRead=0;
 
   fileName = commands[1];
   fileLength = commands[commands.size()-1].toLong();
@@ -93,6 +126,7 @@ bool SocketConnectionReceiver::handlePut(Block<String> &commands)
     receiveBuffer.size(bufferLength);
     size_t bytes_read = read(receiveBuffer);
     totalBytesRead+=bytes_read;
+    totalPacketsRead++;
     if(bufferLength!=bytes_read)
     {
       std::cout << "Send/Receive size mismatch.  The client indicated a data length of " << Utility::formatNumber(bufferLength) << " but a data length of " << Utility::formatNumber(bytes_read) << " was received";
@@ -108,14 +142,16 @@ bool SocketConnectionReceiver::handlePut(Block<String> &commands)
       String strBytesPerSecond = Utility::byteCountToString(bytesPerSecond);
       std::cout << "Transferred " << Utility::byteCountToString(totalBytesRead,false) << " of " << Utility::byteCountToString(fileLength,false) << " " << percent << " percent " << strBytesPerSecond << std::endl;
     }
-
   }
-  std::cout << "Transfer complete" << std::endl;
-  std::cout << "Received " << Utility::byteCountToString(totalBytesRead,false) << " in " << Utility::formatNumber(profiler.end()) << "(ms)" << std::endl;
   writeFile.close();
+  std::cout << "Transfer complete.  Total packets received " << Utility::formatNumber(totalPacketsRead) << std::endl;
+  std::cout << "Received " << Utility::byteCountToString(totalBytesRead,false) << " in " << Utility::formatNumber(profiler.end()) << "(ms)" << std::endl;
   return totalBytesRead==fileLength;
 }
 
+/// @brief Read a PCKT message from the socket and return the length.  This message is of the form PCKT|{length} and the method returns the second parameter (length)
+/// @param  
+/// @return 
 size_t SocketConnectionReceiver::expectPacket(void)
 {
   Block<String> subCommands;
@@ -144,6 +180,9 @@ size_t SocketConnectionReceiver::expectPacket(void)
   return bufferLength;
 }
 
+/// @brief Read a '\r\n' terminated string from the socket.  Return the number of bytes read
+/// @param line The string to read data into
+/// @return 
 size_t SocketConnectionReceiver::readLine(String &line)
 {
     size_t bytes_read = 0;
@@ -169,6 +208,9 @@ size_t SocketConnectionReceiver::readLine(String &line)
     return total_bytes;
 }
 
+/// @brief Read bytes from a socket into the provided buffer.
+/// @param buffer The buffer must be pre-allocated to a given length.  The read operation will continue until all bytes in the buffer have been read
+/// @return 
 size_t SocketConnectionReceiver::read(Array<char> &buffer)
 {
     size_t bytes_read = 0;
@@ -185,3 +227,10 @@ size_t SocketConnectionReceiver::read(Array<char> &buffer)
     }
     return total_bytes_read;
 }
+
+/// @brief Handle a QUIT message... which just displays 
+/// @param  
+void SocketConnectionReceiver::handleQuit(void)
+{
+  std::cout << "Received QUIT" << std::endl;
+}

sstp/socketconnectionreceiver.hpp

@@ -1,5 +1,5 @@
-#ifndef _LISTENER_SOCKETCONNECTIONRECEIVER_HPP_
+#ifndef _SSTP_SOCKETCONNECTIONRECEIVER_HPP_
-#define _LISTENER_SOCKETCONNECTIONRECEIVER_HPP_
+#define _SSTP_SOCKETCONNECTIONRECEIVER_HPP_
 #include <stdio.h>
 #include <iostream>
 #include <sys/types.h>
@@ -16,13 +16,18 @@
 class SocketConnectionReceiver
 {
   public:
+    SocketConnectionReceiver();
     SocketConnectionReceiver(int socket, sockaddr_in inernalSocketAddress);
     virtual ~SocketConnectionReceiver();
+    void initialize(int socket, sockaddr_in inernalSocketAddress);
     void close(void);
   private:
     static constexpr size_t BUFFER_LENGTH=65536;   // this is the buffer length for the socket  
+    void isRunnable(bool isRunnable);
+    bool isRunnable(void);    
     void threadFunction(int data);
     bool handlePut(Block<String> &commands);
+    void handleQuit(void);
     size_t readLine(String &line);
     size_t expectPacket(void);
     size_t read(Array<char> &buffer);    
@@ -31,6 +36,19 @@ class SocketConnectionReceiver
     friend class SocketServer;
     char mBuffer[BUFFER_LENGTH] = {0};  
     int mSocket;
+    bool mIsRunnable;
     sockaddr_in mInternalSocketAddress;
 };
+
+inline
+void SocketConnectionReceiver::isRunnable(bool isRunnable)
+{
+  mIsRunnable=isRunnable;
+}
+
+inline
+bool SocketConnectionReceiver::isRunnable(void)
+{
+  return mIsRunnable;
+}
 #endif

sstp/socketserver.cpp

@@ -37,17 +37,45 @@ SocketServer::SocketServer(int port)
   mIsOkay=true;
 }
 
+/// @brief Close down the listener
 SocketServer::~SocketServer()
 {
-  std::cout << "~SocketServer()" << std::endl;
+  shutdownConnectionReceivers();
-  close();
+  join();    // Then join all socket threads
+  close();   // close the listener socket
+  
 }
 
+/// @brief Join all threads
+/// @param  
+void SocketServer::join(void)
+{
+  for (std::thread& executionThread : mExecutionThreads)
+  {
+    if (executionThread.joinable())
+    { 
+        executionThread.join();
+    } 
+  } 
+}
+
+/// @brief Remove object references to the connection receivers.  This will force socket threads to exit and close connections
+void SocketServer::shutdownConnectionReceivers()
+{
+  mSocketConnectionReceivers.remove();  
+}
+
+
+/// @brief returns true if we have a valid socket connection otherwise false
+/// @return 
 bool SocketServer::isOkay(void)
 {
   return mIsOkay;
 }
 
+/// @brief This is the listener.  It will wait for incoming connections.
+/// When an incoming connection is received it will create a SocketConnectionReceiver object and call it's threadFunction to handle further interactions
+/// such as transmitting a file.
 void SocketServer::listen(void)
 {
   while(isOkay())
@@ -70,11 +98,19 @@ void SocketServer::listen(void)
       close();
       return;
     }
-    SocketConnectionReceiver socketConnectionReceiver(socket, internalSocketAddress);
+    mSocketConnectionReceivers.insert(SmartPointer<SocketConnectionReceiver>());
-    mExecutionThreads.push_back(std::thread(&SocketConnectionReceiver::threadFunction, &socketConnectionReceiver, 0));
+    SmartPointer<SocketConnectionReceiver> &pSocketConnectionReceiver = mSocketConnectionReceivers[mSocketConnectionReceivers.size()-1];
+    pSocketConnectionReceiver = ::new SocketConnectionReceiver(socket, internalSocketAddress);
+    pSocketConnectionReceiver.disposition(PointerDisposition::Delete);
+    mExecutionThreads.push_back(std::thread(&SocketConnectionReceiver::threadFunction, *pSocketConnectionReceiver, 0));
+
+//    SocketConnectionReceiver socketConnectionReceiver(socket, internalSocketAddress);
+//    mExecutionThreads.push_back(std::thread(&SocketConnectionReceiver::threadFunction, &socketConnectionReceiver, 0));
   }
 }
 
+/// @brief Shut down the listener socket
+/// @param  
 void SocketServer::close(void)
 {
   if(-1!=mSocketFileDescriptor)

sstp/socketserver.hpp

@@ -13,6 +13,9 @@
 #include <common/profiler.hpp>
 #include <common/block.hpp>
 #include <common/fileio.hpp>
+#include <common/pointer.hpp>
+
+class SocketConnectionReceiver;
 
 class SocketServer
 {
@@ -24,11 +27,15 @@ class SocketServer
     bool isOkay(void);
   private:
     static constexpr int MAX_CONNECTIONS=10;   // The maximum connections to be queued at a time
+    void shutdownConnectionReceivers();    
+    void join(void);
+
     bool mIsOkay;
     int mListenPort;
     int mSocketFileDescriptor;
     struct sockaddr_in mInternalSocketAddress;
     socklen_t mAddressLength = sizeof(mInternalSocketAddress);
     std::vector<std::thread> mExecutionThreads;
+    Block<SmartPointer<SocketConnectionReceiver>> mSocketConnectionReceivers;
 };
 #endif