eiennet_socket.hpp

浏览该文件的文档.

#ifndef __SOCKET_HPP__
#define __SOCKET_HPP__

namespace eiennet
{
//#define SOCKET_EXCEPTION_USE  // 错误机制是使用错误异常机制，还是使用传统返回值模式

class EIENNET_DLL SocketLib
{
public:
    SocketLib();
    ~SocketLib();

private:
    winux::Members<struct SocketLib_Data> _self;
    DISABLE_OBJECT_COPY(SocketLib)
};

class SocketError : public winux::Error
{
public:
    SocketError( int errType, winux::AnsiString const & errStr ) : winux::Error( errType, errStr ) { }
};

class EndPoint;

class EIENNET_DLL Socket
{
public:
    // classes and types ------------------------------------------------------------------

    enum AddrFamily {
        afUnspec = 0,           
        afLocal = 1,            
        afUnix = afLocal,       
        afFile = afLocal,       
        afInet = 2,             
        afAx25 = 3,             
        afIpx = 4,              
        afAppletalk = 5,        
        afNetrom = 6,           
        afBridge = 7,           
        afAtmpvc = 8,           
        afX25 = 9,              
        afInet6 = 10,           
        afRose = 11,            
        afDecnet = 12,          
        afNetbeui = 13,         
        afSecurity = 14,        
        afKey = 15,             
        afNetlink = 16,
        afRoute = afNetlink,    
        afPacket = 17,          
        afAsh = 18,             
        afEconet = 19,          
        afAtmsvc = 20,          
        afRds = 21,             
        afSna = 22,             
        afIrda = 23,            
        afPppox = 24,           
        afWanpipe = 25,         
        afLlc = 26,             
        afUnknown27 = 27,
        afUnknown28 = 28,
        afCan = 29,             
        afTipc = 30,            
        afBluetooth = 31,       
        afIucv = 32,            
        afRxrpc = 33,           
        afIsdn = 34,            
        afPhonet = 35,          
        afIeee802154 = 36,      
        afMax = 37              
    };

    enum SockType {
        sockUnknown,
        sockStream,     
        sockDatagram,   
        sockRaw,        
        sockRdm,        
        sockSeqPacket,  
        sockDccp,       
        sockPacket,     
        /* Flags to be ORed into the type parameter of socket and socketpair and used for the flags parameter of paccept.  */

        sockCloexec,    
        sockNonblock    
    };

    enum Protocol {
        protoUnspec = 0, protoIp = 0,    
        protoIcmp,      
        protoIgmp,      
        protoIpip, protoIpv4 = protoIpip, 
        protoTcp,       
        protoEgp,       
        protoPup,       
        protoUdp,       
        protoIdp,       
        protoTp,        
        protoDccp,      
        protoIpv6,      
        protoRsvp,      
        protoGre,       
        protoEsp,       
        protoAh,        
        protoMtp,       
        protoBeetph,    
        protoEncap,     
        protoPim,       
        protoComp,      
        protoSctp,      
        protoUdplite,   
        protoRaw,       
        protoMax
    };

public:
    // static members ---------------------------------------------------------------------
    // send/recv's message flags
    static int const MsgDefault;
#if defined(_MSC_VER) || defined(WIN32)
    static int const MsgOob;
    static int const MsgPeek;
    static int const MsgDontRoute;
    static int const MsgWaitAll;
    static int const MsgPartial;
    static int const MsgInterrupt;
    static int const MsgMaxIovLen;
#else
    static int const MsgOob;
    static int const MsgPeek;
    static int const MsgDontRoute;
#   ifdef __USE_GNU
    /* DECnet uses a different name.  */
    static int const MsgTryHard;
#   endif
    static int const MsgCTrunc;
    static int const MsgProxy;
    static int const MsgTrunc;
    static int const MsgDontWait;
    static int const MsgEor;
    static int const MsgWaitAll;
    static int const MsgFin;
    static int const MsgSyn;
    static int const MsgConfirm;
    static int const MsgRst;
    static int const MsgErrQueue;
    static int const MsgNoSignal;
    static int const MsgMore;
    static int const MsgWaitForOne;
    static int const MsgCMsgCloexec;

#endif
    // shutdown's how flags
    static int const SdReceive;
    static int const SdSend;
    static int const SdBoth;

    typedef std::function< void ( size_t hadBytes, void * param ) > FunctionSuccessCallback;
public:
    // constructor/destructor -------------------------------------------------------------

    explicit Socket( int sock = -1, bool isNewSock = false );

    Socket( AddrFamily af, SockType sockType, Protocol proto );

// #ifndef MOVE_SEMANTICS_DISABLED
//     /** \brief 移动构造函数 */
//     Socket( Socket && other );
//     /** \brief 移动赋值操作 */
//     Socket & operator = ( Socket && other );
// #endif

    virtual ~Socket();

public:
    // methods ----------------------------------------------------------------------------
    AddrFamily getAddrFamily() const;
    void setAddrFamily( AddrFamily af );

    SockType getSockType() const;
    void setSockType( SockType sockType );

    Protocol getProtocol() const;
    void setProtocol( Protocol proto );

    void getParams( AddrFamily * af, SockType * sockType, Protocol * proto );
    void setParams( AddrFamily af, SockType sockType, Protocol proto );

    bool create( AddrFamily af, SockType sockType, Protocol proto );
    bool create();

protected:
    bool _tryCreate( AddrFamily af, bool hasAf, SockType sockType, bool hasSockType, Protocol proto, bool hasProto );

public:
    int close();

    int shutdown( int how = SdSend );

    int send( void const * data, size_t size, int msgFlags = MsgDefault );
    int send( winux::AnsiString const & data, int msgFlags = MsgDefault ) { return this->send( data.c_str(), data.size(), msgFlags ); }
    int send( winux::Buffer const & data, int msgFlags = MsgDefault ) { return this->send( data.getBuf(), data.getSize(), msgFlags ); }

    bool sendUntil( size_t targetSize, void const * data, int msgFlags = MsgDefault );
    bool sendUntil( winux::AnsiString const & data, int msgFlags = MsgDefault ) { return this->sendUntil( data.size(), data.c_str(), msgFlags ); }
    bool sendUntil( winux::Buffer const & data, int msgFlags = MsgDefault ) { return this->sendUntil( data.getSize(), data.getBuf(), msgFlags ); }

    int sendWaitUntil(
        size_t targetSize,
        void const * data,
        size_t * hadSent,
        double sec,
        int * rcWait,
        FunctionSuccessCallback eachSuccessCallback = FunctionSuccessCallback(),
        void * param = nullptr,
        int msgFlags = MsgDefault
    );

    int sendWaitUntil(
        winux::AnsiString const & data,
        size_t * hadSent,
        double sec,
        int * rcWait,
        FunctionSuccessCallback eachSuccessCallback = FunctionSuccessCallback(),
        void * param = nullptr,
        int msgFlags = MsgDefault
    ) { return this->sendWaitUntil( data.size(), data.c_str(), hadSent, sec, rcWait, std::move(eachSuccessCallback), param, msgFlags ); }

    int sendWaitUntil(
        winux::Buffer const & data,
        size_t * hadSent,
        double sec,
        int * rcWait,
        FunctionSuccessCallback eachSuccessCallback = FunctionSuccessCallback(),
        void * param = nullptr,
        int msgFlags = MsgDefault
    ) { return this->sendWaitUntil( data.getSize(), data.getBuf(), hadSent, sec, rcWait, std::move(eachSuccessCallback), param, msgFlags ); }

    template < typename _PodType >
    bool sendUntilType( _PodType const & v, size_t size = sizeof(_PodType), int msgFlags = MsgDefault ) { return this->sendUntil( size, &v, msgFlags ); }

    int recv( void * buf, size_t size, int msgFlags = MsgDefault );

    winux::Buffer recv( size_t size, int msgFlags = MsgDefault );

    bool recvUntilTarget( winux::AnsiString const & target, winux::GrowBuffer * data, winux::GrowBuffer * extraData, int msgFlags = MsgDefault );

    int recvWaitUntilTarget(
        winux::AnsiString const & target,
        winux::GrowBuffer * data,
        winux::GrowBuffer * extraData,
        size_t * hadRead,
        size_t * startpos,
        size_t * pos,
        double sec,
        int * rcWait,
        FunctionSuccessCallback eachSuccessCallback = FunctionSuccessCallback(),
        void * param = nullptr,
        int msgFlags = MsgDefault
    );

    bool recvUntilSize( size_t targetSize, winux::GrowBuffer * data, int msgFlags = MsgDefault );

    int recvWaitUntilSize(
        size_t targetSize,
        winux::GrowBuffer * data,
        size_t * hadRead,
        double sec,
        int * rcWait,
        FunctionSuccessCallback eachSuccessCallback = FunctionSuccessCallback(),
        void * param = nullptr,
        int msgFlags = MsgDefault
    );

    template < typename _PodType >
    bool recvUntilType( _PodType * v, size_t size = sizeof(_PodType), int msgFlags = MsgDefault )
    {
        winux::GrowBuffer data;
        data.setBuf( v, 0, size, true );
        return this->recvUntilSize( size, &data, msgFlags );
    }

    winux::Buffer recvAvail( int msgFlags = MsgDefault );

    winux::Buffer recvWaitAvail( double sec, int * rcWait, int msgFlags = MsgDefault );

    int sendTo( EndPoint const & ep, void const * data, size_t size, int msgFlags = MsgDefault );
    int sendTo( EndPoint const & ep, winux::AnsiString const & data, int msgFlags = MsgDefault ) { return this->sendTo( ep, data.c_str(), data.size(), msgFlags ); }
    int sendTo( EndPoint const & ep, winux::Buffer const & data, int msgFlags = MsgDefault ) { return this->sendTo( ep, data.getBuf(), data.getSize(), msgFlags ); }

    int recvFrom( EndPoint * ep, void * buf, size_t size, int msgFlags = MsgDefault );
    winux::Buffer recvFrom( EndPoint * ep, size_t size, int msgFlags = MsgDefault );

    bool connect( EndPoint const & ep );

    bool bind( EndPoint const & ep );

    bool listen( int backlog );

    bool accept( int * sock, EndPoint * ep = NULL );

    winux::SharedPointer<Socket> accept( EndPoint * ep = NULL )
    {
        int sock;
        return this->accept( &sock, ep ) ? winux::SharedPointer<Socket>( new Socket( sock, true ) ) : winux::SharedPointer<Socket>();
    }

    // socket's options -------------------------------------------------------------------

    int getRecvBufSize() const;
    bool setRecvBufSize( int optval );

    int getSendBufSize() const;
    bool setSendBufSize( int optval );

    winux::uint32 getRecvTimeout() const;
    bool setRecvTimeout( winux::uint32 optval );

    winux::uint32 getSendTimeout() const;
    bool setSendTimeout( winux::uint32 optval );

    bool getReUseAddr() const;
    bool setReUseAddr( bool optval );

    bool getBroadcast() const;
    bool setBroadcast( bool optval );

    bool getIpv6Only() const;
    bool setIpv6Only( bool optval );

    int getError() const;

    SockType getType() const;

    bool isListening() const;

    // ioctls -----------------------------------------------------------------------------

    int getAvailable() const;

    bool setBlocking( bool blocking );

    // attributes -------------------------------------------------------------------------

    int get() const;

    operator bool() const { return this->get() > -1; }

    // static -----------------------------------------------------------------------------

    static int ErrNo();

protected:
    // 延迟创建socket使用参数
    AddrFamily _addrFamily;  // 地址族
    SockType _sockType;      // 套接字类型
    Protocol _protocol;      // 协议

    // 延迟设置socket属性
    winux::uint32 _attrSendTimeout; // 发送超时(ms)
    winux::uint32 _attrRecvTimeout; // 接收超时(ms)
    int _attrSendBufSize;   // 发送缓冲区大小
    int _attrRecvBufSize;   // 接收缓冲区大小
    bool _attrBlocking;     // 是否阻塞
    bool _attrBroadcast;    // 是否启用广播
    bool _attrReUseAddr;    // 是否开启了地址重用
    bool _attrIpv6Only;     // IPV6套接字只开启IPV6功能

    // 属性种类
    enum AttrCategory
    {
        attrNone,           // 无意义
        attrBlocking,       // 是否阻塞
        attrBroadcast,      // 是否启用广播
        attrReUseAddr,      // 是否开启了地址重用
        attrSendTimeout,    // 发送超时(ms)
        attrRecvTimeout,    // 接收超时(ms)
        attrSendBufSize,    // 发送缓冲区大小
        attrRecvBufSize,    // 接收缓冲区大小
        attrIpv6Only,       // IPV6套接字只开启IPV6功能
    };
    std::vector<AttrCategory> _attrExecSets; // 执行属性设置的操作集

    // socket资源管理
    int _sock;           // socket描述符
    bool _isNewSock;     // 指示是否为新建socket。如果为true，则会在Socket对象析构时自动关闭sock

    // 初始化全部成员
    void _membersInit()
    {
        this->_addrFamily = afUnspec;
        this->_sockType = sockUnknown;
        this->_protocol = protoUnspec;

        _attrBlocking = true;
        _attrBroadcast = false;
        _attrReUseAddr = false;
        _attrSendTimeout = 0U;
        _attrRecvTimeout = 0U;
        _attrSendBufSize = 0;
        _attrRecvBufSize = 0;
    #if defined(OS_WIN)
        _attrIpv6Only = true;   // IPV6套接字只开启IPV6功能
    #else
        _attrIpv6Only = false;  // IPV6套接字只开启IPV6功能
    #endif

        this->_resetManaged();
    }

    // 重置socket资源管理相关变量
    void _resetManaged()
    {
        this->_sock = -1;
        this->_isNewSock = false;
    }

    DISABLE_OBJECT_COPY(Socket)
};

class EIENNET_DLL EndPoint
{
public:
    EndPoint() { }
    virtual ~EndPoint() { }

    virtual void * get() const = 0;
    template < typename _Ty >
    _Ty * get() const { return reinterpret_cast<_Ty *>( this->get() ); }
    virtual winux::uint & size() const = 0;
    virtual winux::String toString() const = 0;
    virtual EndPoint * clone() const = 0;
    virtual Socket::AddrFamily getAddrFamily() const = 0;
};

struct DataRecvSendCtx
{
    enum {
        RetryCount = 10 
    };

    winux::GrowBuffer data;         
    winux::GrowBuffer extraData;    
    size_t startpos;                
    size_t pos;                     
    size_t hadBytes;                
    size_t targetBytes;             
    size_t retryCount;              

    DataRecvSendCtx()
    {
        this->resetStatus();
    }

    void resetData()
    {
        this->data.free();
        this->extraData.free();
    }

    void resetStatus()
    {
        this->startpos = 0;
        this->pos = winux::npos;
        this->hadBytes = 0;
        this->targetBytes = 0;
        this->retryCount = 0;
    }

    void append( winux::Buffer const & data )
    {
        this->data.append(data);
    }

    template < typename _IndexType >
    bool find( winux::AnsiString const & target, std::vector<_IndexType> const & targetNextVal )
    {
        // 如果接收到的数据小于标记长度 或者 搜不到标记 则退出
        if ( this->data.getSize() - this->startpos < target.size() || ( this->pos = winux::_Templ_KmpMatchEx( this->data.getBuf<char>(), this->data.getSize(), target.c_str(), target.size(), this->startpos, targetNextVal ) ) == winux::npos )
        {
            if ( this->data.getSize() >= target.size() ) this->startpos = this->data.getSize() - target.size() + 1; // 计算下次搜索起始
            return false;
        }
        else
        {
            return true;
        }
    }

    winux::Buffer adjust( size_t actualDataSize )
    {
        this->extraData._setSize(0);
        // 额外收到的数据
        this->extraData.append( this->data.getBuf<char>() + actualDataSize, this->data.getSize() - actualDataSize );
        this->data._setSize(actualDataSize);

        winux::Buffer actualData(this->data);

        // 额外的数据移入主数据中
        this->data = std::move(extraData);
        // 重置数据收发场景
        this->resetStatus();

        return actualData;
    }
};


class EIENNET_DLL SocketStreamBuf : public std::streambuf
{
public:
    SocketStreamBuf(
        eiennet::Socket * sock,
        std::ios_base::openmode mode = std::ios_base::in | std::ios_base::out,
        size_t inputBufSize = (size_t)-1,
        size_t outputBufSize = (size_t)-1
    );

    virtual ~SocketStreamBuf();

    Socket * getSocket() const { return _sock; }
    // input buffer begin -----------------------------------------------------------------------
protected:
    virtual int_type underflow();
    // input buffer end -----------------------------------------------------------------------

    // output buffer begin -----------------------------------------------------------------------
protected:
    virtual int_type overflow( int_type c );
    virtual int sync();
    int _flush();
    // output buffer end -----------------------------------------------------------------------


private:
    eiennet::Socket * _sock;
    winux::Buffer _inputBuf;
    winux::Buffer _outputBuf;

    DISABLE_OBJECT_COPY(SocketStreamBuf)
};

class EIENNET_DLL SocketStreamOut : public std::ostream
{
private:
    SocketStreamBuf * _sockBuf;
public:
    SocketStreamOut( SocketStreamBuf * sockBuf ) : std::ostream(sockBuf), _sockBuf(sockBuf) { }
    SocketStreamOut( SocketStreamBuf & sockBuf ) : std::ostream(&sockBuf), _sockBuf(&sockBuf) { }
    SocketStreamOut( winux::SimplePointer<SocketStreamBuf> & sockBuf ) : std::ostream(sockBuf.get()), _sockBuf(sockBuf.get()) { }
    SocketStreamOut( winux::SharedPointer<SocketStreamBuf> & sockBuf ) : std::ostream(sockBuf.get()), _sockBuf(sockBuf.get()) { }

    SocketStreamOut & writeAndFlush( winux::Buffer const & data );
};

class EIENNET_DLL SocketStreamIn : public std::istream
{
private:
    SocketStreamBuf * _sockBuf;
public:
    SocketStreamIn( SocketStreamBuf * sockBuf ) : std::istream(sockBuf), _sockBuf(sockBuf) { }
    SocketStreamIn( SocketStreamBuf & sockBuf ) : std::istream(&sockBuf), _sockBuf(&sockBuf) { }
    SocketStreamIn( winux::SimplePointer<SocketStreamBuf> & sockBuf ) : std::istream(sockBuf.get()), _sockBuf(sockBuf.get()) { }
    SocketStreamIn( winux::SharedPointer<SocketStreamBuf> & sockBuf ) : std::istream(sockBuf.get()), _sockBuf(sockBuf.get()) { }

    std::streamsize getAvailable() const;
    SocketStreamIn & readAvail( winux::Buffer * data );
    SocketStreamIn & read( winux::Buffer * data, size_t size );
    std::streamsize waitAvail( double sec );
};


namespace ip
{
class EIENNET_DLL EndPoint : public eiennet::EndPoint
{
public:
    EndPoint( Socket::AddrFamily af = Socket::afUnspec );
    EndPoint( winux::Mixed const & ipAndPort );
    EndPoint( winux::String const & ipAddr, winux::ushort port );

    EndPoint( EndPoint const & other );
    EndPoint & operator = ( EndPoint const & other );

#ifndef MOVE_SEMANTICS_DISABLED
    EndPoint( EndPoint && other );
    EndPoint & operator = ( EndPoint && other );
#endif

    virtual ~EndPoint();

    void init( Socket::AddrFamily af = Socket::afUnspec );
    void init( winux::Mixed const & ipAndPort );
    void init( winux::String const & ipAddr, winux::ushort port );

    virtual void * get() const override;
    template < typename _Ty >
    _Ty * get() const { return reinterpret_cast<_Ty *>( this->get() ); }
    virtual winux::uint & size() const override;
    virtual winux::String toString() const override;
    virtual eiennet::EndPoint * clone() const override;
    virtual Socket::AddrFamily getAddrFamily() const override;

    operator winux::Mixed() const;

    winux::String getIp() const;
    winux::ushort getPort() const;

private:
    winux::PlainMembers<struct EndPoint_Data, 32> _self;
};

class EIENNET_DLL Resolver
{
public:
    typedef std::vector<ip::EndPoint> EndPointArray;
    Resolver( winux::Mixed const & hostAndPort );
    Resolver( winux::String const & hostName, winux::ushort port );

    EndPointArray::iterator begin() { return _epArr.begin(); }
    EndPointArray::const_iterator begin() const { return _epArr.begin(); }
    EndPointArray::iterator end() { return _epArr.end(); }
    EndPointArray::const_iterator end() const { return _epArr.end(); }

    size_t count() const { return _epArr.size(); }
    winux::String const & getHostname() const { return _hostName; }
    winux::ushort getPort() const { return _port; }

    EndPointArray::value_type const & operator [] ( int i ) const { return _epArr[i]; }
    EndPointArray::value_type & operator [] ( int i ) { return _epArr[i]; }

    EndPointArray & getArr() { return _epArr; }
    EndPointArray const & getArr() const { return _epArr; }

    virtual winux::String toString() const;
    operator winux::Mixed() const;

private:
    size_t _resolve( winux::String const & hostName, winux::ushort port );
    winux::String _hostName;
    winux::ushort _port;
    EndPointArray _epArr;
};

namespace tcp
{
class EIENNET_DLL Socket : public eiennet::Socket
{
public:
    typedef eiennet::Socket BaseClass;

    explicit Socket( int sock, bool isNewSock = false ) : BaseClass( sock, isNewSock ) { }

    Socket() : BaseClass( BaseClass::afInet, BaseClass::sockStream, BaseClass::protoUnspec ) { }

    winux::SharedPointer<Socket> accept( EndPoint * ep = NULL )
    {
        int sock;
        return BaseClass::accept( &sock, ep ) ? winux::SharedPointer<Socket>( new Socket( sock, true ) ) : winux::SharedPointer<Socket>();
    }
};

EIENNET_FUNC_DECL(int) ConnectAttempt( Socket * sock, EndPoint const & ep, winux::uint32 timeoutMs );

EIENNET_FUNC_DECL(int) ConnectAttempt( Socket * sock, Resolver const & resolver, winux::uint32 perCnnTimeoutMs );

} // namespace tcp

namespace udp
{
class EIENNET_DLL Socket : public eiennet::Socket
{
public:
    typedef eiennet::Socket BaseClass;

    explicit Socket( int sock, bool isNewSock = false ) : BaseClass( sock, isNewSock ) { }

    Socket() : BaseClass( BaseClass::afInet, BaseClass::sockDatagram, BaseClass::protoUnspec ) { }
};

} // namespace udp

} // namespace ip


namespace io
{

class EIENNET_DLL SelectRead
{
public:
    SelectRead();
    SelectRead( Socket const & sock );
    SelectRead( Socket const * sock );
    SelectRead( int fd );
    SelectRead( winux::Mixed const & fds );
    ~SelectRead();

    SelectRead & setReadSock( Socket const & sock ) { return setReadFd( sock.get() ); }
    SelectRead & setReadSock( Socket const * sock ) { return setReadFd( sock->get() ); }
    SelectRead & setReadFd( int fd );
    SelectRead & delReadFd( int fd );
    SelectRead & setReadFds( winux::Mixed const & fds );
    SelectRead & clear();
    int hasReadSock( Socket const & sock ) const { return hasReadFd( sock.get() ); }
    int hasReadFd( int fd ) const;

    int wait( double sec = -1 );

protected:
    winux::Members<struct SelectRead_Data> _self;
    DISABLE_OBJECT_COPY(SelectRead)
};

class EIENNET_DLL SelectWrite
{
public:
    SelectWrite();
    SelectWrite( Socket const & sock );
    SelectWrite( Socket const * sock );
    SelectWrite( int fd );
    SelectWrite( winux::Mixed const & fds );
    ~SelectWrite();

    SelectWrite & setWriteSock( Socket const & sock ) { return setWriteFd( sock.get() ); }
    SelectWrite & setWriteSock( Socket const * sock ) { return setWriteFd( sock->get() ); }
    SelectWrite & setWriteFd( int fd );
    SelectWrite & delWriteFd( int fd );
    SelectWrite & setWriteFds( winux::Mixed const & fds );
    SelectWrite & clear();
    int hasWriteSock( Socket const & sock ) const { return hasWriteFd( sock.get() ); }
    int hasWriteFd( int fd ) const;

    int wait( double sec = -1 );

protected:
    winux::Members<struct SelectWrite_Data> _self;
    DISABLE_OBJECT_COPY(SelectWrite)
};

class EIENNET_DLL SelectExcept
{
public:
    SelectExcept();
    SelectExcept( Socket const & sock );
    SelectExcept( Socket const * sock );
    SelectExcept( int fd );
    SelectExcept( winux::Mixed const & fds );
    ~SelectExcept();

    SelectExcept & setExceptSock( Socket const & sock ) { return setExceptFd( sock.get() ); }
    SelectExcept & setExceptSock( Socket const * sock ) { return setExceptFd( sock->get() ); }
    SelectExcept & setExceptFd( int fd );
    SelectExcept & delExceptFd( int fd );
    SelectExcept & setExceptFds( winux::Mixed const & fds );
    SelectExcept & clear();
    int hasExceptSock( Socket const & sock ) const { return hasExceptFd( sock.get() ); }
    int hasExceptFd( int fd ) const;

    int wait( double sec = -1 );

protected:
    winux::Members<struct SelectExcept_Data> _self;
    DISABLE_OBJECT_COPY(SelectExcept)
};

class EIENNET_DLL Select : public SelectRead, public SelectWrite, public SelectExcept
{
public:
    Select() { }

    Select & setReadSock( Socket const & sock ) { SelectRead::setReadSock(sock); return *this; }
    Select & setReadFd( int fd ) { SelectRead::setReadFd(fd); return *this; }
    Select & delReadFd( int fd ) { SelectRead::delReadFd(fd); return *this; }
    Select & setReadFds( winux::Mixed const & fds ) { SelectRead::setReadFds(fds); return *this; }
    Select & clearReadFds() { SelectRead::clear(); return *this; }

    Select & setWriteSock( Socket const & sock ) { SelectWrite::setWriteSock(sock); return *this; }
    Select & setWriteFd( int fd ) { SelectWrite::setWriteFd(fd); return *this; }
    Select & delWriteFd( int fd ) { SelectWrite::delWriteFd(fd); return *this; }
    Select & setWriteFds( winux::Mixed const & fds ) { SelectWrite::setWriteFds(fds); return *this; }
    Select & clearWriteFds() { SelectWrite::clear(); return *this; }

    Select & setExceptSock( Socket const & sock ) { SelectExcept::setExceptSock(sock); return *this; }
    Select & setExceptFd( int fd ) { SelectExcept::setExceptFd(fd); return *this; }
    Select & delExceptFd( int fd ) { SelectExcept::delExceptFd(fd); return *this; }
    Select & setExceptFds( winux::Mixed const & fds ) { SelectExcept::setExceptFds(fds); return *this; }
    Select & clearExceptFds() { SelectExcept::clear(); return *this; }

    Select & clear() { SelectRead::clear(); SelectWrite::clear(); SelectExcept::clear(); return *this; }

    int wait( double sec = -1 );
};

} // namespace io

class Server;
enum VerboseOutputType
{
    votNone, 
    votConsole, 
    votLogViewer 
};

class EIENNET_DLL ClientCtx
{
public:
    ClientCtx( Server * server, winux::uint64 clientId, winux::String const & clientEpStr, winux::SharedPointer<eiennet::ip::tcp::Socket> clientSockPtr );

    virtual ~ClientCtx();

    winux::String getStamp() const;

    Server * server;            
    winux::uint64 clientId;     
    winux::String clientEpStr;  
    winux::SharedPointer<ip::tcp::Socket> clientSockPtr; 

    bool canRemove;             
    bool processingEvent;       

private:
    DISABLE_OBJECT_COPY(ClientCtx)
};

class EIENNET_DLL Server
{
public:
    Server();

    Server( bool autoReadData, ip::EndPoint const & ep, int threadCount = 4, int backlog = 0, double serverWait = 0.002, double verboseInterval = 0.01, VerboseOutputType verbose = votConsole );

    virtual ~Server();

    bool startup( bool autoReadData, ip::EndPoint const & ep, int threadCount = 4, int backlog = 0, double serverWait = 0.002, double verboseInterval = 0.01, VerboseOutputType verbose = votConsole );

    virtual int run( void * runParam );

    void stop( bool b = true );

    size_t getClientsCount() const;

    void removeClient( winux::uint64 clientId );

protected:
    virtual bool _canAddClient( ClientCtx * clientCtx );
    bool _addClient( ip::EndPoint const & clientEp, winux::SharedPointer<ip::tcp::Socket> clientSockPtr, winux::SharedPointer<ClientCtx> ** ppClientCtxPtr );
    template < typename _Fx, typename... _ArgType >
    void _postTask( winux::SharedPointer<ClientCtx> clientCtxPtr, _Fx fn, _ArgType&& ... arg )
    {
        auto routine = MakeSimple( NewRunable( fn, std::forward<_ArgType>(arg)... ) );
        // 标记为处理事件中
        clientCtxPtr->processingEvent = true;
        this->_pool.task( [routine, clientCtxPtr] () {
            routine->invoke();
            // 事件处理完毕，可再次select()事件
            clientCtxPtr->processingEvent = false;
        } ).post();
    }

    // 客户数据通知
    DEFINE_CUSTOM_EVENT(
        ClientDataNotify,
        ( winux::SharedPointer<ClientCtx> clientCtxPtr, size_t readableSize ),
        ( clientCtxPtr, readableSize )
    )

    // 客户数据到达
    DEFINE_CUSTOM_EVENT(
        ClientDataArrived,
        ( winux::SharedPointer<ClientCtx> clientCtxPtr, winux::Buffer & data ),
        ( clientCtxPtr, data )
    )

    // 当创建客户连接对象
    DEFINE_CUSTOM_EVENT_RETURN_EX(
        ClientCtx *,
        CreateClient,
        ( winux::uint64 clientId, winux::String const & clientEpStr, winux::SharedPointer<ip::tcp::Socket> clientSockPtr )
    );

protected:
    winux::ThreadPool _pool;            
    winux::RecursiveMutex _mtxServer;   
    ip::tcp::Socket _servSockA;         
    ip::tcp::Socket _servSockB;         
    std::map< winux::uint64, winux::SharedPointer<ClientCtx> > _clients; 

    winux::uint64 _cumulativeClientId;  
    bool _stop;                         
    bool _servSockAIsListening;         
    bool _servSockBIsListening;         
    bool _isAutoReadData;               

    double _serverWait;                 
    double _verboseInterval;            
    VerboseOutputType _verbose;         

    friend class ClientCtx;

    DISABLE_OBJECT_COPY(Server)
};


namespace old_v1
{
class ClientCtx
{
public:
    ClientCtx( winux::uint64 clientId, winux::String clientEpStr, winux::SharedPointer<ip::tcp::Socket> clientSockPtr ) :
        clientId(clientId),
        clientEpStr(clientEpStr),
        clientSockPtr(clientSockPtr)
    {
    }

    virtual ~ClientCtx()
    {
    }

    winux::uint64 clientId;
    winux::String clientEpStr;
    winux::SharedPointer<ip::tcp::Socket> clientSockPtr; // 客户连接

private:
    DISABLE_OBJECT_COPY(ClientCtx)
};

template < class _ClientCtxClass >
class Server
{
public:
    using ClientCtxSharedPointer = winux::SharedPointer<_ClientCtxClass>;
    using StartupHandlerFunction = std::function< void( ClientCtxSharedPointer clientCtxPtr ) >;

    Server( ip::EndPoint const & ep, int threadCount = 4, int backlog = 0 ) :
        _cumulativeClientId(0),
        _stop(false),
        _pool(threadCount),
        _mtxServer(true)
    {
        _servSock.setReUseAddr(true);
        _stop = !( _servSock.eiennet::Socket::bind(ep) && _servSock.listen(backlog) );
    }

    virtual ~Server()
    {
    }

    virtual int run()
    {
        io::Select sel;
        while ( !_stop )
        {
            sel.clear();
            sel.setExceptSock(_servSock);
            sel.setReadSock(_servSock);
            int rc = sel.wait(0.01);
            if ( rc > 0 )
            {
                if ( sel.hasReadSock(_servSock) )
                {
                    ip::EndPoint clientEp;
                    auto clientSockPtr = _servSock.accept(&clientEp);
                    if ( clientSockPtr )
                    {
                        auto & clientCtxPtr = this->_addClient( clientEp, clientSockPtr );

                        // 进入该客户的业务逻辑
                        this->onStartup(clientCtxPtr);
                    }
                }
                else if ( sel.hasExceptSock(_servSock) )
                {
                    _stop = true;
                }
            }
        }

        _pool.whenEmptyStopAndWait();
        return 0;
    }

    void stop( bool b = true ) { static_cast<volatile bool &>(_stop) = b; }

    size_t getClientsCount() const
    {
        winux::ScopeGuard guard( const_cast<winux::Mutex &>(_mtxServer) );
        return _clients.size();
    }

    void onStartupHandler( StartupHandlerFunction handler )
    {
        _startupHandler = handler;
    }

    void removeClient( winux::uint64 clientId )
    {
        winux::ScopeGuard guard(_mtxServer);
        _clients.erase(clientId);
    }

protected:
    ClientCtxSharedPointer & _addClient( ip::EndPoint const & clientEp, winux::SharedPointer<ip::tcp::Socket> clientSockPtr )
    {
        ClientCtxSharedPointer * client;
        {
            winux::ScopeGuard guard(_mtxServer);
            ++_cumulativeClientId;
            client = &_clients[_cumulativeClientId];
        }
        client->attachNew( new _ClientCtxClass( _cumulativeClientId, clientEp.toString(), clientSockPtr ) );
        return *client;
    }

    winux::uint64 _cumulativeClientId; // 客户唯一标识
    bool _stop; // 是否停止
    winux::ThreadPool _pool; // 线程池
    winux::Mutex _mtxServer; // 互斥量保护服务器共享数据
    ip::tcp::Socket _servSock; // 服务器监听套接字
    std::map< winux::uint64, ClientCtxSharedPointer > _clients; // 客户表

    // 一个客户的业务逻辑开启
    virtual void onStartup( ClientCtxSharedPointer clientCtxPtr )
    {
        if ( this->_startupHandler ) this->_startupHandler(clientCtxPtr);
    }
    StartupHandlerFunction _startupHandler; // onStartup()事件处理

private:
    DISABLE_OBJECT_COPY(Server)
};

} // namespace old_v1

} // namespace eiennet



#endif // __SOCKET_HPP__