Code cleanup

common/callback.hpp

@@ -0,0 +1,41 @@
+#ifndef _COMMON_CALLBACK_HPP_
+#define _COMMON_CALLBACK_HPP_
+#ifndef _COMMON_CALLBACKDATA_HPP_
+#include <common/cbdata.hpp>
+#endif
+#ifndef _COMMON_PURECALLBACK_HPP_
+#include <common/pcallbck.hpp>
+#endif
+#ifndef _COMMON_CALLBACKPOINTER_HPP_
+#include <common/cbptr.hpp>
+#endif
+
+template <class T,class D>
+class Callback : public PureCallback<D>
+{
+public:
+  typedef LONG (T::*PFNMETHOD)(CallbackData<D> &callbackData);
+	Callback(void);
+	Callback(const Callback<T,D> &someCallback);
+	Callback(T *lpObject,PFNMETHOD lpMethod);
+	virtual ~Callback();
+	void setObject(T *lpObject);
+	void setMethod(PFNMETHOD lpMethod);
+	void setCallback(T *lpObject,PFNMETHOD lpMethod);
+	WORD operator==(const Callback<T,D> &someCallback)const;
+	void operator=(const Callback<T,D> &someCallback);
+	LONG operator*(CallbackData<D> &someCallbackData);
+private:
+	T *mlpObject;
+	LONG (T::*mlpMethod)(CallbackData<D> &someCallbackData);
+};
+
+template <class T,class D>
+inline
+LONG Callback<T,D>::operator*(CallbackData<D> &someCallbackData)
+{
+	if((!mlpObject)||(!mlpMethod))return (LONG)0;
+	return (mlpObject->*mlpMethod)(someCallbackData);
+}
+#include <common/callback.tpp>
+#endif

common/callback.tpp

@@ -0,0 +1,60 @@
+#ifndef _COMMON_CALLBACK_TPP_
+#define _COMMON_CALLBACK_TPP_
+
+template <class T,class D>
+Callback<T,D>::Callback(void)
+: mlpObject(0), mlpMethod(0)
+{
+}
+
+template <class T,class D>
+Callback<T,D>::Callback(const Callback<T,D> &someCallback)
+: mlpObject(someCallback.mlpObject), mlpMethod(someCallback.mlpMethod)
+{
+}
+
+
+template <class T,class D>
+Callback<T,D>::Callback(T *lpObject,PFNMETHOD lpMethod)
+: mlpObject(lpObject), mlpMethod(lpMethod)
+{
+}
+
+template <class T,class D>
+Callback<T,D>::~Callback()
+{
+}
+
+template <class T,class D>
+WORD Callback<T,D>::operator==(const Callback<T,D> &someCallback)const
+{
+	return (mlpObject==someCallback.mlpObject && mlpMethod==someCallback.mlpMethod);
+}
+
+template <class T,class D>
+void Callback<T,D>::operator=(const Callback<T,D> &someCallback)
+{
+	mlpObject=someCallback.mlpObject;
+	mlpMethod=someCallback.mlpMethod;
+}
+
+template <class T,class D>
+void Callback<T,D>::setObject(T *lpObject)
+{
+	mlpObject=lpObject;
+}
+
+template <class T,class D>
+void Callback<T,D>::setMethod(PFNMETHOD lpMethod)
+{
+	mlpMethod=lpMethod;
+}
+
+template <class T,class D>
+void Callback<T,D>::setCallback(T *lpObject,PFNMETHOD lpMethod)
+{
+  mlpObject=lpObject;
+	mlpMethod=lpMethod;
+}
+
+#endif

common/cbdata.hpp

@@ -0,0 +1,70 @@
+#ifndef _COMMON_CALLBACKDATA_HPP_
+#define _COMMON_CALLBACKDATA_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+template<class T>
+class CallbackData
+{
+public:
+  typedef LONG ReturnType;
+  CallbackData(void);
+	CallbackData(T &data);
+  CallbackData(const CallbackData &someCallbackData);
+	virtual ~CallbackData();
+	CallbackData &operator=(const CallbackData &someCallbackData);
+	T &getData(void);
+	void setData(T &data);
+private:
+  SmartPointer<T> mData;
+};
+
+template<class T>
+inline
+CallbackData<T>::CallbackData(void)
+{
+}
+
+template<class T>
+inline
+CallbackData<T>::CallbackData(T &data)
+{
+	mData=&data;
+}
+
+template <class T>
+inline
+CallbackData<T>::CallbackData(const CallbackData &someCallbackData)
+{
+  *this=someCallbackData;
+}
+
+template <class T>
+inline
+CallbackData<T>::~CallbackData()
+{
+}
+
+template <class T>
+inline
+CallbackData<T> &CallbackData<T>::operator=(const CallbackData<T> &someCallbackData)
+{
+	mData = someCallbackData.mData;
+	return *this;
+}
+
+template <class T>
+inline
+T &CallbackData<T>::getData(void)
+{
+	return *mData;
+}
+
+template <class T>
+inline
+void CallbackData<T>::setData(T &data)
+{
+  mData=&data;
+}
+#endif

common/cbptr.hpp

@@ -0,0 +1,81 @@
+#ifndef _COMMON_CALLBACKPOINTER_HPP_
+#define _COMMON_CALLBACKPOINTER_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_PURECALLBACK_HPP_
+#include <common/pcallbck.hpp>
+#endif
+
+template <class T>
+class CallbackPointer
+{
+public:
+	CallbackPointer(void);
+	CallbackPointer(PureCallback<T> *lpCallback);
+	CallbackPointer(const CallbackPointer<T> &someCallbackPointer);
+	virtual ~CallbackPointer();
+	void operator=(CallbackPointer &someCallbackPointer);
+	WORD operator==(const CallbackPointer &someCallbackPointer)const;
+	LONG callback(CallbackData<T> &someCallbackData);
+	bool isOkay(void)const;
+private:
+	PureCallback<T> *mlpCallback;
+};
+
+template <class T>
+inline
+CallbackPointer<T>::CallbackPointer(void)
+: mlpCallback(0)
+{
+}
+
+template <class T>
+inline
+CallbackPointer<T>::CallbackPointer(PureCallback<T> *lpCallback)
+: mlpCallback(lpCallback)
+{
+}
+
+template <class T>
+inline
+CallbackPointer<T>::CallbackPointer(const CallbackPointer<T> &someCallbackPointer)
+: mlpCallback(someCallbackPointer.mlpCallback)
+{
+}
+
+template <class T>
+inline
+CallbackPointer<T>::~CallbackPointer()
+{
+}
+
+template <class T>
+inline
+void CallbackPointer<T>::operator=(CallbackPointer<T> &someCallbackPointer)
+{
+	mlpCallback=someCallbackPointer.mlpCallback;
+}
+
+template <class T>
+inline
+WORD CallbackPointer<T>::operator==(const CallbackPointer<T> &someCallbackPointer)const
+{
+	return (mlpCallback==someCallbackPointer.mlpCallback);
+}
+
+template <class T>
+inline
+LONG CallbackPointer<T>::callback(CallbackData<T> &someCallbackData)
+{
+	if(!mlpCallback)return (LONG)0;
+	return mlpCallback->operator*(someCallbackData);
+}
+
+template <class T>
+inline
+bool CallbackPointer<T>::isOkay(void)const
+{
+  return mlpCallback?true:false;
+}
+#endif

common/pcallbck.hpp

@@ -0,0 +1,35 @@
+#ifndef _COMMON_PURECALLBACK_HPP_
+#define _COMMON_PURECALLBACK_HPP_
+#ifndef _COMMON_CALLBACKDATA_HPP_
+#include <common/cbdata.hpp>
+#endif
+
+template <class T>
+class PureCallback
+{
+public:
+	PureCallback(void);
+	virtual ~PureCallback();
+	virtual LONG operator*(CallbackData<T> &someCallbackData)=0;
+private:
+};
+
+template <class T>
+inline
+PureCallback<T>::PureCallback(void)
+{
+}
+
+template <class T>
+inline
+PureCallback<T>::~PureCallback()
+{
+}
+
+template <class T>
+inline
+LONG PureCallback<T>::operator*(CallbackData<T> &/*someCallbackData*/)
+{
+	return 0;
+}
+#endif

common/pointer.hpp

@@ -14,7 +14,8 @@ template <class T>
 class SmartPointer
 {
 public:
-	SmartPointer(void);
+//	SmartPointer(void);
+	SmartPointer(bool createNew=false);
 	SmartPointer(T FAR *lpSmartPointer,PointerDisposition::Disposition disposition=PointerDisposition::Assume);
 	SmartPointer(const SmartPointer<T> &someSmartPointer);
 	virtual ~SmartPointer();
@@ -36,11 +37,23 @@ private:
 	PointerDisposition::Disposition mDisposition;
 };
 
+// template <class T>
+// inline
+// SmartPointer<T>::SmartPointer(void)
+// : mlpSmartPointer(0), mDisposition(PointerDisposition::Assume)
+// {
+// }
+
 template <class T>
 inline
-SmartPointer<T>::SmartPointer(void)
+SmartPointer<T>::SmartPointer(bool createNew)
 : mlpSmartPointer(0), mDisposition(PointerDisposition::Assume)
 {
+	if(createNew)
+	{
+		mlpSmartPointer = ::new T();
+		mDisposition = PointerDisposition::Delete;
+	}
 }
 
 template <class T>

common/utility.hpp

@@ -3,6 +3,8 @@
 #include <stdio.h>
 #include <limits>
 #include <cmath>
+#include <filesystem>
+#include <sys/statvfs.h>
 #include <common/string.hpp>
 
 class Utility
@@ -15,7 +17,8 @@ class Utility
     static String formatCurrency(double number,int places=2);
     static bool fmod(double dividend,double divisor);
     static bool fmod(double dividend, double divisor,double epsilon);
-    static String bytesTransferredToString(double bytesTransferred);
+    static String byteCountToString(double bytesTransferred, bool perSecond = true);
+    static size_t getAvailableDiskSpace(const String &path);
   private:
     static String pad(String theString,char padChar,int toLength);
     static String addCommas(String& theString);
@@ -34,30 +37,35 @@ Utility::~Utility()
 }
 
 inline
-String Utility::bytesTransferredToString(double bytesTransferred)
+String Utility::byteCountToString(double bytesTransferred, bool perSecond)
 {
   double roundedValue = std::round(bytesTransferred * 100.00)/100.00;
+  String strBytesTransferrred;
   if(roundedValue >= 1E+15)
   {
-    return Utility::formatNumber(roundedValue/1E+15,2) + "Pb/s";
+    strBytesTransferrred = Utility::formatNumber(roundedValue/1E+15,2) + "Pb";
   }
   else if(roundedValue >= 1000000000000)
   {
-    return Utility::formatNumber(roundedValue/1000000000000,2) + "Tb/s";
+    strBytesTransferrred = Utility::formatNumber(roundedValue/1000000000000,2) + "Tb";
   }
   else if(roundedValue >= 1073741824)
   {
-    return Utility::formatNumber(roundedValue/1073741824,2) + "Gbb/s";
+    strBytesTransferrred = Utility::formatNumber(roundedValue/1073741824,2) + "Gb";
   }  
   else if(roundedValue >= 1000000)
   {
-    return Utility::formatNumber(roundedValue/1000000,2) + "Mb/s";
+    strBytesTransferrred = Utility::formatNumber(roundedValue/1000000,2) + "Mb";
   }    
   else if(roundedValue >= 1000)
   {
-    return Utility::formatNumber(roundedValue/1000,2) + "Kb/s";
+    strBytesTransferrred = Utility::formatNumber(roundedValue/1000,2) + "Kb";
   } 
-  return Utility::formatNumber(roundedValue,2) + "B/s";   
+  else strBytesTransferrred =  Utility::formatNumber(roundedValue,2) + "B";   
+
+  if(perSecond)strBytesTransferrred+="/s";
+
+  return strBytesTransferrred;
 }
 
 inline
@@ -167,4 +175,11 @@ bool Utility::fmod(double dividend, double divisor)
     // Check if the absolute remainder is less than epsilon
     return std::fabs(remainder) < epsilon;
 }
+
+inline
+size_t Utility::getAvailableDiskSpace(const String& path)
+{
+    std::filesystem::space_info si = std::filesystem::space(path.str());
+    return si.available;
+}
 #endif

ctest/.vscode/settings.json

@@ -48,6 +48,11 @@
         "streambuf": "cpp",
         "typeinfo": "cpp",
         "fstream": "cpp",
-        "iostream": "cpp"
+        "iostream": "cpp",
+        "complex": "cpp",
+        "cstring": "cpp",
+        "semaphore": "cpp",
+        "stop_token": "cpp",
+        "thread": "cpp"
     }
 }

ctest/CMakeLists.txt

@@ -1,10 +1,10 @@
 cmake_minimum_required(VERSION 3.10.0)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/home/pi/Boneyard")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/home/pi/CPP")
 project(tester VERSION 0.1.0 LANGUAGES C CXX)
 
 add_executable(tester main.cpp)
 
-add_subdirectory(/home/pi/Boneyard/common /home/pi/Boneyard/common/build) 
+add_subdirectory(/home/pi/CPP/common /home/pi/CPP/common/build) 
 target_link_libraries(tester PRIVATE common)
 
 

ctest/Untitled-1

@@ -1 +0,0 @@
-

ctest/main.cpp

@@ -10,144 +10,172 @@
 #include <iostream>
 #include <algorithm>
 #include <tuple>
+#include <utility>
 #include <complex>
+#include <csignal>
+#include <common/callback.hpp>
 
 
-// #include <iostream> // For standard input/output operations (like std::cout)
-// #include <fstream>  // For file stream operations (like std::ifstream)
-// #include <string>   // For using std::string
-// int main()
-// {
-//     Profiler profiler = Profiler();
-//     std::ifstream inputFile("/mnt/mariadb/backupdb.sql"); 
+bool registerSignalHandler(void);             // registers a Control-c handler
+void signalHandler(int signal);               // The Control-C handler
 
-//     if (!inputFile.is_open())
-//     {
-//         std::cerr << "Error: Could not open the file." << std::endl;
-//         return 1; // Indicate an error
-//     }
-
-//     DWORD lines = 0;
-//     std::string line;
-//     while (std::getline(inputFile, line))
-//     {
-//        lines++;
-//        if(!(lines%1000000))
-//       {
-//         std::cout << "reading " << lines << " " << line << std::endl;
-//       }
-//     }
-
-//     inputFile.close();
-//     std::cout << "Done, total took " << profiler.end() << " (ms)" << std::endl;
-//     return 0; // Indicate successful execution
-//   }
-
-// int main(int argc, char ** argv)
-// {
-//   Profiler profiler = Profiler();
-//   FileIO inputFile = FileIO("/mnt/mariadb/backupdb.sql");
-//   inputFile.setBufferLength(500000000);
-// //  FileIO inputFile = FileIO("/home/pi/Boneyard/ctest/main.cpp");  
-//   String strLine = String();
-//   DWORD length =  0;
-//   DWORD lines = 0;
-
-//   printf("opening...\n");
-//   while(inputFile.readLine(strLine))
-//   {
-//     lines++;
-// //    printf("reading %d %s\n",lines,(char*)strLine);
-//     if(!(lines%1000000))
-//     {
-//       printf("reading %d %s\n",lines,(char*)strLine);
-//     }
-//   }
-//   printf("Done, read %d lines\n",lines);
-//   inputFile.close();
-//   printf("done, took %d(ms)...\n",profiler.end());
-
-//     return 0;
-// }
-
-std::tuple<int,int,int> foo()
+class Info
 {
-    return std::make_tuple(2,3,4);
+  public:
+  Info();
+  ~Info();
+  String getMessage(void);
+  void setMessage(const String &message);
+  private:
+  String mMessage;
+};
+
+Info::Info()
+{
+  std::cout << "Info" << std::endl;
+}
+
+Info::~Info()
+{
+  std::cout << "~Info" << std::endl;
+}
+
+String Info::getMessage(void)
+{
+    return mMessage;
+}
+
+void Info::setMessage(const String &message)
+{
+    mMessage = message;
+}
+
+class B 
+{
+  public:
+    B();
+    LONG callback(CallbackData<Info> &callbackData);
+    ~B();
+  private:
+    String mFoo;
+};
+
+B::B()
+{
+}
+
+B::~B()
+{
+}
+
+LONG B::callback(CallbackData<Info> &callbackData)
+{
+  std::cout << "callback with data " << callbackData.getData().getMessage().str() << std::endl;  
+  return 0;
+}
+
+class Monitor
+{
+  public:
+  Monitor();
+  ~Monitor();
+  void setCallback(Callback<B,Info> &callback);
+  void doCallback(CallbackData<Info> &callbackData);
+  private:
+  Callback<B,Info> mCallback;
+};
+
+Monitor::Monitor()
+{
+  std::cout << "Monitor" << std::endl;
+}
+
+
+Monitor::~Monitor()
+{
+  std::cout << "~Monitor" << std::endl;
+}
+
+void Monitor::setCallback(Callback<B,Info> &callback)
+{
+  mCallback=callback;
+}
+
+void Monitor::doCallback(CallbackData<Info> &callbackData)
+{
+  CallbackPointer cbptr(&mCallback);
+  cbptr.callback(callbackData);
 }
 
 int main(int argc, char ** argv)
 {
-    //  std::complex<double> c{4.0,3.0};
+    registerSignalHandler();
+    while(true)
+    {
+      // do stuff
+    }
+    // std::vector<int> myBigVec(10000000, 2011);
+    // std::vector<std::string> s1;
+    // std::vector<std::string> s2;
+
+    // s1.push_back("hello");
+    // s1.push_back("world");
+
+    // s2 = std::move(s1);
 
 
+  // Monitor monitor;
+  // SmartPointer<B> b(true);
+  // Callback<B,Info> callback(&(*b),&B::callback);
+  // monitor.setCallback(callback);
+
+  // Info info;
+  // info.setMessage("Hello");
+
+  // CallbackData<Info> callbackData(info);
+  // monitor.doCallback(callbackData);
 
-  // FileIO fileIO = FileIO("/mnt/mariadb/backupdb.sql");
-  // std::cout << "Reading ... " << std::endl;
-  // int lines =0;
-  // String strLine;
-  // while(fileIO.readLine(strLine))
-  // {
-  //   lines++;
-  //   if(!(lines%1000000))
-  //   {
-  //     printf("reading %d %s\n",lines,(char*)strLine);
-  //   }    
-  // }  
-  // fileIO.close();  
 }
 
-void stdLibStuff()
+/// @brief The signal handler
+void signalHandler(int signal)
 {
-    // std::vector<int> numbers;
-    // numbers.push_back(100);
-    // numbers.push_back(50);
-    // numbers.push_back(100);
-
-    // int *p=&numbers[0];
-    // int *p1=&numbers[1];
-    // int *p2=&numbers[2];
-
-    // int max = *std::max_element(numbers.begin(), numbers.end());
-
-//    std::cout <<  typeid(max_it).name() << std::endl;
-    // if(max_it == p)std::cout << "p" << std::endl;
-    // if(max_it == p1) std::cout << "p1" << std::endl;
-    // if(max_it == p2)std::cout << "p2" << std::endl;
-
-
-//    std::cout << *max_it << std::endl;
-
-
-    // int max_value = *max_it;
-    // std::max(*numbers.begin());
-
-
-//    std::cout << std::max(numbers) << std::endl;
-//  Block<int> numbers;
-
-
-
-//  numbers.insert(newInt(100);
-
-//   std::cout<< std::min(100,50) << std::endl;
-    // std::string s = "hello";
-    // std::cout << s << std::endl;
-  // std::vector<std::string> strings;
-  // strings.push_back("hello");
-  // strings.push_back("world");
-
-  //  for (const std::string& s : strings)
-  //  {
-  //     std::cout << s << " ";
-  //  }
-
-  // char buffer[] = "Another direct copy";
-
-  // int a = sizeof(buffer);
-
-
+  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;
+}
+
+
+
+//  Callback callback(&(*b),C
+
+
+//  SmartPointer<B> b1 = b;
+//  b1->foo();
+//  b->foo();
+
+//  String str="Hello";
+//  b->setFoo(str);
+//  str="Goodbye";
+//  String str2=b->getFoo();
+//  str2="world";
+
 void readFile()
 {
   //  MemoryMappedFile memoryMappedFile("/home/pi/Boneyard/ctest/main.cpp",MemoryMappedFile::CreationFlags::ReadOnly);

sstp/.vscode/settings.json

@@ -52,6 +52,9 @@
         "semaphore": "cpp",
         "stop_token": "cpp",
         "thread": "cpp",
-        "*.tpp": "cpp"
+        "*.tpp": "cpp",
+        "csignal": "cpp",
+        "codecvt": "cpp",
+        "iomanip": "cpp"
     }
 }

sstp/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.10.0)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/home/pi/CPP")
 project(sstp VERSION 0.1.0 LANGUAGES C CXX)
 
-add_executable(sstp main.cpp clientsocketsender.cpp socketconnectionreceiver.cpp socketserver.cpp)
+add_executable(sstp main.cpp clientsocketsender.cpp socketconnectionreceiver.cpp socketserver.cpp sstp.cpp)
 
 add_subdirectory(/home/pi/CPP/common /home/pi/CPP/common/build) 
 target_link_libraries(sstp PRIVATE common)

sstp/clientsocketsender.cpp

@@ -1,5 +1,15 @@
 #include <sstp/clientsocketsender.hpp>
+#include <common/utility.hpp>
 
+/// @brief This is to provide a definition for SmartPointer
+ClientSocketSender::ClientSocketSender()
+: mIPAddress(""), mPort(0)
+{
+}
+
+/// @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,20 +36,26 @@ ClientSocketSender::ClientSocketSender(String ipAddress, int port)
     }
 }
 
+/// @brief Close the connection on destruction
 ClientSocketSender::~ClientSocketSender()
 {
+  std::cout << "~ClientSocketSender" << std::endl;
   close();
 }
 
+/// @brief Closes the connection
+/// @param  
 void ClientSocketSender::close(void)
 {
-  if(-1!=mSocket)
-  {
-    ::close(mSocket);
-    mSocket=-1;
-  }
+  if(-1==mSocket)return;
+  std::cout << "ClientSocketSender::close, closing socket" << std::endl;  
+  ::close(mSocket);
+  mSocket=-1;
 }
   
+/// @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;
@@ -54,6 +70,7 @@ bool ClientSocketSender::sendFile(String &pathFileName)
   sendPutIndicator(pathFileName, fileLength);
   Array<char> readBuffer;
   readBuffer.size(BUFFER_LENGTH);
+  std::cout << "Sending file "  << pathFileName << " " << Utility::byteCountToString(fileLength, false) << std::endl;
   while(true)
   {
     size_t bytesRead = readFile.read(&readBuffer[0], readBuffer.size());
@@ -73,6 +90,9 @@ bool ClientSocketSender::sendFile(String &pathFileName)
   return true;
 }
 
+/// @brief Send PCKT with length of packet 
+/// @param bytesToSend 
+/// @return 
 bool ClientSocketSender::sendPacketIndicator(DWORD bytesToSend)
 {
   if(!isOkay())return false;
@@ -83,6 +103,10 @@ bool ClientSocketSender::sendPacketIndicator(DWORD bytesToSend)
   return true;
 }
 
+/// @brief Send PUT with filename and file length
+/// @param fileName 
+/// @param fileLength 
+/// @return 
 bool ClientSocketSender::sendPutIndicator(String fileName,DWORD fileLength)
 {
   if(!isOkay())return false;
@@ -97,6 +121,9 @@ bool ClientSocketSender::sendPutIndicator(String fileName,DWORD fileLength)
   return true;
 }
 
+/// @brief Send QUIT
+/// @param  
+/// @return 
 bool ClientSocketSender::sendQuit(void)
 {
   if(!isOkay())return false;
@@ -105,6 +132,10 @@ bool ClientSocketSender::sendQuit(void)
   return true;
 }
 
+/// @brief items in buffer with length bytesToSend 
+/// @param buffer The buffer to send
+/// @param bytesToSend The number of bytes to send
+/// @return 
 bool ClientSocketSender::sendPacket(Array<char> &buffer,DWORD bytesToSend)
 {
   if(!isOkay())return false;

sstp/clientsocketsender.hpp

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

sstp/main.cpp

@@ -1,103 +1,111 @@
-#include <stdio.h>
 #include <iostream>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <unistd.h>
-#include <arpa/inet.h>
-#include <thread>
-#include <vector>
+#include <csignal>
 #include <common/string.hpp>
 #include <common/profiler.hpp>
 #include <common/block.hpp>
-#include <common/fileio.hpp>
 #include <common/utility.hpp>
 #include <sstp/socketserver.hpp>
 #include <sstp/clientsocketsender.hpp>
+#include <sstp/sstp.hpp>
 
-// https://www.man7.org/linux/man-pages/man2/accept.2.html
+// To Clean: From the top menu choose "View", "Command Palette", Then choose CMake: Clean    OR /usr/bin/cmake --build /home/pi/CPP/sstp/build --config Debug --target clean --
+// To Build: From the top menu choose "View", "Command Palette", Then choose CMake: Build    OR /usr/bin/cmake --build /home/pi/CPP/sstp/build --config Debug --target all --
+// Output will be here.  /home/pi/CPP/sstp/build
+// On Isonoe to receive we will point to the binaries here /home/pi/CPP/sstp/build
+// On Adrastea we will point to the binaries here /home/pi/Boneyard/sstp
 
-void handleServer(Block<String> &commands);
-void handleClient(Block<String> &commands);
+bool registerSignalHandler(void);             // registers a Control-c handler
+void signalHandler(int signal);               // The Control-C handler
+
+SmartPointer<SSTP> sstp;
 
 /// @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.0.0.9";   // major version, minor version, patch, build
 
-  if(argc<2)
+  std::cout << "sstp version " << version.str() << std::endl;  
+  if(!registerSignalHandler())
   {
-    std::cout << "sstp SERVERMODE {port} | CLIENTMODE {serveripaddress} {serverport} {pathfileName}." << std::endl;
-    std::cout << "SERVERMODE will listen on the specified port for a connection and receive the specified file." << std::endl;
-    std::cout << "CLIENTMODE willl connect to the specified address and port and send the specfied file." << std::endl;
-    return 1;
+    std::cout << "Unable to register CTRL-C handler" << std::endl;
+    return -1;
   }
-  Block<String> arguments;
-  for(int index=0;index<argc;index++)
+  try
   {
-    String item(argv[index]);
-    arguments.insert(item);
+    if(argc<2)
+    {
+      std::cout << "sstp SERVERMODE {port} | CLIENTMODE {serveripaddress} {serverport} {pathfileName}." << std::endl;
+      std::cout << "SERVERMODE will listen on the specified port for a connection and receive the specified file." << std::endl;
+      std::cout << "CLIENTMODE willl connect to the specified address and port and send the specfied file." << std::endl;
+      return 1;
+    }
+    Block<String> arguments;
+    for(int index=0;index<argc;index++)
+    {
+      String item(argv[index]);
+      arguments.insert(item);
+    }
+    sstp=::new SSTP();
+    sstp.disposition(PointerDisposition::Delete);
+    std::cout << argv[1] << std::endl;
+    if(arguments[1]=="SERVERMODE")
+    {
+      sstp->handleServer(arguments);
+    }
+    else if(arguments[1]=="CLIENTMODE")
+    {
+      sstp->handleClient(arguments);
+    }  
+    else
+    {
+      std::cout << "Unknown command " << arguments[1] << std::endl;
+      returnCode=-1;
+    }
   }
-
-  std::cout << argv[1] << std::endl;
-  if(arguments[1]=="SERVERMODE")
+  catch(Exception& exception)
   {
-    handleServer(arguments);
+    std::cout << exception.toString() << std::endl;
+    returnCode=-1;
   }
-  else if(arguments[1]=="CLIENTMODE")
+  catch(...)
   {
-    handleClient(arguments);
-  }  
-  else
-  {
-    std::cout << "Unknown command " << arguments[1] << std::endl;
+    std::cout << "An unhandled exception was encountered" << std::endl;
+    returnCode=-1;
   }
-  return 0;
  
   std::cout << "Done, total took " << Utility::formatNumber(profiler.end()) << "(ms)" << std::endl;
+  return returnCode;
 }
 
-/// @brief [0]=program [1]=SERVERMODE [2]={port}
-/// @param commands 
-void handleServer(Block<String> &commands)
+/// @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)
 {
-  Profiler profiler;
-
-  if(commands.size()!=3)
-  {
-    std::cout << "Missing required parameters" << std::endl;
-    return;
-  }
-  int port = commands[2].toInt();
-  std::cout << commands[1] << ":" << commands[2] << std::endl;
-  SocketServer socketServer(commands[2].toInt());
-  socketServer.listen();
-  std::cout << "Done, total took " << Utility::formatNumber(profiler.end()) << "(ms)" << std::endl;
+  std::cout << "SSTP Received signal " << signal << std::endl;
+  if(sstp.isOkay())sstp.destroy();
+  exit(signal);
 }
 
-/// @brief [0]=program, [1]=CLIENTMODE, [2]=serveripaddress, [3]=serverport, [4]=pathfilename
-/// @param commands 
-void handleClient(Block<String> &commands)
+/// @brief Method that registers the signal handler
+/// @param  
+bool registerSignalHandler(void)
 {
-  Profiler profiler;
-  if(commands.size()!=5)
-  {
-    std::cout << "Missing required parameters" << std::endl;
-    return;    
-  }
+  struct sigaction sa;
+  sa.sa_handler = signalHandler; 
+  sigemptyset(&sa.sa_mask);   // Clear the mask of blocked signals
+  sa.sa_flags = 0;            // No special flags
 
-  ClientSocketSender clientSocketSender(commands[2],commands[3].toInt());  
-  bool returnCode = clientSocketSender.sendFile(commands[4]);
-  if(!returnCode)
+  if (-1==sigaction(SIGINT, &sa, nullptr))
   {
-    std::cout << "The transfer failed." << std::endl;
-  }
-  else
-  {
-      std::cout << "Transfer complete" << std::endl;
-  }
-  std::cout << "Done, total took " << Utility::formatNumber(profiler.end()) << "(ms)" << std::endl;
+    std::cerr << "Error registering SIGINT handler." << std::endl;
+    return false;
+  }  
+  return true;
 }
+

sstp/socketconnectionreceiver.cpp

@@ -2,15 +2,40 @@
 #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 +44,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 +57,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 +80,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}.
-/// The connection will continue reading and writing until it receives PCKT 0
-/// @return 
+/// 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 packets and saving data to disk until it receives PCKT 0 which signals the end of transmission
+/// @return true or false
 bool SocketConnectionReceiver::handlePut(Block<String> &commands)
 {
   Profiler profiler;
@@ -61,10 +92,21 @@ bool SocketConnectionReceiver::handlePut(Block<String> &commands)
   String fileName;
   size_t fileLength;
   size_t totalBytesRead=0;
+  size_t totalPacketsRead=0;
+  size_t availableDiskSpace=0;
 
   fileName = commands[1];
   fileLength = commands[commands.size()-1].toLong();
-  std::cout << "PUT" << " " << fileName << " " << fileLength << std::endl;
+  std::cout << "PUT" << " " << fileName << " " << Utility::byteCountToString(fileLength,false) << std::endl;
+
+  availableDiskSpace=Utility::getAvailableDiskSpace(String("./"));
+  std::cout << Utility::byteCountToString(availableDiskSpace,false) << " available space on disk" << std::endl;
+  if(fileLength > availableDiskSpace)
+  {
+    std::cout << "Unsufficient space on disk.  Required space " << Utility::byteCountToString(availableDiskSpace,false) << " , available space" << Utility::byteCountToString(availableDiskSpace,false) << std::endl;
+    return false;
+  }
+
   FileIO writeFile(fileName, FileIO::ByteOrder::LittleEndian, FileIO::Mode::ReadWrite,FileIO::CreationFlags::CreateAlways);
 
   if(!writeFile.isOkay())
@@ -93,6 +135,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";
@@ -105,17 +148,19 @@ bool SocketConnectionReceiver::handlePut(Block<String> &commands)
     {
       double elapsedTimeSeconds = profiler.elapsed()/1000.00;
       double bytesPerSecond = totalBytesRead / elapsedTimeSeconds;
-      String strBytesPerSecond = Utility::bytesTransferredToString(bytesPerSecond);
-      std::cout << "Transferred " << Utility::formatNumber(totalBytesRead) << " of " << Utility::formatNumber(fileLength) << " " << percent << " percent " << strBytesPerSecond << std::endl;
+      String strBytesPerSecond = Utility::byteCountToString(bytesPerSecond);
+      std::cout << "Received " << Utility::byteCountToString(totalBytesRead,false) << " of " << Utility::byteCountToString(fileLength,false) << " " << percent << " percent " << strBytesPerSecond << std::endl;
     }
-
   }
-  std::cout << "Transfer complete" << std::endl;
-  std::cout << "Received " << Utility::formatNumber(totalBytesRead) << " 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;
@@ -128,7 +173,7 @@ size_t SocketConnectionReceiver::expectPacket(void)
     sb.append("Received an invalid PCKT command");
     String str=sb.toString();
     std::cout << str << std::endl;
-    throw new InvalidOperationException(str);
+    throw InvalidOperationException(str);
   }
   if(!(subCommands[0]=="PCKT"))
   {
@@ -138,12 +183,15 @@ size_t SocketConnectionReceiver::expectPacket(void)
     sb.append("Expected PCKT but received ").append(subCommands[0]);
     String str = sb.toString();
     std::cout << str << std::endl;
-    throw new InvalidOperationException(str);
+    throw InvalidOperationException(str);
   }
   size_t bufferLength = subCommands[1].toULong();
   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 +217,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 +236,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_
-#define _LISTENER_SOCKETCONNECTIONRECEIVER_HPP_
+#ifndef _SSTP_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

@@ -1,6 +1,13 @@
 #include <sstp/socketserver.hpp>
 #include <sstp/socketconnectionreceiver.hpp>
 
+/// @brief Defauly constructor.  This is to provide a definition for SmartPointer
+/// @param port 
+SocketServer::SocketServer()
+: mListenPort(-1), mIsOkay(false), mSocketFileDescriptor(-1)
+{
+}
+
 /// @brief This will construct the socket listener.  You must then call listen() to listen for connections
 /// @param port 
 SocketServer::SocketServer(int port)
@@ -25,8 +32,6 @@ SocketServer::SocketServer(int port)
 // bind socket to network address and port  
   mInternalSocketAddress.sin_family = AF_INET;
   mInternalSocketAddress.sin_addr.s_addr=INADDR_ANY;
-
-
   mInternalSocketAddress.sin_port = htons(mListenPort);
   result = ::bind(mSocketFileDescriptor,(struct sockaddr*)&mInternalSocketAddress,sizeof(mInternalSocketAddress));
   if(result)
@@ -37,17 +42,49 @@ SocketServer::SocketServer(int port)
   mIsOkay=true;
 }
 
+/// @brief Close down the listener
 SocketServer::~SocketServer()
 {
-  std::cout << "~SocketServer()" << std::endl;
-  close();
+  std::cout << "~SocketServer" << std::endl;
+  std::cout << "shutdownConnectionReceivers" << std::endl;
+  shutdownConnectionReceivers();
+  std::cout << "join" << std::endl;
+  join();    // Then join all socket threads
+  std::cout << "close" << std::endl;
+  close();   // close the listener socket
+  std::cout << "~SocketServer, done" << std::endl;
 }
 
+/// @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,16 +107,20 @@ void SocketServer::listen(void)
       close();
       return;
     }
-    SocketConnectionReceiver socketConnectionReceiver(socket, internalSocketAddress);
-    mExecutionThreads.push_back(std::thread(&SocketConnectionReceiver::threadFunction, &socketConnectionReceiver, 0));
+    mSocketConnectionReceivers.insert(SmartPointer<SocketConnectionReceiver>());
+    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));
   }
 }
 
+/// @brief Shut down the listener socket
+/// @param  
 void SocketServer::close(void)
 {
-  if(-1!=mSocketFileDescriptor)
-  {
-    ::close(mSocketFileDescriptor);
-    mSocketFileDescriptor=-1;
-  }
+  if(-1==mSocketFileDescriptor)return;
+  std::cout << "SocketServer::close, closing socket" << std::endl;
+  ::close(mSocketFileDescriptor);
+  mSocketFileDescriptor=-1;
 }

sstp/socketserver.hpp

@@ -13,10 +13,14 @@
 #include <common/profiler.hpp>
 #include <common/block.hpp>
 #include <common/fileio.hpp>
+#include <common/pointer.hpp>
+
+class SocketConnectionReceiver;
 
 class SocketServer
 {
   public:
+    SocketServer();
     SocketServer(int port);
     virtual ~SocketServer();
     void listen(void);
@@ -24,11 +28,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

sstp/sstp.cpp

@@ -0,0 +1,52 @@
+#include <iostream>
+#include <sstp/sstp.hpp>
+#include <common/profiler.hpp>
+#include <common/utility.hpp>
+#include <sstp/socketserver.hpp>
+#include <sstp/clientsocketsender.hpp>
+
+/// @brief [0]=program [1]=SERVERMODE [2]={port}
+/// @Note Currently this method will never return.  The application is terminated with CTRL-C.  Ideally, we would exit in 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 SSTP::handleServer(Block<String>& commands)
+{
+  Profiler profiler;
+
+  if(commands.size()!=3)
+  {
+    std::cout << "Missing required parameters" << std::endl;
+    return;
+  }
+  int port = commands[2].toInt();
+  std::cout << commands[1] << ":" << commands[2] << std::endl;
+  mSocketServer = ::new SocketServer(commands[2].toInt());
+  mSocketServer.disposition(PointerDisposition::Delete);
+  mSocketServer->listen();
+  std::cout << "Done, total took " << Utility::formatNumber(profiler.end()) << "(ms)" << std::endl;
+}
+
+/// @brief [0]=program, [1]=CLIENTMODE, [2]=serveripaddress, [3]=serverport, [4]=pathfilename
+/// @param commands 
+void SSTP::handleClient(Block<String>& arguments)
+{
+  Profiler profiler;
+  if(arguments.size()!=5)
+  {
+    std::cout << "Missing required parameters" << std::endl;
+    return;    
+  }
+  mClientSocketSender.destroy();
+  mClientSocketSender = new ClientSocketSender(arguments[2],arguments[3].toInt());
+  mClientSocketSender.disposition(PointerDisposition::Delete);
+  bool returnCode = mClientSocketSender->sendFile(arguments[4]);
+  if(!returnCode)
+  {
+    std::cout << "The transfer failed." << std::endl;
+  }
+  else
+  {
+      std::cout << "Transfer complete" << std::endl;
+  }
+  std::cout << "Done, total took " << Utility::formatNumber(profiler.end()) << "(ms)" << std::endl;
+}

sstp/sstp.hpp

@@ -0,0 +1,33 @@
+#ifndef _SSTP_SSTP_HPP_
+#define _SSTP_SSTP_HPP_
+#include <common/block.hpp>
+#include <common/pointer.hpp>
+
+class SocketServer;
+class ClientSocketSender;
+
+class SSTP
+{
+  public:
+    SSTP();
+    virtual ~SSTP();
+    void handleServer(Block<String>& arguments);
+    void handleClient(Block<String>& arguments);
+  private:
+    SmartPointer<SocketServer> mSocketServer;
+    SmartPointer<ClientSocketSender> mClientSocketSender;
+};
+
+inline
+SSTP::SSTP()
+{
+}
+
+inline
+SSTP::~SSTP()
+{
+  mSocketServer.destroy();
+  mClientSocketSender.destroy();
+}
+
+#endif