sttnet_English.h

Go to the documentation of this file.

#ifndef PUBLIC_H
#define PUBLIC_H 1
#include<jsoncpp/json/json.h>
#include<string_view>
#include<string>
#include<atomic>
#include<iostream>
#include<unistd.h>
#include<sys/stat.h>
#include<fstream>
#include<fcntl.h>
#include<sstream>
#include<mutex>
#include<chrono>
#include<iomanip>
#include<random>
#include<cmath>
#include<thread>
#include<openssl/sha.h>
#include<netdb.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<cstring>
#include<openssl/bio.h>
#include<openssl/evp.h>
#include<openssl/buffer.h>
#include<functional>
#include<list>
#include<queue>
#include<sys/epoll.h> 
#include<condition_variable>
#include <regex>
#include<unordered_map>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include<openssl/crypto.h>
#include<signal.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<sys/wait.h>
#include<sys/shm.h>
#include<type_traits>
#include<charconv>
#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;
    }
    time::Duration operator+(const time::Duration &b)
    {
        long long dayy = day;
        int hourr = hour;
        int minn = min;
        int secc = sec;
        int msecc = msec;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


class DateTime
{
private:
    static Duration& dTOD(const Milliseconds& d1, Duration &D1);
    static Milliseconds& DTOd(const Duration &D1, Milliseconds& d1);
    static std::string &toPGtimeFormat();
    static std::chrono::system_clock::time_point strToTimePoint(const std::string &timeStr, const std::string &format = ISO8086A);
    static std::string& timePointToStr(const std::chrono::system_clock::time_point &tp, std::string &timeStr, const std::string &format = ISO8086A);
public:
    static std::string& getTime(std::string &timeStr, const std::string &format = ISO8086A);
    static bool convertFormat(std::string &timeStr, const std::string &oldFormat, const std::string &newFormat = ISO8086A);
    static Duration& calculateTime(const std::string &time1, const std::string &time2, Duration &result, const std::string &format1 = ISO8086A, const std::string &format2 = ISO8086A);
    static std::string& calculateTime(const std::string &time1, const Duration &time2, std::string &result, const std::string &am, const std::string &format1 = ISO8086A, const std::string &format2 = ISO8086A);
    static bool compareTime(const std::string &time1, const std::string &time2, const std::string &format1 = ISO8086A, const std::string &format2 = ISO8086A);
private:
    Duration dt{-1, -1, -1, -1, -1};
    bool flag = false;
    std::chrono::steady_clock::time_point start;
    std::chrono::steady_clock::time_point end;
public:
    bool startTiming();
    Duration checkTime();
    Duration endTiming();
public:
    Duration getDt() { return dt; }
    bool isStart() { return flag; }
};
}
namespace file
{
class LogFile : private time::DateTime, protected file::File
{
private:
    std::string timeFormat;
    std::string contentFormat;
    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-bit unsigned number conversion to big/little endian (network byte order)
        };
        
        class PrecisionUtil
        {
        public:
        
            static std::string& getPreciesFloat(const float &number, const int &bit, std::string &str);
            static float& getPreciesFloat(float &number, const int &bit);
            static std::string& getPreciesDouble(const double &number, const int &bit, std::string &str);
            static double& getPreciesDouble(double &number, const int &bit);
            static float& getValidFloat(float &number, const int &bit);
        };
        class HttpStringUtil
        {
        public:
            static size_t get_split_str(const std::string_view& ori_str, std::string_view &str, const std::string_view &a, const std::string_view &b, const size_t &pos = 0);
            static std::string_view& get_value_str(const std::string_view& ori_str, std::string_view &str, const std::string& name);
            static std::string_view& get_value_header(const std::string_view& ori_str, std::string_view &str, const std::string& name);
            static std::string_view& get_location_str(const std::string_view& ori_str, std::string_view &str);
            static std::string_view& getLocPara(const std::string_view &url, std::string_view &locPara);
            static std::string_view& getPara(const std::string_view &url, std::string_view &para);



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

            static std::string toString(const Json::Value &val);
            static Json::Value toJsonArray(const std::string & str);
            template<class T1, class T2>
            static std::string createJson(T1 first, T2 second)
            {
                Json::Value root;
                //root[first] = second;
                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,      // Punishment-based: hit limit => cooldown, require quiet secs to recover
    FixedWindow,   // Fixed window counter: each secs is a window, allow up to times
    SlidingWindow, // Sliding window: count events within the last secs (timestamp deque)
    TokenBucket    // Token bucket: allow bursts + control long-term average rate
};


struct RateState
{
    // Common
    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 risk score used for escalation
    std::unordered_map<int, ConnectionState> conns; // fd -> state
};


enum DefenseDecision : int
{
    ALLOW = 0,
    DROP  = 1,
    CLOSE = 2
};


class ConnectionLimiter
{
public:
    ConnectionLimiter(const int& maxConn = 20, const int& idleTimeout = 60)
        : maxConnections(maxConn), connectionTimeout(idleTimeout) {}

    // ========== Strategy configuration ==========

    void setConnectStrategy(const RateLimitType &type);

    void setRequestStrategy(const RateLimitType &type);

    void setPathStrategy(const RateLimitType &type);

    // ========== Path configuration ==========

    void setPathLimit(const std::string &path, const int &times, const int &secs);

    // ========== Core decisions ==========

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

    // ========== Lifecycle ==========

    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:
    // Core limiter primitive
    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 -> unban time
    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<<"Received: "<<message<<std::endl;return true;};
        std::string url;
        EpollSingle k;
        bool flag5 = false;
    private:
        bool close1();
    public:
        WebSocketClient(const bool &TLS = false, const char *ca = "", const char *cert = "", const char *key = "", const char *passwd = "") : TcpClient(TLS, ca, cert, key, passwd) {}
        void setFunction(std::function<bool(const std::string &message, WebSocketClient &k)> fc) { this->fc = fc; }
        bool connect(const std::string &url, const int &min = 20);
        bool sendMessage(const std::string &message, const std::string &type = "0001");
        void close(const std::string &closeCodeAndMessage, const bool &wait = true);
        void close(const short &code = 1000, const std::string &message = "bye", const bool &wait = true);       
    public:
        bool isConnect() { return flag4; }
        std::string getUrl() { return url; }
        std::string getServerIp() { return TcpClient::getServerIP(); }
        std::string getServerPort() { return TcpClient::getServerIP(); }
        ~WebSocketClient();
    };

    struct HttpRequestInformation 
    {
        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;
    };

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

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

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

    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 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;
        };
        HttpRequestInformation *httpinf;

private:
    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];
        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(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 &, WebSocketFDInformation &)>>>
        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;  // heartbeat interval (seconds)
    int secb = 30;       // heartbeat response timeout (seconds)



private:
    void handler_netevent(const int &fd);
    void handler_workerevent(const int &fd, const int &ret);

    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 &, WebSocketFDInformation &)> &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 &, WebSocketFDInformation &)> fc)
    {
        this->globalSolveFun = fc;
    }

    void setStartFunction(
        std::function<bool(WebSocketServerFDHandler &, WebSocketFDInformation &)> fccc)
    {
        this->fccc = fccc;
    }

    void setJudgeFunction(std::function<bool(WebSocketFDInformation &)> fcc)
    {
        this->fcc = fcc;
    }

    void setFunction(
        const std::string &key,
        std::function<int(WebSocketServerFDHandler &, WebSocketFDInformation &)> fc)
    {
        auto [it, inserted] = solveFun.try_emplace(key);
        it->second.push_back(std::move(fc));
    }

    void setGetKeyFunction(
        std::function<int(WebSocketServerFDHandler &, WebSocketFDInformation &)> parseKeyFun)
    {
        this->parseKey = parseKeyFun;
    }

    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<<"Terminated by uncaught exception"<<std::endl;if(ServerSetting::logfile!=nullptr){if(ServerSetting::language=="Chinese")ServerSetting::logfile->writeLog("未捕获的异常终止");else ServerSetting::logfile->writeLog("end for uncaught exception");}kill(getpid(),15);}
            static void signalSIGSEGV(int signal){std::cout<<"SIGSEGV"<<std::endl;if(ServerSetting::logfile!=nullptr){if(ServerSetting::language=="Chinese")ServerSetting::logfile->writeLog("信号SIGSEGV");else ServerSetting::logfile->writeLog("signal SIGSEGV");}kill(getpid(),15);}
            static void signalSIGABRT(int signal){std::cout<<"SIGABRT"<<std::endl;if(ServerSetting::logfile!=nullptr){if(ServerSetting::language=="Chinese")ServerSetting::logfile->writeLog("信号SIGABRT");else ServerSetting::logfile->writeLog("signal SIGABRT");}kill(getpid(),15);}
        public:
            static void setExceptionHandling();
            static void setLogFile(file::LogFile *logfile = nullptr, const std::string &language = "");
            static void init(file::LogFile *logfile = nullptr, const std::string &language = "");
        };
        
        class csemp
        {
        private:
            union semun  
            {
                int val;                
                struct semid_ds *buf;   
                unsigned short  *arry;  
            };

            int   m_semid;      
            short m_sem_flg;    

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

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

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

            bool wait(short value = -1);

            bool post(short value = 1);

            int getvalue();

            bool destroy();

            ~csemp();
        };

        #define MAX_PROCESS_NAME 100

        #define MAX_PROCESS_INF 1000

        #define SHARED_MEMORY_KEY 0x5095

        #define SHARED_MEMORY_LOCK_KEY 0x5095

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

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

        class Process
        {
        public:
        

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

        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(); // perform tasks
                }
            }

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

    
}


#endif