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>
#include<any>
#include <sys/eventfd.h>
#include <sys/timerfd.h>
#include <cstddef>
#include <cstdint>
#include <new>
#include <vector>
namespace stt
{

    namespace system
    {
        class WorkerPool;

template <typename T>
class MPSCQueue {
public:
    explicit MPSCQueue(std::size_t capacity_pow2)
        : capacity_(capacity_pow2),
          mask_(capacity_pow2 - 1),
          buffer_(capacity_pow2),
          head_(0),
          tail_(0)
    {
        // capacity must be power of two
        if (capacity_ < 2 || (capacity_ & mask_) != 0) {
            // You can replace with your own assert/log
            throw std::invalid_argument("MPSCQueue capacity must be power of two and >= 2");
        }

        // Initialize per-slot sequence
        for (std::size_t i = 0; i < capacity_; ++i) {
            buffer_[i].seq.store(i, std::memory_order_relaxed);
        }
    }

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

    ~MPSCQueue() {
        // Drain remaining items to call destructors if needed
        T tmp;
        while (pop(tmp)) {}
    }

    bool push(T&& v) noexcept(std::is_nothrow_move_constructible_v<T>) {
        return emplace_impl(std::move(v));
    }

    bool push(const T& v) noexcept(std::is_nothrow_copy_constructible_v<T>) {
        return emplace_impl(v);
    }

    bool pop(T& out) noexcept(std::is_nothrow_move_assignable_v<T> &&
                              std::is_nothrow_move_constructible_v<T>)
    {
        Slot& slot = buffer_[head_ & mask_];
        const std::size_t seq = slot.seq.load(std::memory_order_acquire);
        const std::intptr_t dif = static_cast<std::intptr_t>(seq) - static_cast<std::intptr_t>(head_ + 1);

        if (dif != 0) {
            // seq != head+1 => empty
            return false;
        }

        // Move out
        out = std::move(*slot.ptr());

        // Destroy in-place
        slot.destroy();

        // Mark slot as free for producers:
        // seq = head + capacity
        slot.seq.store(head_ + capacity_, std::memory_order_release);

        ++head_;
        return true;
    }

    std::size_t approx_size() const noexcept {
        const std::size_t t = tail_.load(std::memory_order_relaxed);
        const std::size_t h = head_; // consumer-only
        return (t >= h) ? (t - h) : 0;
    }

private:
    struct Slot {
        std::atomic<std::size_t> seq;
        typename std::aligned_storage<sizeof(T), alignof(T)>::type storage;
        bool has_value = false;

        T* ptr() noexcept { return reinterpret_cast<T*>(&storage); }
        const T* ptr() const noexcept { return reinterpret_cast<const T*>(&storage); }

        template <class U>
        void construct(U&& v) noexcept(std::is_nothrow_constructible_v<T, U&&>) {
            ::new (static_cast<void*>(&storage)) T(std::forward<U>(v));
            has_value = true;
        }

        void destroy() noexcept {
            if (has_value) {
                ptr()->~T();
                has_value = false;
            }
        }
    };

    template <class U>
    bool emplace_impl(U&& v) noexcept(std::is_nothrow_constructible_v<T, U&&>) {
        std::size_t pos = tail_.load(std::memory_order_relaxed);

        for (;;) {
            Slot& slot = buffer_[pos & mask_];
            const std::size_t seq = slot.seq.load(std::memory_order_acquire);
            const std::intptr_t dif = static_cast<std::intptr_t>(seq) - static_cast<std::intptr_t>(pos);

            if (dif == 0) {
                // slot is free for this pos
                if (tail_.compare_exchange_weak(
                        pos, pos + 1,
                        std::memory_order_relaxed,
                        std::memory_order_relaxed))
                {
                    // We own this slot now
                    slot.construct(std::forward<U>(v));
                    // Publish to consumer: seq = pos+1 means "ready"
                    slot.seq.store(pos + 1, std::memory_order_release);
                    return true;
                }
                // CAS failed: pos updated with current tail; retry
            } else if (dif < 0) {
                // slot seq < pos => queue is full (producer wrapped)
                return false;
            } else {
                // Another producer is ahead; move pos forward
                pos = tail_.load(std::memory_order_relaxed);
            }
        }
    }

private:
    const std::size_t capacity_;
    const std::size_t mask_;
    std::vector<Slot> buffer_;

    // Single consumer only
    std::size_t head_;

    // Multi-producer
    std::atomic<std::size_t> tail_;
};


    }
    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);
        bool 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;
        std::atomic<bool> consumerGuard{true};
        //std::mutex queueMutex;
        //std::condition_variable queueCV;
        system::MPSCQueue<std::string> logQueue;
        std::thread consumerThread;
    public:
        LogFile(const size_t &logQueue_cap=8192):logQueue(logQueue_cap)
        {
        consumerGuard=true;
        consumerThread = std::thread([this]()->void
        {
            std::string content;
            content.reserve(1024);
            std::string time;
            content.reserve(1074);
            while(this->consumerGuard)
            {
                while(this->logQueue.pop(content))//非空则执行
                {       
                    getTime(time,timeFormat);
                    time+=contentFormat;
                    time+=content;
                    this->appendLine(time);
                }
                std::this_thread::sleep_for(std::chrono::microseconds(500));

            }
        });
        }
        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);
        void writeLog(const std::string &data);
        bool clearLog();
        bool deleteLogByTime(const std::string &date1="1",const std::string &date2="2");
        ~LogFile();
    };
    }
    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;
                if constexpr (std::is_integral_v<T2>) {
                    root[first] = Json::Value(static_cast<Json::Int64>(second));
                } else {
                    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;
                if constexpr (std::is_integral_v<T2>) {
                    root[first] = Json::Value(static_cast<Json::Int64>(second));
                } else {
                    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
    {
        enum class RateLimitType 
        {
            Cooldown,      // 连续触发惩罚：达到上限后进入冷却，需要安静 secs 才恢复
            FixedWindow,   // 固定窗口计数：每 secs 一个窗口，窗口内最多 times 次
            SlidingWindow, // 滑动窗口：统计最近 secs 内的次数（队列时间戳）
            TokenBucket    // 令牌桶：允许突发 + 控制长期平均速率（常用于 API/消息）
        };
        struct RateState
        {
            // 通用
            int counter = 0;
            int violations = 0;   // 新增：触发限流的次数
            std::chrono::steady_clock::time_point lastTime{};

            // SlidingWindow
            std::deque<std::chrono::steady_clock::time_point> history;

            // TokenBucket
            double tokens = 0.0;
            std::chrono::steady_clock::time_point lastRefill{};
        };
        struct ConnectionState
        {
            int fd = -1;
            RateState requestRate;
            std::unordered_map<std::string, RateState> pathRate;
            std::chrono::steady_clock::time_point lastActivity{};
        };
        struct IPInformation
        {
            int activeConnections = 0;
            RateState connectRate;
            int badScore = 0; //IP 风险评分（用于升级惩罚）
            std::unordered_map<int, ConnectionState> conns; // fd -> state
        };
        enum DefenseDecision : int
        {
            ALLOW = 0,  // 正常通过
            DROP  = 1,  // 不回应（丢弃）
            CLOSE = 2   // 断连（可伴随封 IP）
        };
    
        class ConnectionLimiter
        {
        public:
            ConnectionLimiter(const int& maxConn = 20, const int& idleTimeout = 60) : maxConnections(maxConn),connectionTimeout(idleTimeout){}

            // ========== 策略设置 ==========
            void setConnectStrategy(const RateLimitType &type);
            void setRequestStrategy(const RateLimitType &type);
            void setPathStrategy(const RateLimitType &type);

            // ========== Path 配置 ==========
            void setPathLimit(const std::string &path, const int &times, const int &secs);

            // ========== 核心判断 ==========
            DefenseDecision allowConnect(const std::string &ip, const int &fd,const int &times, const int &secs);
            DefenseDecision allowRequest(const std::string &ip,const int &fd,const std::string_view &path,const int &times,const int &secs);

            // ========== 生命周期 ==========
            void clearIP(const std::string &ip,const int &fd);
            bool connectionDetect(const std::string &ip,const int &fd);
        void banIP(const std::string &ip,int banSeconds,const std::string &reasonCN,const std::string &reasonEN);
    void unbanIP(const std::string &ip);
    bool isBanned(const std::string &ip) const;


        private:
            // 核心判定
            bool allow(RateState &st,const RateLimitType &type,const int &times,const int &secs,const std::chrono::steady_clock::time_point &now);

        private:
            int maxConnections;
            int connectionTimeout;

            RateLimitType connectStrategy = RateLimitType::Cooldown;
            RateLimitType requestStrategy = RateLimitType::SlidingWindow;
            RateLimitType pathStrategy    = RateLimitType::SlidingWindow;

            std::unordered_map<std::string, IPInformation> table;
            std::unordered_map<std::string, std::pair<int,int>> pathConfig;
            // IP -> 解封时间
            std::unordered_map<std::string,std::chrono::steady_clock::time_point> blacklist;
            inline void logSecurity(const std::string &msgCN,const std::string &msgEN);
        };

        
        
    }

    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 
    {
        int fd;
        uint64_t connection_obj_fd;
        std::string type;
        std::string locPara;
        std::string loc;
        std::string para;
        std::string header;
        std::string body;
        std::string body_chunked;
        std::unordered_map<std::string,std::any> ctx;
    };
    
    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,HttpRequestInformation &HttpInf,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;
        uint64_t connection_obj_fd;
        bool closeflag;
        std::string locPara;
        std::string header;
        time_t HBTime=0;
        time_t response;
        size_t recv_length;
        size_t have_recv_length;
        int message_type;
        std::string message="";
        bool fin;
        std::string mask;
        std::unordered_map<std::string,std::any> ctx;
        HttpRequestInformation httpinf;
    };

    struct TcpInformation
    {
        int fd;
        uint64_t connection_obj_fd;
        std::string data;
        std::unordered_map<std::string,std::any> ctx;
    };

    enum class TLSState : uint8_t {
    NONE = 0,        // 非 TLS 连接（普通 TCP）
    HANDSHAKING,    // TLS 握手中（SSL_accept 还没完成）
    ESTABLISHED,    // TLS 已建立，可以 SSL_read / SSL_write
    ERROR           // TLS 出错（可选）
    };

    struct TcpFDInf
    {
        int fd;
        uint64_t connection_obj_fd;
        std::string ip;
        std::string port;
        int FDStatus;
        std::queue<std::any> pendindQueue;
        int status;
        std::string_view data;
        SSL* ssl;
        TLSState tls_state;
        char *buffer;
        unsigned long p_buffer_now;
    };

    struct WorkerMessage
    {
        int fd;
        int ret;
    };
    
    
    class TcpServer 
    {
    protected:
        system::MPSCQueue<WorkerMessage> finishQueue;
        stt::system::WorkerPool *workpool; 
        unsigned long buffer_size;
        unsigned long long  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;
        bool security_open;
        //bool flag_detect;
        //bool flag_detect_status;
        int workerEventFD;
        int serverType; // 1 tcp 2 http 3 websocket
        int connectionSecs;
        int connectionTimes;
        int requestSecs;
        int requestTimes;
        int checkFrequency;
        uint64_t connection_obj_fd;
    private:
        std::function<void(const int &fd)> closeFun=[](const int &fd)->void
        {

        };
        std::function<void(TcpFDHandler &k,TcpInformation &inf)> securitySendBackFun=[](TcpFDHandler &k,TcpInformation &inf)->void
        {};
        std::function<bool(TcpFDHandler &k,TcpInformation &inf)> globalSolveFun=[](TcpFDHandler &k,TcpInformation &inf)->bool
        {return true;};
        std::unordered_map<std::string,std::vector<std::function<int(TcpFDHandler &k,TcpInformation &inf)>>> solveFun;
        std::function<int(TcpFDHandler &k,TcpInformation &inf)> parseKey=[](TcpFDHandler &k,TcpInformation &inf)->int
        {inf.ctx["key"]=inf.data;return 1;};
        int fd=-1;
        int port=-1;
        int flag=false;
        bool flag2=false;
    private:
        void epolll(const int &evsNum);
        //virtual void consumer(const int &threadID);
        virtual void handler_netevent(const int &fd);
        virtual void handler_workerevent(const int &fd,const int &ret);
        virtual void handleHeartbeat()=0;
    public:
        void putTask(const std::function<int(TcpFDHandler &k,TcpInformation &inf)> &fun,TcpFDHandler &k,TcpInformation &inf);
        TcpServer(const unsigned long long &maxFD=1000000,const int &buffer_size=256,const size_t &finishQueue_cap=65536,const bool &security_open=true,
        const int &connectionNumLimit=20,const int &connectionSecs=1,const int &connectionTimes=6,const int &requestSecs=1,const int &requestTimes=40,
        const int &checkFrequency=60,const int &connectionTimeout=60):maxFD(maxFD),buffer_size(buffer_size*1024),finishQueue(finishQueue_cap),security_open(security_open),connectionSecs(connectionSecs),connectionTimes(connectionTimes),requestSecs(requestSecs),requestTimes(requestTimes),
        connectionLimiter(connectionNumLimit,connectionTimeout),checkFrequency(checkFrequency){serverType=1;}
        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();
        void setSecuritySendBackFun(std::function<void(TcpFDHandler &k,TcpInformation &inf)> fc){this->securitySendBackFun=fc;}
        void setGlobalSolveFunction(std::function<bool(TcpFDHandler &k,TcpInformation &inf)> fc){this->globalSolveFun=fc;}
        void setFunction(const std::string &key,std::function<int(TcpFDHandler &k,TcpInformation &inf)> fc)
        {
            auto [it, inserted] = solveFun.try_emplace(key);
            it->second.push_back(std::move(fc));
        }
        void setGetKeyFunction(std::function<int(TcpFDHandler &k,TcpInformation &inf)> parseKeyFun){this->parseKey=parseKeyFun;}
        bool stopListen();
        bool close();
        virtual bool close(const int &fd);
        void setConnectStrategy(const stt::security::RateLimitType &type){this->connectionLimiter.setConnectStrategy(type);}
        void setRequestStrategy(const stt::security::RateLimitType &type){this->connectionLimiter.setRequestStrategy(type);}
        void setPathStrategy(const stt::security::RateLimitType &type){this->connectionLimiter.setPathStrategy(type);}
        void setPathLimit(const std::string &path, const int &times, const int &secs){this->connectionLimiter.setPathLimit(path,times,secs);}
        void setCloseFun(std::function<void(const int &fd)> closeFun){this->closeFun=closeFun;}
    public:
        bool isListen(){return flag;}
        SSL* getSSL(const int &fd);
        ~TcpServer(){close();}
    };

    
    
    class HttpServer:public TcpServer
    {
    private:
        std::function<void(HttpServerFDHandler &k,HttpRequestInformation &inf)> securitySendBackFun=[](HttpServerFDHandler &k,HttpRequestInformation &inf)->void
        {};
        std::vector<std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)>> globalSolveFun;
        //std::function<bool(HttpServerFDHandler &k,HttpRequestInformation &inf)> globalSolveFun={};
        std::unordered_map<std::string,std::vector<std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)>>> solveFun;
        std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)> parseKey=[](HttpServerFDHandler &k,HttpRequestInformation &inf)->int
        {inf.ctx["key"]=inf.loc;return 1;};
        //std::function<bool(const HttpRequestInformation &inf,HttpServerFDHandler &k)> fc;
        //HttpRequestInformation *HttpInf;
        HttpRequestInformation *httpinf;
    private:
        //void consumer(const int &threadID);
        //inline void handler(const int &fd);
        void handler_netevent(const int &fd);
        void handler_workerevent(const int &fd,const int &ret);
        void handleHeartbeat(){}
    public:
        void putTask(const std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)> &fun,HttpServerFDHandler &k,HttpRequestInformation &inf);
         
        HttpServer(const unsigned long long &maxFD=1000000,const int &buffer_size=256,const size_t &finishQueue_cap=65536,const bool &security_open=true,
        const int &connectionNumLimit=10,const int &connectionSecs=1,const int &connectionTimes=3,const int &requestSecs=1,const int &requestTimes=20,
        const int &checkFrequency=30,const int &connectionTimeout=30):TcpServer(
              maxFD,
              buffer_size,
              finishQueue_cap,
              security_open,
              connectionNumLimit,
              connectionSecs,
              connectionTimes,
              requestSecs,
              requestTimes,
              checkFrequency,
              connectionTimeout
          ){serverType=2;}
        void setSecuritySendBackFun(std::function<void(HttpServerFDHandler &k,HttpRequestInformation &inf)> fc){this->securitySendBackFun=fc;}
        void setGlobalSolveFunction(std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)> fc){globalSolveFun.push_back(std::move(fc));}
        void setFunction(const std::string &key,std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)> fc)
        {
            auto [it, inserted] = solveFun.try_emplace(key);
            it->second.push_back(std::move(fc));
        }
        void setGetKeyFunction(std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)> parseKeyFun){this->parseKey=parseKeyFun;}
        bool startListen(const int &port,const int &threads=8)
        {
            //HttpInf=new HttpRequestInformation[maxFD];
            httpinf=new HttpRequestInformation[maxFD];
            return TcpServer::startListen(port,threads);
        }
        ~HttpServer()
        {
            delete[] httpinf;
        }
    };
    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 unsigned long &buffer_size,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::function<void(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> securitySendBackFun=[](WebSocketServerFDHandler &k,WebSocketFDInformation &inf)->void
        {};
        //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(WebSocketFDInformation &k)> fcc=[](WebSocketFDInformation &k)
        {return true;};
        std::function<bool(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> fccc=[](WebSocketServerFDHandler &k,WebSocketFDInformation &inf)->bool
        {
            return true;
        };
        std::function<bool(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> globalSolveFun=[](WebSocketServerFDHandler &k,WebSocketFDInformation &inf)->bool
        {return true;};
        std::unordered_map<std::string,std::vector<std::function<int(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)>>> solveFun;
        std::function<int(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> parseKey=[](WebSocketServerFDHandler &k,WebSocketFDInformation &inf)->int
        {inf.ctx["key"]=inf.message;return 1;};
        int seca=20*60;
        int secb=30;

    private:
        void handler_netevent(const int &fd);
        void handler_workerevent(const int &fd,const int &ret);
        //void consumer(const int &threadID);
        //inline void handler(const int &fd);
        void closeAck(const int &fd,const std::string &closeCodeAndMessage);
        void closeAck(const int &fd,const short &code=1000,const std::string &message="bye");
        
        void handleHeartbeat();
        bool closeWithoutLock(const int &fd,const std::string &closeCodeAndMessage);
        bool closeWithoutLock(const int &fd,const short &code=1000,const std::string &message="bye");
    public:
         void putTask(const std::function<int(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> &fun,WebSocketServerFDHandler &k,WebSocketFDInformation &inf);
        WebSocketServer(const unsigned long long &maxFD=1000000,const int &buffer_size=256,const size_t &finishQueue_cap=65536,const bool &security_open=true,
        const int &connectionNumLimit=5,const int &connectionSecs=10,const int &connectionTimes=3,const int &requestSecs=1,const int &requestTimes=10,
        const int &checkFrequency=60,const int &connectionTimeout=120):TcpServer(
              maxFD,
              buffer_size,
              finishQueue_cap,
              security_open,
              connectionNumLimit,
              connectionSecs,
              connectionTimes,
              requestSecs,
              requestTimes,
              checkFrequency,
              connectionTimeout
          ){serverType=3;}
        void setSecuritySendBackFun(std::function<void(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> fc){this->securitySendBackFun=fc;}
        void setGlobalSolveFunction(std::function<bool(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> fc){this->globalSolveFun=fc;}
        void setStartFunction(std::function<bool(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> fccc){this->fccc=fccc;}
        void setJudgeFunction(std::function<bool(WebSocketFDInformation &k)> fcc){this->fcc=fcc;}
        void setFunction(const std::string &key,std::function<int(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> fc)
        {
            auto [it, inserted] = solveFun.try_emplace(key);
            it->second.push_back(std::move(fc));
        }
        void setGetKeyFunction(std::function<int(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> parseKeyFun){this->parseKey=parseKeyFun;}
        //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 closeFD(const int &fd,const std::string &closeCodeAndMessage);
        bool closeFD(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 close(const int &fd);
        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(){  }
    };

    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;
                    }
                }
            }
        };

        using Task = std::function<void()>;
        class WorkerPool 
        {
        public:
            explicit WorkerPool(size_t n):stop_(false)
            {
                for (size_t i = 0; i < n; ++i) {
                    threads_.emplace_back([this] {
                        this->workerLoop();
                    });
                }
            }
            ~WorkerPool() 
            {
                stop();
            }
            void submit(Task task) 
            {
                {
                    std::lock_guard<std::mutex> lk(mtx_);
                    tasks_.push(std::move(task));
                }
                cv_.notify_one();
            }
            void stop() 
            {
                {
                    std::lock_guard<std::mutex> lk(mtx_);
                    stop_ = true;
                }
                cv_.notify_all();
                for (auto &t : threads_) 
                {
                    if (t.joinable()) t.join();
                }
            }

        private:
            void workerLoop() 
            {
                while (true) 
                {
                    Task task;
                    {
                        std::unique_lock<std::mutex> lk(mtx_);
                        cv_.wait(lk, [this] {
                        return stop_ || !tasks_.empty();
                        });
                        if (stop_ && tasks_.empty())
                        {
                            return;
                        }
                        task = std::move(tasks_.front());
                        tasks_.pop();
                    }
                    task(); // 执行任务
                }
            }

        private:
            std::vector<std::thread> threads_;
            std::queue<Task> tasks_;
            std::mutex mtx_;
            std::condition_variable cv_;
            bool stop_;
        };
    }
    
}


#endif