cNetSocket.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cNetSocket_H
#define _INC_cNetSocket_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cNetAddr.h"
#include "../WinAPI/WinTypes.h"
#include "GrayCore/include/cStream.h"
#include "GrayCore/include/HResult.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cNonCopyable.h"
#include "GrayCore/include/cAppState.h"
 
#ifdef __linux__
typedef int SOCKET; // same as HANDLE and cOSHandle
#define INVALID_SOCKET  (SOCKET)(~0)
#define SOCKET_ERROR    (-1)
#endif  // __linux__
 
#ifdef USE_MFC_SOCKET
#include <afxsock.h> // MFC socket extensions
#endif
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cNetSocket);
 
        typedef int IPPROTO_TYPE;       
 
        enum SOCKETSTATE_TYPE
        {
 
                SOCKETSTATE_Undefined = 0,      
                SOCKETSTATE_Created,            
                SOCKETSTATE_Bound,                      
                SOCKETSTATE_Listening,          
                SOCKETSTATE_Connecting,         
                SOCKETSTATE_Established,        
                SOCKETSTATE_Closing,            
                SOCKETSTATE_Disconnected,       
                SOCKETSTATE_Error,                      
        };
 
        enum SOCKET_ShutDown_TYPE { SOCKET_ShutDown_receives = 0, SOCKET_ShutDown_sends = 1, SOCKET_ShutDown_both = 2 };
 
#ifndef USE_MFC_SOCKET
        class GRAYLIB_LINK cNetSocketBase
                : public CObject
                , public cNonCopyable
        {
 
        public:
                static ITERATE_t sm_iAllocSockets;      
 
        protected:
#ifdef _WIN32
                SOCKET m_hSocket;       
#elif defined(__linux__)
                cOSHandle m_hSocket;    
#else 
#error NOOS
#endif
 
        protected:
 
                SOCKET get_HSocket() const noexcept
                {
#ifdef _WIN32
                        return m_hSocket;
#elif defined(__linux__)
                        return m_hSocket.get_Handle();
#endif
                }
 
                bool Connect(const struct sockaddr* pAddr, socklen_t nAddrLen)
                {
                        return(::connect(get_HSocket(), pAddr, nAddrLen) == 0);
                }
 
                bool ShutDown(SOCKET_ShutDown_TYPE nHow = SOCKET_ShutDown_sends)
                {
                        if (::shutdown(get_HSocket(), (int)nHow) == SOCKET_ERROR)
                                return false;
                        return true;
                }
 
        public:
                cNetSocketBase();
                virtual ~cNetSocketBase();
 
                virtual bool isValidCheck() const noexcept; // override
                bool isValidSocket() const noexcept
                {
#ifdef _WIN32
                        if (m_hSocket == INVALID_SOCKET || m_hSocket == (SOCKET)HANDLE_NULL)    // illegal value for _WIN32.
                                return false;
#elif defined(__linux__)
                        if (!m_hSocket.isValidHandle())
                                return false;
#endif
                        return true;
                }
                operator SOCKET() const noexcept
                {
                        return get_HSocket();
                }
 
                bool AttachSocket(SOCKET hSocket);
                SOCKET DetachSocket();
 
                virtual void Close();
 
                bool Listen(int iMaxBacklogConnections = SOMAXCONN)
                {
                        ASSERT(isValidSocket());
                        return ::listen(get_HSocket(), iMaxBacklogConnections) == 0;
                }
 
                int Send(const void* pData, int iLen, int nFlags = 0)
                {
 
                        ASSERT(isValidSocket());
#ifdef __linux__
                        nFlags |= MSG_NOSIGNAL; // Get rid of the SIGPIPE signal for this talking to disconnected sockets. (ESIGNAL)
#endif
                        int iRet = ::send(get_HSocket(), (char*)pData, iLen, nFlags);
                        return iRet;
                }
                int Receive(void* pBuffer, int nBufLen, int nFlags = 0)
                {
                        ASSERT(isValidSocket());
                        int iRet = ::recv(get_HSocket(), (char*)pBuffer, nBufLen, nFlags);
                        return iRet;
                }
 
                bool IOCtl(long lCmd, unsigned long* pnArgs) const;
                bool SetSockOpt(int nOptionName, const void* optval, socklen_t optlen, int nLevel = SOL_SOCKET) const;
                bool GetSockOpt(int nOptionName, void* optval, socklen_t* pOptLen, int nLevel = SOL_SOCKET) const;
        };
 
#endif // ! USE_MFC_SOCKET
 
        //*******************************************************************************
 
        class GRAYLIB_LINK cNetSocket
                : public cNetSocketBase // Emulate MFC
                , public cStream        // Seek() NOT implemented/supported.
        {
 
                typedef cNetSocketBase SUPER_t;
                typedef cNetSocket THIS_t;
 
        public:
                SOCKETSTATE_TYPE m_eState;      
#ifdef _WIN32
                bool m_bBlockingMode;   
#if ! defined(UNDER_CE)
                HWND m_hWndAsync;       
#endif
#endif
 
        public:
                cNetSocket();
                cNetSocket(SOCKET hSocket);
                cNetSocket(const cNetSocket& src);
                virtual ~cNetSocket();
 
                cNetSocket& operator =(const cNetSocket& src)
                {
                        AttachSocket(src);
                        return *this;
                }
 
                virtual void Close() override;
                bool AttachSocket(SOCKET hSocket, long lEvent = 0);
 
#ifdef USE_MFC_SOCKET
                SOCKET DetachSocket()
                {
                        return SUPER_t::Detach();
                }
#endif
 
                HRESULT BindAddr(const cNetAddress& SockAddr)
                {
                        ASSERT(isValidSocket());
#ifdef USE_MFC_SOCKET
                        if (!SUPER_t::Bind(&SockAddr.ref_Addr(), SockAddr.get_AddrLen()))
#else
                        int iRet = ::bind(m_hSocket, &SockAddr.get_Addr(), SockAddr.get_AddrLen());
                        if (iRet != 0)
#endif
                        {
                                // Can't bind. port might already be used ? or socket already bound?
                                return GetLastErrorDef();
                        }
                        m_eState = SOCKETSTATE_Bound;
                        return S_OK;
                }
 
                bool Listen(int iMaxBacklogConnections = SOMAXCONN)
                {
                        ASSERT(isValidSocket());
                        if (!SUPER_t::Listen(iMaxBacklogConnections))
                        {
                                return false;
                        }
                        m_eState = SOCKETSTATE_Listening;
                        return true;
                }
 
                HRESULT ConnectAddr(const cNetAddress& rSockAddr);
                HRESULT Accept(OUT cNetSocket& rConnectedSocket, OUT cNetAddress* pConnectedSocketAddr=nullptr);
 
                //***************************************************************************************
 
                HRESULT CreateSocket(sa_family_t nAddressFamily = AF_INET, int nSocketType = SOCK_STREAM, IPPROTO_TYPE nProtocolType = IPPROTO_TCP);
 
                HRESULT CreateConnect(const cNetAddress& SockAddr, int nSocketType = SOCK_STREAM, IPPROTO_TYPE nProtocolType = IPPROTO_TCP);
                HRESULT CreateConnect(const cNetAddressArray& rSockAddrs, int nSocketType = SOCK_STREAM, IPPROTO_TYPE nProtocolType = IPPROTO_TCP);
 
                HRESULT CreateBind(const cNetAddress& SockAddr, int nSocketType = SOCK_STREAM, IPPROTO_TYPE nProtocolType = IPPROTO_TCP);
                HRESULT CreateBindFirst(const cNetAddressArray& rSockAddrs, int nSocketType = SOCK_STREAM, IPPROTO_TYPE nProtocolType = IPPROTO_TCP);
 
                HRESULT CloseFlush(TIMESECD_t tWait = 1);
 
                static inline HRESULT GetLastError()
                {
                        return cNetSystem::GetLastError();
                }
                static inline HRESULT GetLastErrorDef(HRESULT hResDef = E_FAIL) // static
                {
                        return cNetSystem::GetLastErrorDef(hResDef);
                }
 
#ifdef USE_MFC_SOCKET
                bool isValidSocket() const noexcept
                {
                        if (m_hSocket == INVALID_SOCKET)        // -1 is not valid.
                                return false;
                        if (m_hSocket == (SOCKET)HANDLE_NULL)   // 0 is never a valid handle value. ASSUME _WIN32
                                return false;
                        return true;
                }
#endif
 
                bool isConnecting() const noexcept
                {
                        if (m_eState == SOCKETSTATE_Connecting)
                        {
                                DEBUG_CHECK(isValidSocket());
                                return true;
                        }
                        return false;
                }
                bool isConnected() const noexcept
                {
                        if (m_eState == SOCKETSTATE_Established)
                        {
                                DEBUG_CHECK(isValidSocket());
                                return true;
                        }
                        return false;
                }
                bool isConnected2() const noexcept
                {
                        if (m_eState == SOCKETSTATE_Established || m_eState == SOCKETSTATE_Connecting)
                        {
                                DEBUG_CHECK(isValidSocket());
                                return true;
                        }
                        return false;
                }
                void SetStateEstablished() noexcept
                {
                        DEBUG_CHECK(isValidSocket());
                        m_eState = SOCKETSTATE_Established;
                        // ASSERT(isConnected());
                }
 
                SOCKET get_HSocket() const noexcept
                {
                        return m_hSocket;
                }
                HASHCODE_t get_HashCode() const noexcept
                {
                        DEBUG_CHECK(isValidSocket());
                        return (HASHCODE_t)m_hSocket;
                }
 
                //****************************
                // A connection is present.
 
                bool GetAddrSock(OUT cNetAddress& SockAddr) const;
                bool GetAddrPeer(OUT cNetAddress& SockAddr) const;
 
                HRESULT SendTo(const void* pData, size_t iLen, const cNetAddress& SockAddr, int nFlags = 0);
                HRESULT ReceiveFrom(void* pBuffer, size_t nBufLen, cNetAddress& SockAddr, int nFlags = 0);
 
                cNetAddress get_AddrSock() const;       // get the local side of the connection.
                cNetAddress get_AddrPeer() const;       // get the far side of the connection.
 
                bool isBlockingMode() const;    // FIONBIO set ?
                bool put_BlockingMode(bool bBlock);     // FIONBIO
                bool put_BlockingTimeoutRx(TIMESECD_t tSec);
                bool put_BlockingTimeoutTx(TIMESECD_t tSec);
 
                bool put_Nagle(bool bDelay);            // TCP_NODELAY
                bool put_KeepAlive(bool bKeepAlive);
                bool put_Async(bool bAsync);            // FIOASYNC
                bool put_ReuseAddr(bool bReuse);
 
                int get_BufferSizeRx() const;
                bool put_BufferSizeRx(int iSize);
                int get_BufferSizeTx() const;
                bool put_BufferSizeTx(int iSize);
                int get_ReadReady() const;                      // FIONREAD
 
                // cStream support
                virtual HRESULT WriteX(const void* pData, size_t nDataSize) override;
                virtual HRESULT ReadX(void* pData, size_t nDataSize) override;
                virtual HRESULT ReadPeek(void* pData = nullptr, size_t nDataSize = 1) override;
 
#if defined(_WIN32) && ! defined(UNDER_CE)
                bool AsyncAccept(cNetSocket& socknew, cNetAddress& rAddr, LPCONDITIONPROC pfnCondition, DWORD_PTR dwCallbackData = 0);
                bool AsyncSelect(HWND hWnd, WINMSG_t uMsg, UINT dwEventMask = FD_CONNECT | FD_READ | FD_WRITE | FD_CLOSE);
#endif
 
                UNITTEST_FRIEND(cNetSocket);
        };
};
#endif // _INC_cNetSocket_H