TnbSocket.h

[詳解]

#pragma once
#include "TnbAbstractReport.h"
#include "TnbThread.h"
#include "TnbVector.h"
#include "TnbIcmp.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
typedef TNB::CVectorT<SOCKET> CSocketVector;
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 _SELECTANY bool s_boIsInitSock = false;
 _SELECTANY int s_iMaxUdpDg = 0;
#endif
 
 
 
class CSocketAddress
{
public:
 
    CSocketAddress(WORD portNo = 0, DWORD ipAddress = 0) : m_portNo(portNo), m_isNameMode(false)
    {
        m_inaddr.s_addr = ::htonl(ipAddress);
    }
 
    CSocketAddress(WORD portNo, LPCTSTR lpszIpAddressName) : m_portNo(portNo), m_isNameMode(true)
    {
        m_inaddr.s_addr = 0;
        m_ipAddressName = lpszIpAddressName;
    }
 
    void Set(WORD portNo, DWORD ipAddress = 0)
    {
        m_isNameMode = false;
        m_inaddr.s_addr = ::htonl(ipAddress);
        m_ipAddressName.Empty();
        m_portNo = portNo;
    }
 
    void Set(WORD portNo, LPCTSTR lpszIpAddressName)
    {
        m_isNameMode = true;
        m_inaddr.s_addr = 0;
        m_portNo = portNo;
        m_ipAddressName = lpszIpAddressName;
    }
 
    void Set(const SOCKADDR_IN& sockaddr)
    {
        m_isNameMode = false;
        m_inaddr = sockaddr.sin_addr;
        m_ipAddressName.Empty();
        m_portNo = ::ntohs(sockaddr.sin_port);
    }
 
    void Get(IN_ADDR& _inaddr) const
    {
        if ( ! m_isNameMode )
        {
            _inaddr = m_inaddr;
        }
        else
        {
            DWORD ad = ::inet_addr(m_ipAddressName);
            if ( ad == INADDR_NONE )
            {
                // ドット形式でないとき
                LPHOSTENT ptHost = ::gethostbyname(m_ipAddressName);
                if ( ptHost == NULL )
                {
                    TRACE2( "::gethostbyname(%s) error = %d\n", CStr(m_ipAddressName), ::WSAGetLastError() );
                    ad = INADDR_NONE;
                }
                else
                {
                    ad = *(reinterpret_cast<DWORD*>(ptHost->h_addr));
                }
            }
            _inaddr.s_addr = ad;
        }
    }
 
    void Get(SOCKADDR_IN& _sockaddr) const
    {
        Get(_sockaddr.sin_addr);
        _sockaddr.sin_port = ::htons(m_portNo);
    }
 
    CStr GetHostName(void) const
    {
        IN_ADDR inaddr;
        Get(inaddr);
        hostent* P = ::gethostbyaddr(reinterpret_cast<const char*>(&inaddr), sizeof(inaddr), AF_INET);
        if ( P != NULL )
        {
            return CStr(P->h_name);
        }
        return _T("");
    }
 
    CStr GetAddressString(bool withDns = true) const
    {
        if ( ! m_isNameMode )
        {
            if ( withDns && m_inaddr.s_addr != INADDR_ANY)
            {
                hostent* P = ::gethostbyaddr(reinterpret_cast<const char*>(&m_inaddr), sizeof(m_inaddr), AF_INET);
                if ( P != NULL )
                {
                    return CStr(P->h_name);
                }
            }
            return CStr(::inet_ntoa(m_inaddr));
        }
        else
        {
            return CStr(m_ipAddressName);
        }
    }
 
    DWORD GetAddress(void) const
    {
        in_addr addr;
        Get(addr);
        return ::htonl(addr.s_addr);
    }
 
    WORD GetPortNo(void) const
    {
        return m_portNo;
    }
 
    bool IsBroadcast(void) const
    {
        return GetAddress() == INADDR_BROADCAST;
    }
 
    static DWORD htonl(DWORD hostlong)
    {
        return ::htonl(hostlong);
    }
 
    static WORD htons(WORD hostshort)
    {
        return ::htons(hostshort);
    }
 
    static DWORD ntohl(DWORD netlong)
    {
        return ::ntohl(netlong);
    }
 
    static DWORD ntohs(DWORD netshort)
    {
        return ::ntohl(netshort);
    }
 
private:
    bool        m_isNameMode;       
    IN_ADDR     m_inaddr;           
    CAscii      m_ipAddressName;    
    WORD        m_portNo;           
};
 
 
 
class CSocketEvent : public CReportEvent
{
    DEFSUPER(CReportEvent);
    SOCKET                      m_soData;   
    class CAbstractSocket *     m_pcSocket; 
public:
 
    CSocketEvent(CAbstractSocket* pcSocket, SOCKET so, EReportEvent eEvent = ReportEvent_Non, DWORD dwError = 0);
 
    virtual bool Send(size_t dataSize, LPCVOID lpcvData) const;
 
    virtual DWORD GetInterfaceId(void) const
    {
        return static_cast<DWORD>(m_soData) | 0x80000000;
    }
 
    bool GetPeerName(CSocketAddress& _address) const;
 
    bool GetSockName(CSocketAddress& _address) const;
 
    SOCKET GetSocket(void) const
    {
        return m_soData;
    }
};
 
 
 
class CAbstractSocket : public CAbstractReport
{
    DEFSUPER(CAbstractReport);
    friend class CSocketEvent;      
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual bool OnSocketEvent(const CSocketEvent& ev) = 0;
    };
 
 
    //----------------------------
 
 
    CAbstractSocket(void) : _super(), m_piSocketListner(NULL), m_boIsDelay(true)
    {
        m_lpcBuffer = new char[E_BufferSize];
    }
 
    virtual ~CAbstractSocket(void)
    {
        delete[] m_lpcBuffer;
    }
 
    virtual void SetSocketListener(IListener* piSocketListener)
    {
        m_piSocketListner = piSocketListener;
    }
 
    static void StartUp(void)
    {
        if ( s_boIsInitSock )
        {
            return;
        }
        s_boIsInitSock = true;
        #ifndef _WIN32_WCE
        SOCKET so = ::socket(AF_INET, SOCK_STREAM, 0);
        if ( so != SOCKET_ERROR )
        {
            ::closesocket(so);
            return;
        }
        if ( ::WSAGetLastError() == WSANOTINITIALISED )
        #endif //_WIN32_WCE
        {
            WSADATA wsaData;
            if ( ::WSAStartup(E_DefaultVersion, &wsaData) == SOCKET_ERROR )
            {
                ASSERT1( false, "WSAStartup", "error = %d\n", ::WSAGetLastError() );
            }
            else
            {
                static CCleanup s_cleanup; // Cleanup用インスタンス
                if ( LOBYTE(wsaData.wVersion) == 1 )
                {
                    s_iMaxUdpDg = wsaData.iMaxUdpDg;
                }
                else
                {
                    s_iMaxUdpDg = 0;
                }
            }
        }
    }
 
    static CDwordVector GetMyAddress(void)
    {
        CDwordVector v;
        CAscii na;
        ::gethostname(na.GetBuffer(1000), 1000);
        na.ReleaseBuffer();
        hostent* pHostEnt = ::gethostbyname(na);
        if ( pHostEnt != NULL )
        {
            loop ( i, 1000 )
            {
                DWORD* p = reinterpret_cast<DWORD*>(pHostEnt->h_addr_list[i]);
                if ( p == NULL )
                {
                    break;
                }
                v.Add(SwapEndian(*p));
            }
        }
        return v;
    }
 
protected:
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
 
    struct TSockAddr : SOCKADDR_IN
    {
        void Init(void) { memset(this, 0, sizeof(SOCKADDR_IN)); }
        static int GetSize(void) { return sizeof(SOCKADDR_IN); }
        operator LPSOCKADDR(void) { return reinterpret_cast<LPSOCKADDR>(this); }
    };
 
    enum
    {
        #ifdef _TnbWINSOCK2_ENABLE
         E_DefaultVersion   = WINSOCK_VERSION,  
        #else
         E_DefaultVersion   = MAKEWORD(1, 1),   
        #endif
        E_BufferSize        = 10000,    
        E_RetryDelay        = 2000,     
        E_SelectTimeout     = 2000,     
        E_ConnectTimeout    = 2000,     
    };
    TSockAddr       m_sockaddrPartner;  
    IListener *     m_piSocketListner;  
    char *          m_lpcBuffer;        
    bool            m_boIsDelay;        
 
    class CCleanup
    {
    public:~CCleanup(void) { ::WSACleanup(); }
    };
 
    static bool ms_AddressToIp(IN_ADDR& _addr, LPCTSTR lpszAddress)
    {
        StartUp();
        CSocketAddress a(0, lpszAddress);
        a.Get(_addr);
        return (_addr.s_addr != INADDR_NONE);
    }
 
    bool m_SetAddress(LPCTSTR lpszAddress, WORD wPortNo)
    {
        // ソケット構造体の初期化
        m_sockaddrPartner.Init();
        m_sockaddrPartner.sin_family = AF_INET;         // TCP/IPを指定
        CSocketAddress a(wPortNo, lpszAddress);
        a.Get(m_sockaddrPartner);
        return m_sockaddrPartner.sin_addr.s_addr != INADDR_NONE;
    }
 
    bool m_SetAddress(const CSocketAddress& address)
    {
        // ソケット構造体の初期化
        m_sockaddrPartner.Init();
        m_sockaddrPartner.sin_family = AF_INET;         // TCP/IPを指定
        address.Get(m_sockaddrPartner);
        return m_sockaddrPartner.sin_addr.s_addr != INADDR_NONE;
    }
 
    bool m_Recv(SOCKET so)
    {
        int iLen = ::recv(so, m_lpcBuffer, E_BufferSize, 0);
        if ( iLen == SOCKET_ERROR )
        {
            int iError = ::WSAGetLastError();
            TRACE2( "::recv(%d) error = %d\n", so, iError );
            if ( iError != WSAENOTSOCK/*10038*/ && iError != WSAESHUTDOWN/*10058*/ )
            {
                m_OnSocketEvent(CSocketEvent(this, so, ReportEvent_Error, iError));
            }
            return false;   //切断
        }
        else if ( iLen == 0 )
        {
            TTRACE0("CSocket:Closed Connection\n");
            return false;
        }
        else
        {
            CSocketEvent s(this, so);
            s.SetData(iLen, m_lpcBuffer);
            if ( ! m_OnSocketEvent(s) )
            {
                return false;   //切断
            }
        }
        return true;
    }
 
    static bool ms_SetDelayMode(SOCKET so, bool boIsDelay)
    {
        BOOL boValue = ! boIsDelay;
        int iRc = ::setsockopt(
                            so,
                            IPPROTO_TCP,
                            TCP_NODELAY,
                            reinterpret_cast<const char*>(&boValue),
                            sizeof(BOOL));
        #ifdef _DEBUG
            if ( iRc != 0) { TRACE2( "::setsockopt(%d) error = %d\n ", so, ::WSAGetLastError()); } 
        #endif
        {
            BOOL yes = TRUE;
            ::setsockopt(so, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char*>(&yes), sizeof(yes));
        }
        return iRc == 0;
    }
 
    virtual bool m_Send(SOCKET so, size_t dataSize, LPCVOID lpcvData)
    {
        if ( so == INVALID_SOCKET )
        {
            return false;
        }
        int iRc = ::send(so, static_cast<const char*>(lpcvData), ToInt(dataSize), 0);
        TRACE2("::send(%u) result = %d\n", dataSize, iRc);
        return iRc == ToInt(dataSize);
    }
 
    virtual bool m_GetPeerName(CSocketAddress& _address, SOCKET so)
    {
        TSockAddr addr;
        int iLen = addr.GetSize();
        if ( ::getpeername(so, addr, &iLen) == SOCKET_ERROR )
        {
            TRACE2( "::getpeername(%d) error = %d\n", so, ::WSAGetLastError() );
            return false;
        }
        _address.Set(addr);
        return true;
    }
 
    virtual bool m_OnSocketEvent(CSocketEvent& e)
    {
        bool r = true;
        if ( m_piSocketListner != NULL )
        {
            r &= m_piSocketListner->OnSocketEvent(e);
        }
        r &= _super::m_OnEvent(e);
        return r;
    }
 
    WORD m_GetMaxUdpDg(SOCKET s)
    {
        ASSERTLIB(s_iMaxUdpDg >= 0);
        #ifdef _TnbWINSOCK2_ENABLE
            if ( s_iMaxUdpDg == 0 )
            {
                int iOptVal;
                int iOptLen = sizeof(iOptVal);
                int r = ::getsockopt(s, SOL_SOCKET, SO_MAX_MSG_SIZE, reinterpret_cast<char*>(&iOptVal), &iOptLen);
                return static_cast<WORD>((r == SOCKET_ERROR) ? 0 : iOptVal);
            }
        #endif
        return static_cast<WORD>(s_iMaxUdpDg);
    }
    #endif // _TnbDOXYGEN
};
 
 
 
inline CSocketEvent::CSocketEvent(CAbstractSocket* pcSocket, SOCKET so, EReportEvent eEvent, DWORD dwError)
    : _super(static_cast<IReport*>(pcSocket), eEvent, dwError)
{
    m_soData    = so;
    m_pcSocket  = pcSocket;
}
 
// データ送信
inline bool CSocketEvent::Send(size_t dataSize, LPCVOID lpcvData) const
{
    return m_pcSocket->Send(dataSize, lpcvData);
//  return m_pcSocket->m_Send(m_soData, dataSize, lpcvData);
}
 
//情報取得
inline bool CSocketEvent::GetPeerName(CSocketAddress& _address) const
{
    return m_pcSocket->m_GetPeerName(_address, m_soData);
}
 
//情報取得
inline bool CSocketEvent::GetSockName(CSocketAddress& _address) const
{
    CAbstractSocket::TSockAddr addr;
    int iLen = addr.GetSize();
    if ( ::getsockname(m_soData, addr, &iLen) == SOCKET_ERROR )
    {
        TRACE2( "::getpeername(%d) error = %d\n", m_soData, ::WSAGetLastError() );
        return false;
    }
    _address.Set(addr);
    return true;
}
 
 
 
class CSocketClient : public CAbstractSocket, TNB::CThread::IRunner
{
    DEFSUPER(CAbstractSocket);
public:
 
    explicit CSocketClient(bool isAutoReconnect = true) 
        : _super(), m_soData(INVALID_SOCKET), m_isAutoReconnect(isAutoReconnect), m_wServerPortNo(0)
    {
        m_threadReceiver.SetRunner(this);
    }
 
    virtual ~CSocketClient(void)
    {
        m_CloseDataSocket();
        m_threadReceiver.Stop();
    }
 
    void SetDelayMode(bool boIsDelay)
    {
        m_boIsDelay = boIsDelay;
    }
 
    virtual CStr GetReportName(void) const 
    {
        return CStr::Fmt(_T("SocketClient[%u]:"), m_soData);
    }
 
    virtual DWORD GetReportID(void) const 
    {
        return TNBVIW_KIND_SOCK_C + (m_soData & 0xFFFF);
    }
 
    SOCKET GetSocket(void) const
    {
        return m_soData;
    }
 
    void SetServer(const CSocketAddress& address)
    {
        StartUp();
        Stop();
        m_strServerAddress = address.GetAddressString(false);
        m_wServerPortNo = address.GetPortNo();
    }
 
    virtual bool Start(void)
    {
        StartUp();
        Stop();
        if ( ! m_SetAddress(m_strServerAddress, m_wServerPortNo) )
        {
            if ( ! m_isAutoReconnect )
            {
                return false;
            }
        }
        if ( ! m_isAutoReconnect )
        {
            if ( ! m_ConnectSub() )
            {
                return false;
            }
        }
        #ifdef _DEBUG
            m_threadReceiver.Start(CStr::Fmt(_T("Client(p=%d)監視"), m_wServerPortNo));
        #else
            m_threadReceiver.Start();
        #endif
        return true;
    }
 
    bool Connect(const CSocketAddress& address)
    {
        SetServer(address);
        return Start();
    }
 
    virtual bool IsAlive(void) const
    {
        return m_threadReceiver.IsAlive(); 
    }
    
    virtual bool IsConnect(void) const
    {
        return m_soData != INVALID_SOCKET; 
    }
 
    virtual bool Send(size_t dataSize, LPCVOID lpcvData)
    {
        TTRACE1("CSocket[Client%d]:Send\n", m_soData);
        _super::m_OnSend(dataSize, lpcvData);
        return m_Send(m_soData, dataSize, lpcvData);
    }
 
    virtual void Stop(void)
    {
        if ( IsConnect() )
        {
            m_CloseDataSocket();
        }
        m_threadReceiver.Stop();
    }
 
    void Disconnect(void)
    {
        Stop(); 
    }
 
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_threadReceiver;
    }
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
    // [実行] 開始. 旧タイプの指定方法です。 廃止予定です。
    bool Connect(LPCTSTR lpszAddress, WORD wPortNo)
    {
        SetServer(CSocketAddress(wPortNo, lpszAddress));
        return Start();
    }
#endif
 
private:
    TNB::CThread    m_threadReceiver;   
    bool            m_isAutoReconnect;  
    SOCKET          m_soData;           
    CStr            m_strServerAddress; 
    WORD            m_wServerPortNo;    
 
    bool m_ConnectWithTimeout(SOCKET so, DWORD dwTimeout)
    {
        DWORD dwOpt = 1;    //非ブロッキングに設定
        ::ioctlsocket(so, FIONBIO, &dwOpt);
        int iCntRst = ::connect(so, m_sockaddrPartner, m_sockaddrPartner.GetSize());
        if ( iCntRst == SOCKET_ERROR ) 
        {
            DWORD dwError = ::WSAGetLastError();
            if ( dwError != WSAEWOULDBLOCK )
            {
                TRACE2("::connect(%d) error = %d\n", so, dwError);
                dwOpt = 0;  //ブロッキングに設定
                ::ioctlsocket(so, FIONBIO, &dwOpt);
                return false;
            }
            fd_set tFdSet;
            FD_ZERO(&tFdSet);
            FD_SET(so, &tFdSet);
            timeval tTimeVal = { dwTimeout / 1000, dwTimeout % 1000 };
            ::select(FD_SETSIZE, NULL, &tFdSet, NULL, &tTimeVal);
            if ( ! FD_ISSET(so, &tFdSet) )
            {
                dwOpt = 0;  //ブロッキングに設定
                ::ioctlsocket(so, FIONBIO, &dwOpt);
                return false;
            }       
        }
        dwOpt = 0;  //ブロッキングに設定
        ::ioctlsocket(so, FIONBIO, &dwOpt);
        return true;
    }
 
    bool m_ConnectSub(void)
    {
        if ( m_soData != INVALID_SOCKET )
        {
            return true;
        }
        SOCKET so = ::socket(AF_INET, SOCK_STREAM, 0);
        if ( so == SOCKET_ERROR ) 
        {
            TRACE1( "::socket() error = %d\n", ::WSAGetLastError() );
            return false;
        }
        if ( ! ms_AddressToIp(m_sockaddrPartner.sin_addr, m_strServerAddress) )
        {
            ::shutdown(so, SD_BOTH);
            ::closesocket(so);
            return false;
        }
        if ( ! m_ConnectWithTimeout(so, E_ConnectTimeout) )
        {
            ::shutdown(so, SD_BOTH);
            ::closesocket(so);
            return false;
        }
        TTRACE1("CSocket[Client%d]:Connected\n", so);
        m_soData = so;
        if ( ! m_OnSocketEvent(CSocketEvent(this, m_soData, ReportEvent_Connect)) )
        {
            m_CloseDataSocket();
            return false;
        }
        ms_SetDelayMode(m_soData, m_boIsDelay);
        return true;
    }
 
    void m_CloseDataSocket(void)
    {
        if ( m_soData != INVALID_SOCKET )
        {
            SOCKET so = m_soData;
            m_soData = INVALID_SOCKET;
            TTRACE1("CSocket[Client%d]:Closed\n", so);
            m_OnSocketEvent(CSocketEvent(this, so, ReportEvent_Disconnect));
            ::shutdown(so, SD_BOTH);
            ::closesocket(so);
        }
    }
 
    virtual DWORD Run(void)
    {
        while ( IsRunnable() )
        {
            if ( ! m_ConnectSub() )
            {
                loop ( i, 20 )
                {
                    if ( ! IsRunnable() )
                    {
                        break;
                    }
                    ::Sleep(E_RetryDelay / 20);
                }
                continue;
            }
            //
            CTickCount tickIdle;
            CTickCount tickConCheck;
            while ( IsRunnable() )
            {
                fd_set tFdSet;
                FD_ZERO(&tFdSet);
                FD_SET(m_soData, &tFdSet);
                int iSelTime = E_SelectTimeout;
                int iInterval = _super::GetIdleInterval();
                if ( iInterval > 0 )
                {
                    iSelTime = iInterval;
                }
                timeval tTimeVal = { iSelTime / 1000, iSelTime % 1000 };
                ::select(ToInt(m_soData + 1), &tFdSet, NULL, NULL, &tTimeVal);
                if ( ! FD_ISSET(m_soData, &tFdSet) )
                {
                    if ( tickConCheck.IsPassedAndReset(E_SelectTimeout) )
                    {
                        CSocketAddress adds;
                        if ( ! m_GetPeerName(adds, m_soData) )
                        {
                            break;  //切断
                        }
                    }
                    if ( iInterval > 0 && tickIdle.IsPassedAndReset(iInterval) )
                    {
                        if ( ! m_OnSocketEvent(CSocketEvent(this, m_soData, ReportEvent_Idle)) )
                        {
                            break;  //切断
                        }
                    }
                    continue;
                }
                if ( ! m_Recv(m_soData) )
                {
                    break;  //切断
                }
                TTRACE1("CSocket[Client%d]:受信成功\n", m_soData);
                tickIdle.Reset();
            }
            //
            TTRACE1("CSocket[Client%d]:受信停止\n", m_soData);
            m_CloseDataSocket();
            if ( ! m_isAutoReconnect )
            {
                break;
            }
            loop ( i, 20 )
            {
                if ( ! IsRunnable() )
                {
                    break;
                }
                ::Sleep(E_RetryDelay / 20);
            }
        }
        m_OnSocketEvent(CSocketEvent(this, m_soData, ReportEvent_End));
        return 0;
    }
};
 
 
 
class CSocketServer : public CAbstractSocket, TNB::CThread::IRunner
{
    DEFSUPER(CAbstractSocket);
public:
 
    CSocketServer(void) : _super(), m_soListen(INVALID_SOCKET), m_connectMax(1), m_wOpenPortNo(0)
    {
        m_threadReceiver.SetRunner(this);
    }
 
    virtual ~CSocketServer(void)
    {
        Close(); 
    }
 
    void SetDelayMode(bool boIsDelay)
    {
        m_boIsDelay = boIsDelay;
    }
 
    virtual CStr GetReportName(void) const 
    {
        return CStr::Fmt(_T("SocketServer[%08X]:"), this);
    }
 
    virtual DWORD GetReportID(void) const 
    {
        return TNBVIW_KIND_SOCK_S + (reinterpret_cast<DWORD>(this) & 0xFFFF);
    }
 
    void SetConnectMax(size_t max)
    {
        if ( max >= 1 )
        {
            m_connectMax = max; 
        }
    }
 
    void SetParameter(const CSocketAddress& address)
    {
        StartUp();
        Stop();
        m_wOpenPortNo = address.GetPortNo();
        m_strAwaitAddress = address.GetAddressString(false);
    }
 
    virtual bool Start(void)
    {
        StartUp();
        Stop();
        if ( GetConnectedSockets() != 0 )
        {
            return false;
        }
        if ( m_strAwaitAddress.IsEmpty() )
        {
            m_strAwaitAddress = _T("0.0.0.0");
        }
        if ( ! m_SetAddress(m_strAwaitAddress, m_wOpenPortNo) )
        {
            return false;
        }
        if ( m_OpenListenSocket() == 10048 )
        {
            return false;
        }
        #ifdef _DEBUG
            m_threadReceiver.Start(CStr::Fmt(_T("Server(p=%d)監視"), m_wOpenPortNo));
        #else
            m_threadReceiver.Start();
        #endif
        return true;
    }
 
    bool Open(const CSocketAddress& address)
    {
        SetParameter(address);
        return Start();
    }
 
    INT_PTR GetConnectedSockets(CSocketVector* P = NULL) const
    {
        if ( P != NULL )
        {
            EXCLUSIVE(&m_syncSocket);
            *P = m_vsoData;
        }
        return m_vsoData.GetSize();
    }
 
    bool IsConnect(SOCKET so) const
    {
        EXCLUSIVE(&m_syncSocket);
        loop ( i, m_vsoData.GetSize() )
        {
            if ( m_vsoData[i] == so ){ return true; }
        }
        return false;
    }
 
    bool Send(SOCKET so, size_t dataSize, LPCVOID lpcvData)
    {
        TTRACE1("CSocket[Server%d]:Send\n", so);
        _super::m_OnSend(dataSize, lpcvData);
        return m_Send(so, dataSize, lpcvData);
    }
 
    bool GetPeerName(CSocketAddress& _address, SOCKET so)
    {
        return m_GetPeerName(_address, so);
    }
 
    void Disconnect(SOCKET so)
    {
        m_CloseDataSocket(so);
    }
 
    virtual bool IsAlive(void) const
    {
        return m_threadReceiver.IsAlive();
    }
 
    virtual bool IsConnect(void) const
    {
        return GetConnectedSockets() != 0; 
    }
 
    virtual bool Send(size_t dataSize, LPCVOID lpcvData)
    {
        TTRACE0("CSocket[Server%d]:Send<All>\n");
        bool boRc = true;
        EXCLUSIVE(&m_syncSocket);
        loop ( i, m_vsoData.GetSize() )
        {
            boRc &= Send(m_vsoData[i], dataSize, lpcvData);
        }
        return boRc;
    }
 
    void Disconnect(void)
    {
        m_CloseAllDataSockets();
        m_OpenListenSocket();
    }
 
    virtual void Stop(void)
    {
        Close();
    }
 
    void Close(void)
    {
        TTRACE0("CSocket[Server]:サーバクローズ\n");
        m_CloseAllDataSockets();
        m_CloseListenSocket();
        m_threadReceiver.Stop();
    }
 
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_threadReceiver;
    }
 
private:
    TNB::CThread    m_threadReceiver;   
    SOCKET          m_soListen;         
    CSocketVector   m_vsoData;          
    CSyncSection    m_syncSocket;       
    size_t          m_connectMax;       
    WORD            m_wOpenPortNo;      
    CStr            m_strAwaitAddress;  
    
    void m_CloseAllDataSockets(void)
    {
        EXCLUSIVE(&m_syncSocket);
        size_t iLen = m_vsoData.GetSize();
        if ( iLen > 0 )
        {
            TTRACE0("CSocket[Server]:全クローズ\n");
            loop ( i, iLen )
            {
                if ( m_vsoData[i] != INVALID_SOCKET )
                {
                    SOCKET so = m_vsoData[i];
                    TTRACE1("CSocket[Server%d]:クローズ\n", so);
                    m_OnSocketEvent(CSocketEvent(this, so, ReportEvent_Disconnect));
                    ::shutdown(so, SD_BOTH);
                    ::closesocket(so);
                }
            }
            m_vsoData.RemoveAll();
        }
    }
 
    void m_CloseDataSocket(SOCKET so)
    {
        EXCLUSIVE(&m_syncSocket);
        loop ( i, m_vsoData.GetSize() )
        {
            if ( m_vsoData[i] == so )
            {
                TTRACE1("CSocket[Server%d]:クローズ\n", so);
                m_vsoData.Remove(i);
                m_OnSocketEvent(CSocketEvent(this, so, ReportEvent_Disconnect));
                ::shutdown(so, SD_BOTH);
                ::closesocket(so);
                m_OpenListenSocket();
                break;
            }
        }
    }
 
    int m_OpenListenSocket(void)
    {
        if ( m_soListen == INVALID_SOCKET )
        {
            m_soListen = ::socket(AF_INET, SOCK_STREAM, 0); // TCP socket
            if ( m_soListen == INVALID_SOCKET )
            {
                int r = ::WSAGetLastError();
                ASSERT( r != 0 );
                TRACE1( "::socket() error = %d\n", r );
                return r;
            }
            if ( ::bind(m_soListen, m_sockaddrPartner, m_sockaddrPartner.GetSize()) == SOCKET_ERROR )
            {
                int r = ::WSAGetLastError();
                ASSERT( r != 0 );
                TRACE2( "::bind(%d) error = %d\n", m_soListen, r );
                return r;
            }
            TTRACE0("CSocket[Server]:リスナーSOCKETオープン\n");
            if ( ::listen(m_soListen, 5) == SOCKET_ERROR ) 
            {
                int r = ::WSAGetLastError();
                ASSERT( r != 0 );
                TRACE2( "::listen(%d) error = %d\n", m_soListen, r );
                m_CloseListenSocket();
                return r;
            }
        }
        return 0;
    }
 
    void m_CloseListenSocket(void)
    {
        if ( m_soListen != INVALID_SOCKET )
        {
            SOCKET so = m_soListen;
            m_soListen = INVALID_SOCKET;
            TTRACE0("CSocket[Server]:リスナーSOCKETクローズ\n");
            ::shutdown(so, SD_BOTH);
            ::closesocket(so);
        }
    }
 
    virtual DWORD Run(void)
    {
        while ( IsRunnable() )
        {
            if ( m_OpenListenSocket() != 0 )
            {
                loop ( i, 20 )
                {
                    if ( ! IsRunnable() )
                    {
                        break;
                    }
                    ::Sleep(E_RetryDelay / 20);
                }
                continue;
            }
            //
            CTickCount tickIdle;
            CTickCount tickConCheck;
            while ( IsRunnable() )
            {
                fd_set tFdSet;
                FD_ZERO(&tFdSet);
                CSocketVector vsoBack;
                INT_PTR iConnectedCount = GetConnectedSockets(&vsoBack);
                if ( iConnectedCount > 0 )
                {
                    loop ( i, iConnectedCount )
                    {
                        FD_SET(vsoBack[i], &tFdSet);
                    }
                }
                if ( m_soListen != INVALID_SOCKET )
                {
                    FD_SET(m_soListen, &tFdSet);
                }
                int iSelTime = E_SelectTimeout;
                int iInterval = _super::GetIdleInterval();
                if ( iInterval > 0 )
                {
                    iSelTime = iInterval;
                }
                timeval tTimeVal = { iSelTime / 1000, iSelTime % 1000 };
                if ( ::select(FD_SETSIZE, &tFdSet, NULL, NULL, &tTimeVal) == SOCKET_ERROR )
                {
                    DWORD dwError = ::WSAGetLastError();
                    TRACE1( "::select() error = %d\n", dwError );
                    if ( dwError == WSAEINVAL )
                    {
                        ::Sleep(E_SelectTimeout);
                    }
                    continue;
                }
                if ( FD_ISSET(m_soListen, &tFdSet) )
                {
                    FD_CLR(m_soListen, &tFdSet);
                    TSockAddr addrFrom;
                    int iFromlen = addrFrom.GetSize();
                    SOCKET so = ::accept(m_soListen, addrFrom, &iFromlen);
                    if ( so == INVALID_SOCKET )
                    {
                        TRACE2( "::accept(%d) error = %d\n", m_soListen, ::WSAGetLastError() );
                        m_CloseListenSocket();
                    }
                    else if ( m_vsoData.GetSize() >= m_connectMax )
                    {
                        TTRACE1( "CSocket[Server%d]:接続依頼、拒否\n", so );
                        m_CloseListenSocket();
                        ::shutdown(so, SD_BOTH);
                        ::closesocket(so);
                    }
                    else
                    {
                        TTRACE1("CSocket[Server%d]:接続\n", so);
                        ms_SetDelayMode(so, m_boIsDelay);
                        {
                            EXCLUSIVE(&m_syncSocket);
                            m_vsoData.AddEx(so);
                            if ( m_vsoData.GetSize() >= m_connectMax )
                            {
                                m_CloseListenSocket();
                            }
                        }
                        if ( ! m_OnSocketEvent(CSocketEvent(this, so, ReportEvent_Connect)) )
                        {
                            TTRACE1("CSocket[Server%d]:切断\n", so);
                            m_CloseDataSocket(so);
                            m_OpenListenSocket();
                        }
                    }
                }
                if ( iConnectedCount == 0 )
                {
                    continue;
                }
                if ( tFdSet.fd_count == 0 )
                {
                    if ( tickConCheck.IsPassedAndReset(E_SelectTimeout) )
                    {
                        CSocketAddress adds;
                        loop ( i, iConnectedCount )
                        {
                            if ( ! m_GetPeerName(adds, vsoBack[i]) )
                            {
                                m_CloseDataSocket(vsoBack[i]);
                                m_OpenListenSocket();
                            }
                        }
                    }
                    if ( iInterval > 0 && tickIdle.IsPassedAndReset(iInterval) )
                    {
                        loop ( i, iConnectedCount )
                        {
                            if ( ! m_OnSocketEvent(CSocketEvent(this, vsoBack[i], ReportEvent_Idle)) )
                            {
                                TTRACE1("CSocket[Server%d]:切断\n", vsoBack[i]);
                                m_CloseDataSocket(vsoBack[i]);
                                m_OpenListenSocket();
                            }
                        }
                    }
                    continue;
                }
                //
                loop ( i, iConnectedCount )
                {
                    if ( ! FD_ISSET(vsoBack[i], &tFdSet) )
                    {
                        continue;
                    }
                    if ( ! m_Recv(vsoBack[i]) )
                    {
                        TTRACE1("CSocket[Server%d]:切断(Recvによる)\n", vsoBack[i]);
                        m_CloseDataSocket(vsoBack[i]);
                        m_OpenListenSocket();
                    }
                    else
                    {
                        TTRACE1("CSocket[Server%d]:データ受信\n", vsoBack[i]);
                    }
                }
                tickIdle.Reset();
            }
        }
        m_OnSocketEvent(CSocketEvent(this, 0, ReportEvent_End));
        return 0;
    };
};
 
 
 
}; // TNB