eiennet_socket.hpp

浏览该文件的文档.

#ifndef __SOCKET_HPP__
#define __SOCKET_HPP__

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

class EIENNET_DLL SocketLib
{
public:
    SocketLib();
    ~SocketLib();
private:
    winux::MembersWrapper<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 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;
};

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

    Socket( Socket && other );
    Socket & operator = ( Socket && other );
#endif

    virtual ~Socket();

public:
    // methods ----------------------------------------------------------------------------
    void setParams( AddrFamily af, SockType sockType, Protocol proto );

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

    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, size_t _N = sizeof(_PodType) >
    bool sendUntilType( _PodType const & v, int msgFlags = MsgDefault ) { return this->sendUntil( _N, &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, size_t _N = sizeof(_PodType) >
    bool recvUntilType( _PodType * v, int msgFlags = MsgDefault )
    {
        winux::GrowBuffer data;
        data.setBuf( v, 0, _N, true );
        return this->recvUntilSize( _N, &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, SockType sockType = sockStream );

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

    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:
    winux::MembersWrapper<struct Socket_Data> _self;
    DISABLE_OBJECT_COPY(Socket)
};

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( winux::AnsiString const & target )
    {
        // 搜到指定标记时收到数据的大小（含指定标记）
        size_t searchedDataSize = this->pos + target.size();
        this->extraData._setSize(0);
        // 额外收到的数据
        this->extraData.append( this->data.getBuf<char>() + searchedDataSize, this->data.getSize() - searchedDataSize );
        this->data._setSize(searchedDataSize);

        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;

    operator winux::Mixed() const;

    winux::String getIp() const;
    winux::ushort getPort() const;
private:
    winux::MembersWrapper<struct EndPoint_Data> _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 ) { }

#ifndef MOVE_SEMANTICS_DISABLED

    Socket( Socket && other ) : BaseClass( std::move(other) ) { }
    Socket & operator = ( Socket && other )
    {
        BaseClass::operator = ( std::move(other) );
        return *this;
    }
#endif

    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 ) { }

#ifndef MOVE_SEMANTICS_DISABLED

    Socket( Socket && other ) : BaseClass( std::move(other) ) { }
    Socket & operator = ( Socket && other )
    {
        BaseClass::operator = ( std::move(other) );
        return *this;
    }
#endif

};

} // 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::MembersWrapper<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::MembersWrapper<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::MembersWrapper<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 EIENNET_DLL ClientCtx
{
public:
    ClientCtx( winux::uint64 clientId, winux::String const & clientEpStr, winux::SharedPointer<eiennet::ip::tcp::Socket> clientSockPtr );

    virtual ~ClientCtx();

    winux::String getStamp() const;

    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, bool verbose = true );

    virtual ~Server();

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

    virtual int run( void * runParam );

    void stop( bool b = true );

    size_t getClientsCount() const;

    void removeClient( winux::uint64 clientId );

protected:
    winux::SharedPointer<ClientCtx> & _addClient( ip::EndPoint const & clientEp, winux::SharedPointer<ip::tcp::Socket> clientSockPtr );
    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();
    }

    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;            
    bool _verbose;                      

private:
    // 客户数据通知
    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, std::move(data) )
    )

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

    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, Socket::sockStream ) && _servSock.listen(backlog) );
    }

    virtual ~Server()
    {
    }

    virtual int run()
    {
        while ( !_stop )
        {
            io::Select sel;
            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__