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 EIENNET_DLL 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;
    virtual winux::uint & size() const = 0;
    virtual winux::String toString() const = 0;
};

class EIENNET_DLL Socket
{
public:

    // classes and types ------------------------------------------------------------------
    enum AddrFamily {
        afUnspec = 0,           /* Unspecified.  */
        afLocal = 1,            /* Local to host (pipes and file-domain).  */
        afUnix = afLocal,       /* POSIX name for PF_LOCAL.  */
        afFile = afLocal,       /* Another non-standard name for PF_LOCAL.  */
        afInet = 2,             /* IP protocol family.  */
        afAx25 = 3,             /* Amateur Radio AX.25.  */
        afIpx = 4,              /* Novell Internet Protocol.  */
        afAppletalk = 5,        /* Appletalk DDP.  */
        afNetrom = 6,           /* Amateur radio NetROM.  */
        afBridge = 7,           /* Multiprotocol bridge.  */
        afAtmpvc = 8,           /* ATM PVCs.  */
        afX25 = 9,              /* Reserved for X.25 project.  */
        afInet6 = 10,           /* IP version 6.  */
        afRose = 11,            /* Amateur Radio X.25 PLP.  */
        afDecnet = 12,          /* Reserved for DECnet project.  */
        afNetbeui = 13,         /* Reserved for 802.2LLC project.  */
        afSecurity = 14,        /* Security callback pseudo AF.  */
        afKey = 15,             /* PF_KEY key management API.  */
        afNetlink = 16,
        afRoute = afNetlink,    /* Alias to emulate 4.4BSD.  */
        afPacket = 17,          /* Packet family.  */
        afAsh = 18,             /* Ash.  */
        afEconet = 19,          /* Acorn Econet.  */
        afAtmsvc = 20,          /* ATM SVCs.  */
        afRds = 21,             /* RDS sockets.  */
        afSna = 22,             /* Linux SNA Project */
        afIrda = 23,            /* IRDA sockets.  */
        afPppox = 24,           /* PPPoX sockets.  */
        afWanpipe = 25,         /* Wanpipe API sockets.  */
        afLlc = 26,             /* Linux LLC.  */
        afUnknown27 = 27,
        afUnknown28 = 28,
        afCan = 29,             /* Controller Area Network.  */
        afTipc = 30,            /* TIPC sockets.  */
        afBluetooth = 31,       /* Bluetooth sockets.  */
        afIucv = 32,            /* IUCV sockets.  */
        afRxrpc = 33,           /* RxRPC sockets.  */
        afIsdn = 34,            /* mISDN sockets.  */
        afPhonet = 35,          /* Phonet sockets.  */
        afIeee802154 = 36,      /* IEEE 802.15.4 sockets.  */
        afMax = 37              /* For now..  */
    };

    enum SockType {
        sockUnknown,
        sockStream,     /* Sequenced, reliable, connection-based byte streams.  */
        sockDatagram,   /* Connectionless, unreliable datagrams of fixed maximum length.  */
        sockRaw,        /* Raw protocol interface.  */
        sockRdm,        /* Reliably-delivered messages.  */
        sockSeqPacket,  /* Sequenced, reliable, connection-based, datagrams of fixed maximum length.  */
        sockDccp,       /* Datagram Congestion Control Protocol.  */
        sockPacket,     /* Linux specific way of getting packets at the dev level.  For writing rarp and
                               other similar things on the user level. */

        /* Flags to be ORed into the type parameter of socket and socketpair and used for the flags parameter of paccept.  */

        sockCloexec,    /* Atomically set close-on-exec flag for the new descriptor(s).  */
        sockNonblock    /* Atomically mark descriptor(s) as non-blocking.  */
    };

    enum Protocol {
        protoIp = 0,    /* Dummy protocol for TCP.  */
        protoIcmp,      /* Internet Control Message Protocol.  */
        protoIgmp,      /* Internet Group Management Protocol. */
        protoIpip, protoIpv4 = protoIpip, /* IPIP tunnels (older KA9Q tunnels use 94).  */
        protoTcp,      /* Transmission Control Protocol.  */
        protoEgp,      /* Exterior Gateway Protocol.  */
        protoPup,      /* PUP protocol.  */
        protoUdp,      /* User Datagram Protocol.  */
        protoIdp,      /* XNS IDP protocol.  */
        protoTp,       /* SO Transport Protocol Class 4.  */
        protoDccp,     /* Datagram Congestion Control Protocol.  */
        protoIpv6,     /* IPv6 header.  */
        protoRsvp,     /* Reservation Protocol.  */
        protoGre,      /* General Routing Encapsulation.  */
        protoEsp,      /* encapsulating security payload.  */
        protoAh,       /* authentication header.  */
        protoMtp,      /* Multicast Transport Protocol.  */
        protoBeetph,   /* IP option pseudo header for BEET.  */
        protoEncap,    /* Encapsulation Header.  */
        protoPim,      /* Protocol Independent Multicast.  */
        protoComp,     /* Compression Header Protocol.  */
        protoSctp,     /* Stream Control Transmission Protocol.  */
        protoUdplite,  /* UDP-Lite protocol.  */
        protoRaw,      /* Raw IP packets.  */
        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 ( int 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 ----------------------------------------------------------------------------

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

    int close();

    int shutdown( int how = SdReceive );

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

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

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

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

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

    winux::Buffer recv( int 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, int * hadRead, int * startpos, int * pos, double sec, int * rcWait, FunctionSuccessCallback eachSuccessCallback = FunctionSuccessCallback(), void * param = nullptr, int msgFlags = MsgDefault );

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

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

    template < typename _PodType >
    bool recvUntilType( _PodType * v, int msgFlags = MsgDefault )
    {
        winux::GrowBuffer data;
        data.setBuf( v, 0, sizeof(_PodType), true );
        return this->recvUntilSize( sizeof(_PodType), &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, int size, int msgFlags = MsgDefault );
    int recvFrom( EndPoint * ep, void * buf, int 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 );

    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; // 额外数据
    int startpos; // 起始位置
    int pos; // 找到位置
    int hadBytes; // 已接收/发送数据量
    int targetBytes; // 目标数据量
    int retryCount; // 已重试次数

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

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

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


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,
        winux::uint32 inputBufSize = (winux::uint32)-1,
        winux::uint32 outputBufSize = (winux::uint32)-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, std::streamsize size );
    std::streamsize waitAvail( double sec );
};


namespace ip
{

class EIENNET_DLL EndPoint : public eiennet::EndPoint
{
public:
    EndPoint();
    EndPoint( winux::Mixed const & ipAndPort );
    EndPoint( winux::String const & ipAddr, winux::ushort port );
    EndPoint( EndPoint const & other );
    virtual ~EndPoint();
    EndPoint & operator = ( EndPoint const & other );

    virtual void * get() const;
    virtual winux::uint & size() const;
    virtual winux::String toString() const;

    operator winux::Mixed() 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(); }

    int count() const { return (int)_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; }

    operator winux::Mixed() const;
private:
    int _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::protoTcp ) { }

#ifndef MOVE_SEMANTICS_DISABLED

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

    bool connect( winux::String const & ipAddr, winux::ushort port )
    {
        return BaseClass::connect( EndPoint( ipAddr, port ) );
    }

    bool bind( winux::String const & ipAddr, winux::ushort port )
    {
        return BaseClass::bind( EndPoint( ipAddr, port ) );
    }

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

#ifndef MOVE_SEMANTICS_DISABLED

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

    int sendTo( winux::String const & ipAddr, winux::ushort port, void const * data, int size, int msgFlags = MsgDefault )
    {
        return BaseClass::sendTo( EndPoint( ipAddr, port ), data, size, msgFlags );
    }

    int recvFrom( winux::String * ipAddr, winux::ushort * port, void * buf, int size, int msgFlags = MsgDefault );
};

} // 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 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, double durationSec = 0.1 ) :
        _cumulativeClientId(0),
        _stop(false),
        _pool( threadCount, winux::ThreadPool::modeWaitTimeRePost, durationSec ),
        _mtxServer(true)
    {
        _stop = !( _servSock.eiennet::Socket::bind(ep) && _servSock.listen(backlog) );
    }

    virtual ~Server()
    {
    }

    virtual int run()
    {
        while ( !_stop )
        {
            io::Select sel;
            sel.setExceptSock(_servSock);
            sel.setReadSock(_servSock);
            int rc = sel.wait(0.5);
            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;
    }

    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 eiennet



#endif // __SOCKET_HPP__