sttnet.h

浏览该文件的文档.

#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;
        }
        Duration operator+(const 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 Duration(dayy,hourr,minn,secc,msecc);
        }
        Duration operator-(const 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 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
    {
    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位无符号数转化为大/小端序（网络字节序）
        };
        
        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);//字符串转化为16进制字符串     (暂不需要)(待修复)
        };
        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<<"收到: "<<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<<"收到: "<<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<<"未捕获的异常终止"<<std::endl;if(system::ServerSetting::logfile!=nullptr){if(system::ServerSetting::language=="Chinese")system::ServerSetting::logfile->writeLog("未捕获的异常终止");else system::ServerSetting::logfile->writeLog("end for uncaught exception");}kill(getpid(),15);}
            static void signalSIGSEGV(int signal){std::cout<<"SIGSEGV"<<std::endl;if(system::ServerSetting::logfile!=nullptr){if(system::ServerSetting::language=="Chinese")system::ServerSetting::logfile->writeLog("信号SIGSEGV");else system::ServerSetting::logfile->writeLog("signal SIGSEGV");}kill(getpid(),15);}
            static void signalSIGABRT(int signal){std::cout<<"SIGABRT"<<std::endl;if(system::ServerSetting::logfile!=nullptr){if(system::ServerSetting::language=="Chinese")system::ServerSetting::logfile->writeLog("信号SIGABRT");else system::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