sttnet_English.h

Go to the documentation of this file.

#ifndef PUBLIC_H
#define PUBLIC_H 1
#include<jsoncpp/json/json.h>
#include<string_view>
#include<string>
#include<atomic>
#include<iostream>
#include<unistd.h>
#include<sys/stat.h>
#include<fstream>
#include<fcntl.h>
#include<sstream>
#include<mutex>
#include<chrono>
#include<iomanip>
#include<random>
#include<cmath>
#include<thread>
#include<openssl/sha.h>
#include<netdb.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<cstring>
#include<openssl/bio.h>
#include<openssl/evp.h>
#include<openssl/buffer.h>
#include<functional>
#include<list>
#include<queue>
#include<sys/epoll.h> 
#include<condition_variable>
#include <regex>
#include<unordered_map>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include<openssl/crypto.h>
#include<signal.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<sys/wait.h>
#include<sys/shm.h>
#include<type_traits>
#include<charconv>
namespace stt
{
    namespace file
    {
    class FileTool
    {
    public:
        static bool createDir(const std::string & ddir,const mode_t &mode=0775); 
        static bool copy(const std::string &sourceFile,const std::string &objectFile);
        static bool createFile(const std::string &filePath,const mode_t &mode=0666);
        static size_t get_file_size(const std::string &fileName);
    };
    
    struct FileThreadLock
    {
        std::string loc;
        int threads;
        std::mutex lock;
        FileThreadLock(const std::string &loc,const int &threads):loc(loc),threads(threads){};
    };

    class File:private FileTool
    {
    protected:
        static std::mutex l1;
        static std::unordered_map<std::string,FileThreadLock> fl2;
    protected:
        std::mutex che;
        
    private:
        void lockfl2();
        void unlockfl2();
    private:
        std::ifstream fin;
        std::vector<std::string> data;
        std::vector<std::string> backUp;
        char *data_binary=nullptr;
        char *backUp_binary=nullptr;
        size_t size1=0;
        size_t size2=0;
        int multiple=0;
        size_t multiple_backup=0;
        size_t malloced=0;
        std::mutex fl1;
        
        std::ofstream fout;
        std::string fileName;
        
        std::string fileNameTemp;
        bool flag=false;
        bool binary;
        mode_t mode;
        size_t size=0;
        uint64_t totalLines=0;
    private:
        void toMemory();
        bool toDisk();
    public:
        bool openFile(const std::string &fileName,const bool &create=true,const int &multiple=0,const size_t &size=0,const mode_t &mode=0666);
        bool closeFile(const bool &del=false);
        ~File(){closeFile(false);}
        bool isOpen(){return flag;}
        bool isBinary(){return binary;}
        std::string getFileName(){return fileName;}
        uint64_t getFileLine(){return totalLines;}
        size_t getFileSize(){return size;}
        size_t getSize1(){return size1;}
    public:
        bool lockMemory();
        bool unlockMemory(const bool &rec=false);
    public:
        int findC(const std::string &targetString,const int linePos=1);
        bool appendLineC(const std::string &data,const int &linePos=0);
        bool deleteLineC(const int &linePos=0);
        bool deleteAllC();
        bool chgLineC(const std::string &data,const int &linePos=0);
        bool readLineC(std::string &data,const int linePos);
        std::string& readC(std::string &data,const int &linePos,const int &num);
        std::string& readAllC(std::string &data);
        bool readC(char *data,const size_t &pos,const size_t &size);
        bool writeC(const char *data,const size_t &pos,const size_t &size);
        void formatC();
    public:
        int find(const std::string &targetString,const int linePos=1);
        bool appendLine(const std::string &data,const int &linePos=0);
        bool deleteLine(const int &linePos=0);
        bool deleteAll();
        bool chgLine(const std::string &data,const int &linePos=0);
        bool readLine(std::string &data,const int linePos);
        std::string& read(std::string &data,const int &linePos,const int &num);
        std::string& readAll(std::string &data);
        bool read(char *data,const size_t &pos,const size_t &size);
        bool write(const char *data,const size_t &pos,const size_t &size);
        void format();
    };
    }
    namespace time
    {
    struct Duration
{
    long long day;
    int hour;
    int min;
    int sec;
    int msec;
    Duration(long long a, int b, int c, int d, int e) : day(a), hour(b), min(c), sec(d), msec(e) {}
    Duration() = default;
    bool operator>(const Duration &b)
    {
        long long total;
        total = day * 24 * 60 * 60 * 1000 + hour * 60 * 60 * 1000 + min * 60 * 1000 + sec * 1000 + msec;
        long long totalB;
        totalB = b.day * 24 * 60 * 60 * 1000 + b.hour * 60 * 60 * 1000 + b.min * 60 * 1000 + b.sec * 1000 + b.msec;
        if (total > totalB)
            return true;
        else
            return false;
    }
    bool operator<(const Duration &b)
    {
        long long total;
        total = day * 24 * 60 * 60 * 1000 + hour * 60 * 60 * 1000 + min * 60 * 1000 + sec * 1000 + msec;
        long long totalB;
        totalB = b.day * 24 * 60 * 60 * 1000 + b.hour * 60 * 60 * 1000 + b.min * 60 * 1000 + b.sec * 1000 + b.msec;
        if (total < totalB)
            return true;
        else
            return false;
    }
    bool operator==(const Duration &b)
    {
        long long total;
        total = day * 24 * 60 * 60 * 1000 + hour * 60 * 60 * 1000 + min * 60 * 1000 + sec * 1000 + msec;
        long long totalB;
        totalB = b.day * 24 * 60 * 60 * 1000 + b.hour * 60 * 60 * 1000 + b.min * 60 * 1000 + b.sec * 1000 + b.msec;
        if (total == totalB)
            return true;
        else
            return false;
    }
    bool operator>=(const Duration &b)
    {
        long long total;
        total = day * 24 * 60 * 60 * 1000 + hour * 60 * 60 * 1000 + min * 60 * 1000 + sec * 1000 + msec;
        long long totalB;
        totalB = b.day * 24 * 60 * 60 * 1000 + b.hour * 60 * 60 * 1000 + b.min * 60 * 1000 + b.sec * 1000 + b.msec;
        if (total >= totalB)
            return true;
        else
            return false;
    }
    bool operator<=(const Duration &b)
    {
        long long total;
        total = day * 24 * 60 * 60 * 1000 + hour * 60 * 60 * 1000 + min * 60 * 1000 + sec * 1000 + msec;
        long long totalB;
        totalB = b.day * 24 * 60 * 60 * 1000 + b.hour * 60 * 60 * 1000 + b.min * 60 * 1000 + b.sec * 1000 + b.msec;
        if (total <= totalB)
            return true;
        else
            return false;
    }
    time::Duration operator+(const time::Duration &b)
    {
        long long dayy = day;
        int hourr = hour;
        int minn = min;
        int secc = sec;
        int msecc = msec;

        msecc += b.msec;
        secc += b.sec;
        minn += b.min;
        hourr += b.hour;
        dayy += b.day;

        if (msecc / 1000 != 0)
        {
            secc += msecc / 1000;
            msecc = msecc % 1000;
        }

        if (secc / 60 != 0)
        {
            minn += secc / 60;
            secc = secc % 60;
        }

        if (minn / 60 != 0)
        {
            hourr += minn / 60;
            minn = minn % 60;
        }

        if (hourr / 24 != 0)
        {
            dayy += hourr / 24;
            hourr = hourr % 24;
        }
        return time::Duration(dayy, hourr, minn, secc, msecc);
    }
    time::Duration operator-(const time::Duration &b)
    {
        long long dayy = day;
        int hourr = hour;
        int minn = min;
        int secc = sec;
        int msecc = msec;

        msecc = dayy * 24 * 60 * 60 * 1000 + hourr * 60 * 60 * 1000 + minn * 60 * 1000 + secc * 1000 + msecc - b.day * 24 * 60 * 60 * 1000 - b.hour * 60 * 60 * 1000 - b.min * 60 * 1000 - b.sec * 1000 - b.msec;
        secc = 0;
        minn = 0;
        hourr = 0;
        dayy = 0;

        if (msecc / 1000 != 0)
        {
            secc += msecc / 1000;
            msecc = msecc % 1000;
        }

        if (secc / 60 != 0)
        {
            minn += secc / 60;
            secc = secc % 60;
        }

        if (minn / 60 != 0)
        {
            hourr += minn / 60;
            minn = minn % 60;
        }

        if (hourr / 24 != 0)
        {
            dayy += hourr / 24;
            hourr = hourr % 24;
        }
        return time::Duration(dayy, hourr, minn, secc, msecc);
    }
    
    double convertToDay()
    { 
        long long total;
        total = hour * 60 * 60 * 1000 + min * 60 * 1000 + sec * 1000 + msec; 
        double k = day + total / 86400000.0000;
        return k;
    }
    double convertToHour()
    {
        long long total;
        total = min * 60 * 1000 + sec * 1000 + msec; 
        double k = day * 24 + hour + total / 36000000.0000;
        return k;
    }
    double convertToMin()
    {
        long long total;
        total = sec * 1000 + msec; 
        double k = day * 24 * 60 + hour * 60 + min + total / 60000.0000;
        return k;
    }
    double convertToSec()
    {
        long long total;
        total = msec; 
        double k = day * 24 * 60 * 60 + hour * 60 * 60 + min * 60 + sec + total / 1000.0000;
        return k;
    }
    long long convertToMsec()
    {
        long long total;
        total = day * 24 * 60 * 60 * 1000 + hour * 60 * 60 * 1000 + min * 60 * 1000 + sec * 1000 + msec;
        return total;
    }
    Duration recoverForm(const long long &t)
    {
        msec = t;
        sec = 0;
        min = 0;
        hour = 0;
        day = 0;

        if (msec / 1000 != 0)
        {
            sec += msec / 1000;
            msec = msec % 1000;
        }

        if (sec / 60 != 0)
        {
            min += sec / 60;
            sec = sec % 60;
        }

        if (min / 60 != 0)
        {
            hour += min / 60;
            min = min % 60;
        }

        if (hour / 24 != 0)
        {
            day += hour / 24;
            hour = hour % 24;
        }
        return Duration(day, hour, min, sec, msec);
    }
};
std::ostream& operator<<(std::ostream &os, const Duration &a);

using Milliseconds = std::chrono::duration<uint64_t, std::milli>;
using Seconds = std::chrono::duration<uint64_t>;
#define ISO8086A "yyyy-mm-ddThh:mi:ss"

#define ISO8086B "yyyy-mm-ddThh:mi:ss.sss"


class DateTime
{
private:
    static Duration& dTOD(const Milliseconds& d1, Duration &D1);
    static Milliseconds& DTOd(const Duration &D1, Milliseconds& d1);
    static std::string &toPGtimeFormat();
    static std::chrono::system_clock::time_point strToTimePoint(const std::string &timeStr, const std::string &format = ISO8086A);
    static std::string& timePointToStr(const std::chrono::system_clock::time_point &tp, std::string &timeStr, const std::string &format = ISO8086A);
public:
    static std::string& getTime(std::string &timeStr, const std::string &format = ISO8086A);
    static bool convertFormat(std::string &timeStr, const std::string &oldFormat, const std::string &newFormat = ISO8086A);
    static Duration& calculateTime(const std::string &time1, const std::string &time2, Duration &result, const std::string &format1 = ISO8086A, const std::string &format2 = ISO8086A);
    static std::string& calculateTime(const std::string &time1, const Duration &time2, std::string &result, const std::string &am, const std::string &format1 = ISO8086A, const std::string &format2 = ISO8086A);
    static bool compareTime(const std::string &time1, const std::string &time2, const std::string &format1 = ISO8086A, const std::string &format2 = ISO8086A);
private:
    Duration dt{-1, -1, -1, -1, -1};
    bool flag = false;
    std::chrono::steady_clock::time_point start;
    std::chrono::steady_clock::time_point end;
public:
    bool startTiming();
    Duration checkTime();
    Duration endTiming();
public:
    Duration getDt() { return dt; }
    bool isStart() { return flag; }
};
}
namespace file
{
class LogFile : private time::DateTime, protected file::File
{
private:
    std::string timeFormat;
    std::string contentFormat;
public:
    bool openFile(const std::string &fileName, const std::string &timeFormat = ISO8086A, const std::string &contentFormat = "   ");
    bool isOpen() { return File::isOpen(); }
    std::string getFileName() { return File::getFileName(); }
    bool closeFile(const bool &del = false);
    bool writeLog(const std::string &data);
    bool clearLog();
    bool deleteLogByTime(const std::string &date1 = "1", const std::string &date2 = "2");
};
}
    namespace data
    {
        class CryptoUtil
        {
        public:
            static bool encryptSymmetric(const unsigned char *before, const size_t &length, const unsigned char *passwd, const unsigned char *iv, unsigned char *after);
            static bool decryptSymmetric(const unsigned char *before, const size_t &length, const unsigned char *passwd, const unsigned char *iv, unsigned char *after);
            static std::string& sha1(const std::string &ori_str, std::string &result);
            static std::string& sha11(const std::string &ori_str, std::string &result);
        };
        class BitUtil
        {
        public:
            static std::string& bitOutput(char input, std::string &result);
            static std::string& bitOutput(const std::string &input, std::string &result);
            static char& bitOutput_bit(char input, const int pos, char &result);
            static unsigned long& bitStrToNumber(const std::string &input, unsigned long &result);
            static unsigned long& bitToNumber(const std::string &input, unsigned long &result);
            static char& toBit(const std::string &input, char &result);
            static std::string& toBit(const std::string &input, std::string &result);
        };
        class RandomUtil
        {
        public:
            static long getRandomNumber(const long &a, const long &b);
            static std::string& getRandomStr_base64(std::string &str, const int &length);
            static std::string& generateMask_4(std::string &mask);
        };
        class NetworkOrderUtil
        {
        public:
            static unsigned long& htonl_ntohl_64(unsigned long &data); // 64-bit unsigned number conversion to big/little endian (network byte order)
        };
        
        class PrecisionUtil
        {
        public:
        
            static std::string& getPreciesFloat(const float &number, const int &bit, std::string &str);
            static float& getPreciesFloat(float &number, const int &bit);
            static std::string& getPreciesDouble(const double &number, const int &bit, std::string &str);
            static double& getPreciesDouble(double &number, const int &bit);
            static float& getValidFloat(float &number, const int &bit);
        };
        class HttpStringUtil
        {
        public:
            static size_t get_split_str(const std::string_view& ori_str, std::string_view &str, const std::string_view &a, const std::string_view &b, const size_t &pos = 0);
            static std::string_view& get_value_str(const std::string_view& ori_str, std::string_view &str, const std::string& name);
            static std::string_view& get_value_header(const std::string_view& ori_str, std::string_view &str, const std::string& name);
            static std::string_view& get_location_str(const std::string_view& ori_str, std::string_view &str);
            static std::string_view& getLocPara(const std::string_view &url, std::string_view &locPara);
            static std::string_view& getPara(const std::string_view &url, std::string_view &para);



            static size_t get_split_str(const std::string_view& ori_str, std::string &str, const std::string_view &a, const std::string_view &b, const size_t &pos = 0);
            static std::string& get_value_str(const std::string& ori_str, std::string &str, const std::string& name);
            static std::string& get_value_header(const std::string& ori_str, std::string &str, const std::string& name);
            static std::string& get_location_str(const std::string& ori_str, std::string &str);
            static std::string& getLocPara(const std::string &url, std::string &locPara);
            static std::string& getPara(const std::string &url, std::string &para);
            static std::string& getIP(const std::string &url, std::string &IP);
            static int& getPort(const std::string &url, int &port);
            static std::string createHeader(const std::string& first, const std::string& second);
            template<class... Args>
            static std::string createHeader(const std::string& first, const std::string& second, Args... args)
            {
                std::string cf = first + ": " + second + "\r\n" + createHeader(args...);
                return cf;
            }
        };
        class WebsocketStringUtil
        {
        public:
            static std::string& transfer_websocket_key(std::string &str);
        };
        class NumberStringConvertUtil
        {
        public:
            static int& toInt(const std::string_view&ori_str, int &result, const int &i = -1);
            static int& str16toInt(const std::string_view&ori_str, int &result,const int &i=-1);
            static long& toLong(const std::string_view&ori_str, long &result, const long &i = -1);
            static float& toFloat(const std::string&ori_str, float &result, const float &i = -1);
            static double& toDouble(const std::string&ori_str, double &result, const double &i = -1);
            static bool& toBool(const std::string_view&ori_str, bool &result);
            static std::string& strto16(const std::string &ori_str, std::string &result); // String to hexadecimal string     (Not needed for now) (To be fixed)
        };
        class EncodingUtil
        {
        public:
            static std::string base64_encode(const std::string &input);
            static std::string base64_decode(const std::string &input);
            static std::string& transfer_websocket_key(std::string &str);
            static std::string& generateMask_4(std::string &mask);
            static std::string& maskCalculate(std::string &data, const std::string &mask);
        };
        class JsonHelper
        {
            public:
            static int getValue(const std::string &oriStr,std::string& result,const std::string &type="value",const std::string &name="a",const int &num=0);

            static std::string toString(const Json::Value &val);
            static Json::Value toJsonArray(const std::string & str);
            template<class T1, class T2>
            static std::string createJson(T1 first, T2 second)
            {
                Json::Value root;
                root[first] = second;
                Json::StreamWriterBuilder builder;
                std::string jsonString = Json::writeString(builder, root);
                return jsonString;
            }
             template<class T1, class T2, class... Args>
            static std::string createJson(T1 first, T2 second, Args... args)
            {
                Json::Value root;
                root[first] = second;
                std::string kk = createJson(args...);
                Json::StreamWriterBuilder builder;
                std::string jsonString = Json::writeString(builder, root);
                jsonString = jsonString.erase(jsonString.length() - 2);
                kk = kk.substr(1);
                return jsonString + "," + kk;

            }
            template<class T>
            static std::string createArray(T first)
            {
                Json::Value root(Json::arrayValue);
                root.append(first);
                Json::StreamWriterBuilder builder;
                std::string jsonString = Json::writeString(builder, root);
                return jsonString;
            }
            template<class T, class... Args>
            static std::string createArray(T first, Args... args)
            {
                Json::Value root(Json::arrayValue);
                root.append(first);
                std::string kk = createArray(args...);
                Json::StreamWriterBuilder builder;
                std::string jsonString = Json::writeString(builder, root);
                jsonString = jsonString.erase(jsonString.length() - 2);
                kk = kk.substr(1);
                return jsonString + "," + kk;

            }
            static std::string jsonAdd(const std::string &a, const std::string &b);
            static std::string& jsonFormatify(const std::string &a, std::string &b);
            static std::string& jsonToUTF8(const std::string &input, std::string &output);
        };
    }

    namespace security
    {
        struct IPInformation
        {
            int connectionNum;
            std::deque<std::chrono::steady_clock::time_point> connectionTimeQueue;
        };
        class ConnectionLimiter
        {
        private:
            int connectionLimit;
            int connectionRateLimit;
            std::unordered_map<std::string,IPInformation> connectionTable;

        public:
            ConnectionLimiter(const int &connectionLimit=20,const int &connectionRateLimit=6):connectionLimit(connectionLimit),connectionRateLimit(connectionRateLimit){}
            bool allow(const std::string &ip);
            void clearIP(const std::string &ip);
        };
    }

    namespace network
    {
    class TcpFDHandler
    {
    protected:
        int fd = -1;
        bool flag1 = false;
        bool flag2 = false;
        SSL *ssl = nullptr;
        int sec=-1;
    public:
        bool flag3 = false;
    public:
        void setFD(const int &fd, SSL *ssl, const bool &flag1 = false, const bool &flag2 = false,const int &sec=-1);
        int getFD() { return fd; }
        SSL *getSSL() { return ssl; }
        void close(const bool &cle = true);
        void blockSet(const int &sec = -1);
        void unblockSet();
        bool multiUseSet();
        bool isConnect() { if (fd == -1) return false; else return true; }
    public:
        int sendData(const std::string &data, const bool &block = true);
        int sendData(const char *data, const uint64_t &length, const bool &block = true);
        int recvDataByLength(std::string &data, const uint64_t &length, const int &sec = 2);
        int recvDataByLength(char *data, const uint64_t &length, const int &sec = 2);
        int recvData(std::string &data, const uint64_t &length);
        int recvData(char *data, const uint64_t &length);
    };

    class TcpClient : public TcpFDHandler
    {
    private:
        std::string serverIP = "";
        int serverPort = -1;
        bool flag = false;
        bool TLS;
        SSL_CTX *ctx = nullptr;
        const char *ca;
        const char *cert;
        const char *key;
        const char *passwd;
    private:
        bool createFD();
        void closeAndUnCreate();
        bool initCTX(const char *ca, const char *cert = "", const char *key = "", const char *passwd = "");
    public:
        TcpClient(const bool &TLS = false, const char *ca = "", const char *cert = "", const char *key = "", const char *passwd = "");
        bool connect(const std::string &ip, const int &port);        
        void resetCTX(const bool &TLS = false, const char *ca = "", const char *cert = "", const char *key = "", const char *passwd = "");
        bool close();
        ~TcpClient() { closeAndUnCreate(); }
    public:
        std::string getServerIP() { return serverIP; }
        int getServerPort() { return serverPort; }
        bool isConnect() { return flag; }
    };  

    class HttpClient : private TcpClient
    {
    private:
        bool flag = false;
    public:
        HttpClient(const bool &TLS = false, const char *ca = "", const char *cert = "", const char *key = "", const char *passwd = "") : TcpClient(TLS, ca, cert, key, passwd) {}
    public:
        bool getRequest(const std::string &url, const std::string &header = "", const std::string &header1 = "Connection: keep-alive",const int &sec=-1);
        bool postRequest(const std::string &url, const std::string &body = "", const std::string &header = "", const std::string &header1 = "Connection: keep-alive",const int &sec=-1);
        bool getRequestFromFD(const int &fd, SSL *ssl, const std::string &url, const std::string &header = "", const std::string &header1 = "Connection: keep-alive",const int &sec=2);
        bool postRequestFromFD(const int &fd, SSL *ssl, const std::string &url, const std::string &body = "", const std::string &header = "", const std::string &header1 = "Connection: keep-alive",const int &sec=2);
    public:
        bool isReturn() { return flag; }
        std::string header = "";
        std::string body = "";
    };
    
    class EpollSingle
    {
    private:
        int fd;
        bool flag = true;
        std::function<bool(const int &fd)> fc = [](const int &fd)->bool
        {return true;};
        std::function<void(const int &fd)> fcEnd = [](const int &fd)->void
        {};
        std::function<bool(const int &fd)> fcTimeOut = [](const int &fd)->bool
        {return true;};
        bool flag1 = true;
        bool flag2 = false;
        time::Duration dt{0,20,0,0,0};
        bool flag3 = false;
        time::Duration t;
    private:
        void epolll();
    public:
        void startListen(const int &fd, const bool &flag = true, const time::Duration &dt = time::Duration{0,0,20,0,0});
    public:
        bool isListen() { return flag2; }
        void setFunction(std::function<bool(const int &fd)> fc) { this->fc = fc; }
        void setEndFunction(std::function<void(const int &fd)> fcEnd) { this->fcEnd = fcEnd; };
        void setTimeOutFunction(std::function<bool(const int &fd)> fcTimeOut) { this->fcTimeOut = fcTimeOut; };
        bool endListen();
        void endListenWithSignal() { flag1 = false; }
        void waitAndQuit(const time::Duration &t = time::Duration{0,0,0,10,10}) { flag3 = true; this->t = t; }
        ~EpollSingle() { endListen(); }
    };
    
    class WebSocketClient : private TcpClient 
    {
    private:
        bool flag4 = false;
        std::function<bool(const std::string &message, WebSocketClient &k)> fc = [](const std::string &message, WebSocketClient &k)->bool
        {std::cout<<"Received: "<<message<<std::endl;return true;};
        std::string url;
        EpollSingle k;
        bool flag5 = false;
    private:
        bool close1();
    public:
        WebSocketClient(const bool &TLS = false, const char *ca = "", const char *cert = "", const char *key = "", const char *passwd = "") : TcpClient(TLS, ca, cert, key, passwd) {}
        void setFunction(std::function<bool(const std::string &message, WebSocketClient &k)> fc) { this->fc = fc; }
        bool connect(const std::string &url, const int &min = 20);
        bool sendMessage(const std::string &message, const std::string &type = "0001");
        void close(const std::string &closeCodeAndMessage, const bool &wait = true);
        void close(const short &code = 1000, const std::string &message = "bye", const bool &wait = true);       
    public:
        bool isConnect() { return flag4; }
        std::string getUrl() { return url; }
        std::string getServerIp() { return TcpClient::getServerIP(); }
        std::string getServerPort() { return TcpClient::getServerIP(); }
        ~WebSocketClient();
    };

    struct HttpRequestInformation 
    {
        std::string_view type;
        std::string_view locPara;
        std::string_view loc;
        std::string_view para;
        std::string_view header;
        std::string_view body;
        std::string body_chunked;
    
    };

    struct TcpFDInf;
    class HttpServerFDHandler : public TcpFDHandler
    {
    public:
        void setFD(const int &fd, SSL *ssl = nullptr, const bool &flag1 = false, const bool &flag2 = true) { TcpFDHandler::setFD(fd, ssl, flag1, flag2); }
        int solveRequest(TcpFDInf &TcpInf,const unsigned long &buffer_size,const int &times=1);
        bool sendBack(const std::string &data, const std::string &header = "", const std::string &code = "200 OK", const std::string &header1 = "");
        bool sendBack(const char *data,const size_t &length,const char *header="\0",const char *code="200 OK\0",const char *header1="\0",const size_t &header_length=50);
    };

    struct WebSocketFDInformation
    {
        int fd;
        bool closeflag;
        std::string locPara;
        std::string header;
        time_t HBTime = 0;
        time_t response;
        size_t recv_length;
        int message_type;
        std::string message="";
        bool fin;
        std::string mask;

    };

    struct TcpFDInf
    {
        int fd;
        std::string ip;
        std::string port;
        int status;
        std::string_view data;
        struct HttpRequestInformation HttpInf;
        SSL* ssl;

        char *buffer;
        unsigned long p_buffer_now;
        //unsigned long p_request_now;
        HttpServerFDHandler k;
        std::deque<std::chrono::steady_clock::time_point> requestSpeedQueue;
    };

    struct QueueFD
    {
    int fd;
    bool close;
    };
    
    class TcpServer 
    {
    protected:
        unsigned long buffer_size;
        int maxFD;
        security::ConnectionLimiter connectionLimiter;
        //std::unordered_map<int,TcpFDInf> clientfd;
        //std::mutex lc1;
        TcpFDInf *clientfd;
        int flag1 = true;
        std::queue<QueueFD> *fdQueue;
        std::mutex *lq1;
        //std::condition_variable cv1;
        std::condition_variable *cv;
        int consumerNum;
        std::mutex lco1;
        bool unblock;
        SSL_CTX *ctx = nullptr;
        bool TLS = false;
        //std::unordered_map<int,SSL*> tlsfd;
        //std::mutex ltl1;
        int requestRate;
        int checkFrequency;
        int connectionTimeout;
        bool security_open;
    protected:
        bool allowRequest(const int &cclientfd);
        void connectionDetect();
    private:
        std::function<bool(TcpFDHandler &k,TcpFDInf &inf)> fc;
        int fd = -1;
        int port = -1;
        int flag = false;
        bool flag2 = false;
    private:
        void epolll(const int &evsNum);
        virtual void consumer(const int &threadID);
    public:
        TcpServer(const int &maxFD=10000,const bool &security_open=true,const int &connectionNumLimit=20,const int &connectionRateLimit=6,const int &buffer_size=8,const int &requestRate=12,const int &checkFrequency=1,const int &connectionTimeout=1800):maxFD(maxFD),connectionLimiter(connectionNumLimit,connectionRateLimit),security_open(security_open),buffer_size(buffer_size*1024),requestRate(requestRate),checkFrequency(checkFrequency),connectionTimeout(connectionTimeout){}
        bool startListen(const int &port, const int &threads = 8);
        bool setTLS(const char *cert, const char *key, const char *passwd, const char *ca);
        void redrawTLS();
        bool setFunction(std::function<bool(TcpFDHandler &k,TcpFDInf &inf)> fc) { this->fc = fc; return true; }
        bool stopListen();
        bool close();
        bool close(const int &fd);
    public:
        bool isListen() { return flag; }
        SSL* getSSL(const int &fd);
        ~TcpServer() { close(); }
    };


    
    class HttpServer : public TcpServer
    {
    private:
        std::function<bool(const HttpRequestInformation &inf, HttpServerFDHandler &k)> fc;
    private:
        void consumer(const int &threadID);
    public:
        HttpServer(const int &maxFD=10000000,const bool &security_open=true,const int &connectionNumLimit=20,const int &connectionRateLimit=6,const int &buffer_size=8,const int &requestRate=12,const int &checkFrequency=1,const int &connectionTimeout=60):TcpServer(maxFD,security_open,connectionNumLimit,connectionRateLimit,buffer_size,requestRate,checkFrequency,connectionTimeout){}
        bool setFunction(std::function<bool(const HttpRequestInformation &inf, HttpServerFDHandler &k)> fc) { this->fc = fc; return true; }
    };
    class WebSocketServerFDHandler : private TcpFDHandler
    {
    public:
        void setFD(const int &fd, SSL *ssl = nullptr, const bool &flag1 = false, const bool &flag2 = true) { TcpFDHandler::setFD(fd, ssl, flag1, flag2); }
        int getMessage(TcpFDInf &Tcpinf,WebSocketFDInformation &Websocketinf,const int &ii=1);
        bool sendMessage(const std::string &msg, const std::string &type = "0001");
       
    };
    
    class WebSocketServer : public TcpServer
    {
    private:
        std::unordered_map<int, WebSocketFDInformation> wbclientfd;
        std::mutex lwb;
        std::function<bool(const std::string &msg, WebSocketServer &k,const WebSocketFDInformation &inf)> fc = [](const std::string &message, WebSocketServer &k,const WebSocketFDInformation &inf)->bool
        {std::cout << "Received: " << message << std::endl; return true;};
        std::function<bool(const WebSocketFDInformation &k)> fcc = [](const WebSocketFDInformation &k)
        {return true;};
        std::function<void(const WebSocketFDInformation &inf, WebSocketServer &k)> fccc = [](const WebSocketFDInformation &inf, WebSocketServer &k)
        {

        };
        int seca = 20*60;
        int secb = 30;
        bool HBflag;
        bool HBflag1;
    private:
        void consumer(const int &threadID);
       
        void closeAck(const int &fd, const std::string &closeCodeAndMessage);
        void closeAck(const int &fd, const short &code = 1000, const std::string &message = "bye");
        void HB();
        bool closeWithoutLock(const int &fd, const std::string &closeCodeAndMessage);
        bool closeWithoutLock(const int &fd, const short &code = 1000, const std::string &message = "bye");
    public:
        WebSocketServer(const int &maxFD=10000000,const bool &security_open=true,const int &connectionNumLimit=20,const int &connectionRateLimit=6,const int &buffer_size=8,const int &requestRate=12):TcpServer(maxFD,security_open,connectionNumLimit,connectionRateLimit,buffer_size,requestRate,-1,-1){}
        void setStartFunction(std::function<void(const WebSocketFDInformation &inf, WebSocketServer &k)> fccc) { this->fccc = fccc; }
        void setJudgeFunction(std::function<bool(const WebSocketFDInformation &k)> fcc) { this->fcc = fcc; }
        void setFunction(std::function<bool(const std::string &msg, WebSocketServer &k,const WebSocketFDInformation &inf)> fc) { this->fc = fc; }
        void setTimeOutTime(const int &seca) { this->seca = seca * 60; }
        void setHBTimeOutTime(const int &secb) { this->secb = secb; }
        bool close(const int &fd, const std::string &closeCodeAndMessage);
        bool close(const int &fd, const short &code = 1000, const std::string &message = "bye");
        bool sendMessage(const int &fd, const std::string &msg, const std::string &type = "0001") { WebSocketServerFDHandler k; k.setFD(fd, getSSL(fd), unblock); return k.sendMessage(msg, type); }
        bool close();
        bool startListen(const int &port, const int &threads = 8)
        {
            std::thread(&WebSocketServer::HB, this).detach();
            return TcpServer::startListen(port, threads);
        }
        void sendMessage(const std::string &msg, const std::string &type = "0001");
        ~WebSocketServer() { HBflag1 = false; while(HBflag); }
    };

    class UdpFDHandler
    {
    protected:
        int fd = -1;
        bool flag1 = false;
        bool flag2 = false;
        int sec = -1;
    public:
        void setFD(const int &fd, const bool &flag1 = false, const int &sec = -1, const bool &flag2 = false);
        void blockSet(const int &sec = -1);
        void unblockSet();
        bool multiUseSet();
        int getFD() { return fd; }
        void close(const bool &cle = true);
        int sendData(const std::string &data, const std::string &ip, const int &port, const bool &block = true);
        int sendData(const char *data, const uint64_t &length, const std::string &ip, const int &port, const bool &block = true);
        int recvData(std::string &data, const uint64_t &length, std::string &ip, int &port);
        int recvData(char *data, const uint64_t &length, std::string &ip, int &port);
        
    };
    class UdpClient : public UdpFDHandler
    {
    public:
        UdpClient(const bool &flag1 = false, const int &sec = -1);
        bool createFD(const bool &flag1 = false, const int &sec = -1);
        ~UdpClient() { close(); }
    };
    class UdpServer : public UdpFDHandler
    {
    public:
        UdpServer(const int &port, const bool &flag1 = false, const int &sec = -1, const bool &flag2 = true);
        bool createFD(const int &port, const bool &flag1 = false, const int &sec = -1, const bool &flag2 = true);
        ~UdpServer() { close(); }
    };
    }
    namespace system
    {
        class ServerSetting
        {
        public:
            static file::LogFile *logfile;
            static std::string language;
        private:
            static void signalterminated(){std::cout<<"Terminated by uncaught exception"<<std::endl;if(ServerSetting::logfile!=nullptr){if(ServerSetting::language=="Chinese")ServerSetting::logfile->writeLog("未捕获的异常终止");else ServerSetting::logfile->writeLog("end for uncaught exception");}kill(getpid(),15);}
            static void signalSIGSEGV(int signal){std::cout<<"SIGSEGV"<<std::endl;if(ServerSetting::logfile!=nullptr){if(ServerSetting::language=="Chinese")ServerSetting::logfile->writeLog("信号SIGSEGV");else ServerSetting::logfile->writeLog("signal SIGSEGV");}kill(getpid(),15);}
            static void signalSIGABRT(int signal){std::cout<<"SIGABRT"<<std::endl;if(ServerSetting::logfile!=nullptr){if(ServerSetting::language=="Chinese")ServerSetting::logfile->writeLog("信号SIGABRT");else ServerSetting::logfile->writeLog("signal SIGABRT");}kill(getpid(),15);}
        public:
            static void setExceptionHandling();
            static void setLogFile(file::LogFile *logfile = nullptr, const std::string &language = "");
            static void init(file::LogFile *logfile = nullptr, const std::string &language = "");
        };
        
        class csemp
        {
        private:
            union semun  
            {
                int val;                
                struct semid_ds *buf;   
                unsigned short  *arry;  
            };

            int   m_semid;      
            short m_sem_flg;    

            csemp(const csemp &) = delete;             
            csemp &operator=(const csemp &) = delete;  

        public:
            csemp():m_semid(-1){}

            bool init(key_t key, unsigned short value = 1, short sem_flg = SEM_UNDO);

            bool wait(short value = -1);

            bool post(short value = 1);

            int getvalue();

            bool destroy();

            ~csemp();
        };

        #define MAX_PROCESS_NAME 100

        #define MAX_PROCESS_INF 1000

        #define SHARED_MEMORY_KEY 0x5095

        #define SHARED_MEMORY_LOCK_KEY 0x5095

        struct ProcessInf
        {
            pid_t pid;
            time_t lastTime;
            char name[MAX_PROCESS_NAME];
            char argv0[20];
            char argv1[20];
            char argv2[20];
        };

        class HBSystem
        {
        private:
        
            static ProcessInf *p;
            static csemp plock;
            static bool isJoin;
        public:
            bool join(const char *name, const char *argv0 = "", const char *argv1 = "", const char *argv2 = "");
            bool renew();
            static void list();
            static bool HBCheck(const int &sec);
            bool deleteFromHBS();
            ~HBSystem();
        };

        class Process
        {
        public:
        

            template<class... Args>
            static bool startProcess(const std::string &name, const int &sec = -1, Args ...args)
            {
                std::vector<const char *> paramList={args...,nullptr};
                if(sec==-1)
                {
                    pid_t pid=fork();
                    if(pid==-1)
                        return false;
                    if(pid>0)
                        return true;
                    else
                    {
                        execv(name.c_str(),const_cast<char* const*>(paramList.data()));
                        return false;
                    }
                }
                for(int ii=1;ii<=64;ii++)
                    signal(ii,SIG_IGN);           
                pid_t pid=fork();
                if(pid==-1)
                    return false;
                if(pid>0)
                {   
                    return true;
                }
                else
                {
                    signal(SIGCHLD,SIG_DFL);
                    signal(15,SIG_DFL);
                    while(1)
                    {
                        pid=fork();
                        if(fork()==0)
                        {
                            execv(name.c_str(),const_cast<char* const*>(paramList.data()));
                            exit(0);
                        }
                        else if(pid>0)
                        {
                            int sts;
                            wait(&sts);
                            sleep(sec);
                        }
                        else
                            continue;
                    }
                }
            }
            template<class Fn, class... Args>
            static typename std::enable_if<!std::is_convertible<Fn, std::string>::value, bool>::type
            startProcess(Fn&& fn, const int &sec = -1, Args &&...args)
            {
                if(sec==-1)
                {
                    pid_t pid=fork();
                    if(pid==-1)
                        return false;
                    if(pid>0)
                        return true;
                    else
                    {
                        auto f=std::bind(std::forward<Fn>(fn),std::forward<Args>(args)...);
                        f();
                        return true;
                    }
                }
                for(int ii=1;ii<=64;ii++)
                    signal(ii,SIG_IGN);           
                pid_t pid=fork();
                if(pid==-1)
                    return false;
                if(pid>0)
                {   
                    return true;
                }
                else
                {
                    signal(SIGCHLD,SIG_DFL);
                    signal(15,SIG_DFL);
                    while(1)
                    {
                        pid=fork();
                        if(pid==0)
                        {
                            auto f=std::bind(std::forward<Fn>(fn),std::forward<Args>(args)...);
                            f();
                            return true;
                        }
                        else if(pid>0)
                        {
                            int sts;
                            wait(&sts);
                            sleep(sec);
                        }
                        else
                            continue;
                    }
                }
            }
        };
    }

    
}


#endif