socketex.cpp

C++ patterns设计模式

            // update the current pointer, and counter
            bs.m_cur = pos;
            bs.m_cnt -= (pos-beg);
            if(pos != end)
            {
                // "eof" found
                // advance the counter for the length of "eof".
                bs.m_cnt -= (eofEnd-eofBeg);
                bs.m_cur += (eofEnd-eofBeg);
                break;
            }
        }
        return line.size();
	}

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : isSelected
    // Description         : check whether the socket in a fd_set
    // Input Parameters    : fds -- the fd_set
    // Return Value        : true/false
    //////////////////////////////////////////////////////////////////////////////
    bool AbstractSocket::isSelected(fd_set *fds) const
    {
        assert(m_socket!=INVALID_SOCKET);
        return FD_ISSET(m_socket, fds) == 1;
    }

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : setSelect
    // Description         : set the socket into a fd_set
    // Input Parameters    : fds -- the fd_set
    //////////////////////////////////////////////////////////////////////////////
    void AbstractSocket::setSelect(fd_set *fds) const
    {
        assert(m_socket!=INVALID_SOCKET);
        FD_SET(m_socket, fds);
    }

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : setSption
    // Description         : set SOCKET option
    // Input Parameters    : like the API
    // Return Value        : true/false
    //////////////////////////////////////////////////////////////////////////////
    bool AbstractSocket::setOption(int optname, void *optval, int optlen, int level/* = SOL_SOCKET*/) const
    {
        assert(m_socket!=INVALID_SOCKET);
		return (::setsockopt(m_socket, level, optname, (char *)optval, optlen) != SOCKET_ERROR);
    }

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : getSption
    // Description         : get the SOCKET option
    // Input Parameters    : like the API
    // Return Value        : true/false
    //////////////////////////////////////////////////////////////////////////////
    bool AbstractSocket::getOption(int optname, void *optval, int *optlen,int level /*= SOL_SOCKET*/) const
    {
        assert(m_socket != INVALID_SOCKET);
		return (::getsockopt(m_socket, level, optname, (char *)optval, (socklen_t*)optlen) != SOCKET_ERROR);
    }

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : isValid
    // Description         : check whether socket is valid
    // Return Value        : yes/no
    //////////////////////////////////////////////////////////////////////////////
    bool AbstractSocket::isValid() const
    {
        return m_socket != INVALID_SOCKET;
    }

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : recvReady
    // Description         : select to see can we read now
    // Input Parameters    : tv -- the select timeval
    // Return Value        : yes/no
    //////////////////////////////////////////////////////////////////////////////
    bool AbstractSocket::recvReady(const timeval *tv) const
    {
        assert(m_socket!=INVALID_SOCKET);

        fd_set fd_recv;
        FD_ZERO(&fd_recv);
        FD_SET(m_socket, &fd_recv);

        int ret = ::select(0, &fd_recv, NULL, NULL, (timeval*)tv);
        if(ret == 1)
            return true;
        else
            return false;
    }

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : sendReady
    // Description         : select to see can we send now
    // Input Parameters    : tv -- the select timeval
    // Return Value        : yes/no
    //////////////////////////////////////////////////////////////////////////////
    bool AbstractSocket::sendReady(const timeval *tv) const
    {
        assert(m_socket!=INVALID_SOCKET);

        fd_set fd_send;
        FD_ZERO(&fd_send);
        FD_SET(m_socket, &fd_send);

        int ret = ::select(1, NULL, &fd_send, NULL, (timeval*)tv);
        if(ret == 1)
            return true;
        else
            return false;
    }
    
    DWORD AbstractSocket::getError() const
    {
#ifdef __linux__
        return errno;
#else
        return ::GetLastError();
#endif
    }

    ///////////////////////////////////////////////////////////////////////////

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : ctor
    //////////////////////////////////////////////////////////////////////////////
    ClientSocket::ClientSocket()
        : AbstractSocket(TCP_SOCKET)
		, m_connected(false)
    {
		create();
    }

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : ctor
    // Description         : create from specail server address
    //////////////////////////////////////////////////////////////////////////////
    ClientSocket::ClientSocket(const SocketAddress &serverAddress)
        : AbstractSocket(TCP_SOCKET)
        , m_severAddress(serverAddress)
		, m_connected(false)
    {
    }

	void ClientSocket::setServerAddress(const SocketAddress &serverAddress)
	{
		m_severAddress = serverAddress;
	}

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : connect
    // Description         : connect to server, object must create with a server address
    // Return Value        : connect ok/failed
    //////////////////////////////////////////////////////////////////////////////
    bool ClientSocket::connect()
    {
		if(isConnected())
			disconnect();
		// if SOCKET not created yet! create it first!
        if(isValid() || create())
        {
            if(m_severAddress.connectWith(m_socket))
				m_connected = true;
        }
		return m_connected;
    }

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : connect
    // Description         : connect to server, this method offer the server address
    //                       and it will cover the original server address(if exist)
    // Input Parameters    : serverAddress -- the server address
    // Return Value        : connect ok/failed
    //////////////////////////////////////////////////////////////////////////////
    bool ClientSocket::connect(const SocketAddress &serverAddress)
    {
        m_severAddress = serverAddress;
        return connect();
    }
    
	//////////////////////////////////////////////////////////////////////////////
    // Function Name       : disconnect
    // Description         : disconnect from the server, socket will be close.
    //////////////////////////////////////////////////////////////////////////////
    void ClientSocket::disconnect()
    {
        m_connected = false;
        AbstractSocket::close();
    }

    ///////////////////////////////////////////////////////////////////////////

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : ctor
    //////////////////////////////////////////////////////////////////////////////
    AcceptedSocket::AcceptedSocket()
        : AbstractSocket(TCP_SOCKET)
    {
    };

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : ctor
    //////////////////////////////////////////////////////////////////////////////
    AcceptedSocket::AcceptedSocket(SOCKET sock)
        : AbstractSocket(TCP_SOCKET)
    {
        attach(sock);
    };

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : attach
    // Description         : attach a accepted socket
    // Input Parameters    : sock -- the socket
    //////////////////////////////////////////////////////////////////////////////
    void AcceptedSocket::attach(SOCKET sock)
    {
        //attach the socket to AbsSocket at first
        AbstractSocket::attach(sock);
        //and then get the remote address and port
        if(isValid())
        {
            //get the peer name from the connected socket
            sockaddr_in peer_addr;
            int      addr_len = sizeof(sockaddr);
			::getpeername(m_socket, (sockaddr *)&peer_addr, (socklen_t*)&addr_len);
            m_peerAddress.directCreate(peer_addr);
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : ctor
    //////////////////////////////////////////////////////////////////////////////
    ServerSocket::ServerSocket()
        : AbstractSocket(TCP_SOCKET)
		, m_binded(false)
    {
    };

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : ctor
    //////////////////////////////////////////////////////////////////////////////
    ServerSocket::ServerSocket(const SocketAddress &addr)
        : AbstractSocket(TCP_SOCKET)
        , m_serviceAddress(addr)
    {
    }

	void ServerSocket::setServiceAddress(const SocketAddress &serviceAddress)
	{
		m_serviceAddress = serviceAddress;
	}

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : bind
    // Description         : 
    // Input Parameters    : 
    // Return Value        : 
    // Ext Function called : 
    //////////////////////////////////////////////////////////////////////////////
    bool ServerSocket::bind()
    {
		if(isBinded())
			unbind();
		// if SOCKET not created yet! create it first!
        if(isValid() || create())
        {
            if( m_serviceAddress.bindWith(m_socket) &&
                ::listen(m_socket, LISTEN_SIZE) != SOCKET_ERROR)
            {
                //the the server socket option
                BOOL alive  = TRUE;
                setOption(SO_KEEPALIVE, (char *)&alive, sizeof(alive));
                //set the SO_REUSEADDR socket parameter
                BOOL reuseaddr = TRUE;
                setOption(SO_REUSEADDR, (char *)&reuseaddr, sizeof(reuseaddr));
				m_binded = true;
                return true;
            }
        }
        return false;
    }

	//////////////////////////////////////////////////////////////////////////////
	// Function Name       : bind
	// Description         : 
	// Input Parameters    : 
	// Return Value        : 
	// Ext Function called : 
	//////////////////////////////////////////////////////////////////////////////
	bool ServerSocket::bind(const SocketAddress &addr)
	{
		m_serviceAddress = addr;
		return bind();
	}

	void ServerSocket::unbind()
	{
		m_binded = false;
		AbstractSocket::close();
	}

    //////////////////////////////////////////////////////////////////////////////
    // Function Name       : accept
    // Description         : 
    // Input Parameters    : 
    // Return Value        : 
    // Ext Function called : 
    //////////////////////////////////////////////////////////////////////////////
    AcceptedSocket ServerSocket::accept()
    {
        struct sockaddr_in  peer_addr;
        memset(&peer_addr, 0, sizeof(peer_addr));
        int	   addrlen = sizeof(sockaddr_in);
        return AcceptedSocket(::accept(m_socket, (sockaddr *)&peer_addr, (socklen_t*)&addrlen));
	}
}