TnbSocketUdp.h

[詳解]

#pragma once
#include "TnbSocket.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CSocketUdp : public CAbstractSocket, TNB::CThread::IRunner
{
    DEFSUPER(CAbstractSocket);
public:
 
    CSocketUdp(void) : _super(), m_isStopping(false), m_soData(INVALID_SOCKET), m_isBroadcast(-1), m_bufferSize(0), m_isAddressBroadcast(false)
    {
        m_threadReceiver.SetRunner(this);
        m_addrFrom.Init();
    }
 
    virtual ~CSocketUdp(void)
    {
        Stop();
    }
 
    virtual CStr GetReportName(void) const 
    {
        return CStr::Fmt(_T("SocketUDP[%u]:"), m_baseAddress.GetPortNo());
    }
 
    virtual DWORD GetReportID(void) const 
    {
        return TNBVIW_KIND_SOCK_U + m_baseAddress.GetPortNo();
    }
 
    SOCKET GetSocket(void) const
    {
        return m_soData;
    }
 
    WORD GetMaxDatagram(void)
    {
        WORD w = m_GetMaxUdpDg(m_soData);
        if ( w == 0 )
        {
            w = 1500;
        }
        return w;
    }
 
    void SetBaseAddress(const CSocketAddress& address)
    {
        StartUp();
        Stop();
        m_baseAddress = address;
    }
 
    const CSocketAddress& GetBaseAddress(void) const
    {
        return m_baseAddress;
    }
 
    virtual bool Start(void)
    {
        StartUp();
        Stop();
        // 自分用ソケット構造体の初期化
        TSockAddr addr;
        addr.Init();
        addr.sin_family = AF_INET;          // TCP/IPを指定
        m_baseAddress.Get(addr);
        // UDP オープン
        SOCKET so = ::socket(AF_INET, SOCK_DGRAM, 0);
        if ( so == SOCKET_ERROR ) 
        {
            TRACE1( "::socket() error = %d\n", ::WSAGetLastError() );
            return false;
        }
        if ( ::bind(so, addr, addr.GetSize()) == SOCKET_ERROR )
        {
            TRACE1( "::bind() error = %d\n", ::WSAGetLastError() );
            ::closesocket(so);
            return false;
        }
        m_soData = so;
        m_isBroadcast = -1;
        // 受信スレッド開始
        if ( m_baseAddress.GetPortNo() != 0 )
        {
            m_bufferSize = GetMaxDatagram();
            ASSERTLIB(m_bufferSize > 0);        
            delete m_lpcBuffer;
            m_lpcBuffer = new char[m_bufferSize];
            ASSERTLIB(m_lpcBuffer != NULL);     
            #ifdef _DEBUG
                m_threadReceiver.Start(CStr::Fmt(_T("SocketUDP[%u]監視"), m_baseAddress.GetPortNo()));
            #else
                m_threadReceiver.Start();
            #endif
        }
        return true;
    }
 
    virtual bool IsAlive(void) const 
    {
        return m_soData != INVALID_SOCKET; 
    }
    
    virtual bool IsConnect(void) const
    {
        return m_soData != INVALID_SOCKET; 
    }
 
    const CSocketAddress& GetAddressee(void) const
    {
        return m_addressee;
    }
 
    bool SetAddressee(const CSocketAddress& address)
    {
        m_addressee = address;
        m_isAddressBroadcast = false;
        return m_SetAddress(address);
    }
 
    void SetBroadcastPort(WORD portNo, DWORD address = INADDR_BROADCAST)
    {
        CSocketAddress a(portNo, address);
        m_addressee = a;
        m_isAddressBroadcast = true;
        m_SetAddress(a);
    }
 
    virtual bool Send(size_t dataSize, LPCVOID lpcvData)
    {
        _super::m_OnSend(dataSize, lpcvData);
        return m_Send(m_soData, dataSize, lpcvData);
    }
 
    virtual void Stop(void)
    {
        m_isStopping = true;
        m_CloseDataSocket();
        m_threadReceiver.Stop();
        if ( IsConnect() )
        {
            m_CloseDataSocket();
        }
        m_isStopping = false;
    }
 
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_threadReceiver;
    }
 
    CThreadStatus& GetReceiveThreadStatus(void)
    {
        return m_threadReceiver;
    }
 
    size_t GetReceivedBufferSize(void) const
    {
        int len = 0;
        int lenlen = sizeof(len);
        int r = ::getsockopt(m_soData, SOL_SOCKET, SO_RCVBUF, reinterpret_cast<char *>(&len), &lenlen);
        return static_cast<size_t>((r == SOCKET_ERROR) ? 0 : len);
    }
 
    bool SetReceivedBufferSize(size_t size)
    {
        if ( size < INT_MAX )
        {
            int len = ToInt(size);
            int r = ::setsockopt(m_soData, SOL_SOCKET, SO_RCVBUF, reinterpret_cast<char *>(&len), sizeof(len));
            if ( r != SOCKET_ERROR )
            {
                return size == GetReceivedBufferSize();
            }
        }
        return false;
    }
 
    static bool WakeupOnLan(const BYTE* pbMacAddr)
    {
        CSocketUdp udp;
        udp.Start();
        udp.SetBroadcastPort(7);
        ASSERTLIB( udp.GetAddressee().GetPortNo() == 7 );
        const int MACSIZE = 6;
        const int MACLOOP = 16;
        char sendbuf[MACLOOP * MACSIZE + MACSIZE];
        //  送信データ作成
        ::FillMemory(&sendbuf[0], MACSIZE, 0xFF);
        loop ( i, MACLOOP )
        {
            ::CopyMemory(&sendbuf[MACSIZE + i * MACSIZE], pbMacAddr, MACSIZE);
        }
        return udp.Send(MACLOOP * MACSIZE + MACSIZE, sendbuf);
    }
 
protected:
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    virtual bool m_GetPeerName(CSocketAddress& _address, SOCKET so)
    {
        _address.Set(m_addrFrom);
        return true;
    }
    virtual bool m_Send(SOCKET so, size_t dataSize, LPCVOID lpcvData)
    {
        BOOL isAddressBroadcast = m_isAddressBroadcast;
        if ( m_isBroadcast != (!! isAddressBroadcast) )
        {
            ::setsockopt(so, SOL_SOCKET, SO_BROADCAST, reinterpret_cast<char *>(&isAddressBroadcast), sizeof(isAddressBroadcast));
            m_isBroadcast = !! isAddressBroadcast;
        }
        int iRc = ::sendto(so, static_cast<const char*>(lpcvData), ToInt(dataSize), 0, m_sockaddrPartner, TSockAddr::GetSize());
        TRACE3( "::sendto(%u) result = %d error = %d\n", dataSize, iRc, ::WSAGetLastError() );
        return iRc == ToInt(dataSize);
    }
    #endif // _TnbDOXYGEN
 
private:
    void m_CloseDataSocket(void)
    {
        if ( m_soData != INVALID_SOCKET )
        {
            SOCKET so = m_soData;
            m_soData = INVALID_SOCKET;
            TRACE1( "SocketUDP[%u]:Closed\n", m_baseAddress.GetPortNo() );
            ::closesocket(so);
        }
    }
    virtual DWORD Run(void)
    {
        if ( m_OnSocketEvent(CSocketEvent(this, m_soData, ReportEvent_Connect)) )
        {
            CTickCount tickIdle;
            while ( IsRunnable() )
            {
                int iInterval = _super::GetIdleInterval();
                if ( iInterval > 0 )
                {
                    fd_set tFdSet;
                    FD_ZERO(&tFdSet);
                    FD_SET(m_soData, &tFdSet);
                    int iSelTime = iInterval;
                    timeval tTimeVal = { iSelTime / 1000, iSelTime % 1000 };
                    ::select(ToInt(m_soData + 1), &tFdSet, NULL, NULL, &tTimeVal);
                    if ( ! FD_ISSET(m_soData, &tFdSet) )
                    {
                        //== データなし
                        if ( iInterval > 0 && tickIdle.IsPassedAndReset(iInterval) )
                        {
                            if ( ! m_OnSocketEvent(CSocketEvent(this, m_soData, ReportEvent_Idle)) )
                            {
                                break;  //切断
                            }
                        }
                        continue;
                    }
                }
                TTRACE1( "SocketUDP[%u]:受信\n", m_baseAddress.GetPortNo() );
                int iFromLen = m_addrFrom.GetSize();
                int iLen = ::recvfrom(m_soData, m_lpcBuffer, ToInt(m_bufferSize), 0, m_addrFrom, &iFromLen);
                if ( iLen == SOCKET_ERROR )
                {
                    if ( ! m_isStopping )
                    {
                        int iError = ::WSAGetLastError();
                        TRACE2( "::recv(%d) error = %d\n", m_soData, iError );
                        if ( ! m_OnSocketEvent(CSocketEvent(this, m_soData, ReportEvent_Error, iError)) )
                        {
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                else if ( iLen != 0 )
                {
                    CSocketEvent s(this, m_soData);
                    s.SetData(iLen, m_lpcBuffer);
                    if ( ! m_OnSocketEvent(s) )
                    {
                        break;
                    }
                }
                else
                {
                    //データ無し
                }
                tickIdle.Reset();
            }
            m_OnSocketEvent(CSocketEvent(this, m_soData, ReportEvent_Disconnect));
        }
        m_OnSocketEvent(CSocketEvent(this, m_soData, ReportEvent_End));
        return 0;
    }
    CThread         m_threadReceiver;       
    SOCKET          m_soData;               
    CSocketAddress  m_baseAddress;          
    CSocketAddress  m_addressee;            
    bool            m_isAddressBroadcast;   
    TSockAddr       m_addrFrom;             
    BOOL            m_isBroadcast;          
    size_t          m_bufferSize;           
    bool            m_isStopping;           
};
 
 
 
class CSocketUdpEx : public CSocketUdp
{
    DEFSUPER(CSocketUdp);
public:
 
    #pragma pack(push)
    #pragma pack(1)
    struct TDataHeader
    {
        DWORD           ipAddress;      
        WORD            portNo;         
        TDataHeader(WORD pn = 0, DWORD ip = 0) : ipAddress(ip), portNo(pn)
        {
        }
        TDataHeader(const CSocketAddress& addr)
        {
            operator=(addr);
        }
        operator CSocketAddress() const
        {
            return CSocketAddress(portNo, ipAddress);
        }
        void operator=(const CSocketAddress& addr)
        {
            ipAddress = addr.GetAddress();
            portNo = addr.GetPortNo();
        }
    };
    #pragma pack(pop)
 
 
    //---
 
 
    CSocketUdpEx(void)
    {
    }
 
    bool Broadcast(size_t dataSize, LPCVOID lpcvData)
    {
        _super::m_OnSend(dataSize, lpcvData);
        C_ASSERT( sizeof(TDataHeader) == 6 );
        if ( dataSize < sizeof(TDataHeader) )
        {
            return false;
        }
        const TDataHeader* p = static_cast<const TDataHeader*>(lpcvData);
        TDataHeader h = AdjustDataHeader(*p);
        if ( p->ipAddress == 0 )
        {
            _super::SetBroadcastPort(h.portNo);
        }
        else
        {
            _super::SetBroadcastPort(h.portNo, p->ipAddress);
        }
        const BYTE* b = static_cast<const BYTE*>(lpcvData);
        return m_Send(_super::GetSocket(), dataSize - sizeof(TDataHeader), &b[sizeof(TDataHeader)]);
    }
 
    virtual bool Send(size_t dataSize, LPCVOID lpcvData)
    {
        _super::m_OnSend(dataSize, lpcvData);
        C_ASSERT( sizeof(TDataHeader) == 6 );
        if ( dataSize < sizeof(TDataHeader) )
        {
            return false;
        }
        const TDataHeader* p = static_cast<const TDataHeader*>(lpcvData);
        TDataHeader h = AdjustDataHeader(*p);
        CSocketAddress sa(h.portNo, h.ipAddress);
        //
        EXCLUSIVE( &m_syncSend );
        _super::SetAddressee(sa);
        const BYTE* b = static_cast<const BYTE*>(lpcvData);
        return m_Send(_super::GetSocket(), dataSize - sizeof(TDataHeader), &b[sizeof(TDataHeader)]);
    }
 
    TDataHeader AdjustDataHeader(const TDataHeader& h) const
    {
        TDataHeader dh = h;
        if ( dh.ipAddress == 0 )
        {
            dh.ipAddress = _super::GetAddressee().GetAddress();;
        }
        if ( dh.portNo == 0 )
        {
            dh.portNo = _super::GetAddressee().GetPortNo();
        }
        return dh;
    }
 
protected:
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    virtual bool m_OnSocketEvent(CSocketEvent& e)
    {
        CWorkMem w;
        CSocketEvent se = e;
        if ( se.HasData() )
        {
            w.Resize(sizeof(TDataHeader) + se.GetDataSize());
            BYTE* b = w.Ref();
            TDataHeader* h = reinterpret_cast<TDataHeader*>(b);
            CSocketAddress sa;
            e.GetPeerName(sa);
            h->ipAddress = sa.GetAddress();
            h->portNo = sa.GetPortNo();
            memcpy(&b[sizeof(TDataHeader)], e.GetData(), e.GetDataSize());
            se.SetData(w.GetSize(), w);
        }
        return _super::m_OnSocketEvent(se);
    }
    #endif // _TnbDOXYGEN
 
private:
    CSyncSection        m_syncSend;     
//  DWORD               m_defaultAddr;  ///< デフォルトアドレス
//  WORD                m_defaultPort;  ///< デフォルトポート
};
 
 
 
};