socketex.h

C++ patterns设计模式

////////////////////////////////////////////////////////////////////////////////
// ACL
////////////////////////////////////////////////////////////////////////////////
// Author      : 黎达文                                                        
// Description : abstract socket
//
// Version     : 2.0
//
// Standard include files : 
//
// Start Date  : 2003年8月16日
//
// Change Log  : 
// 2003年8月16日 by 黎达文 -- Created
// 2004年9月7日 by 黎达文
// 修改BufferedSocket名字为BufferedSocket
////////////////////////////////////////////////////////////////////////////////

#ifndef INCLUDED_SOCKETEX_H
#define INCLUDED_SOCKETEX_H

#if defined(HAS_PRAGMA_ONCE)
#pragma PRAGMA_ONCE_DECLARE
#endif

#include "socketdef.h"
#include "socketaddress.h"

//////////////////////////////////////////////////////////////////////////////
// Class Name  : AbstractSocket
// Description : abstract socket, encapsulation socket api
//////////////////////////////////////////////////////////////////////////////
namespace acl
{
	class BufferedSocket
	{	
	public:
        friend class AbstractSocket;
		BufferedSocket();
    private:
		// no copy
		BufferedSocket(const BufferedSocket &);
		BufferedSocket& operator = (const BufferedSocket &);

		enum
		{
			BUF_SIZE=1500
		};
        char *m_cur;
        int   m_cnt;
        char  m_buf[BUF_SIZE];
	};

    class AbstractSocket
    {
    public:
        AbstractSocket(SOCKET_TYPE type=IP_SOCKET);

        operator SOCKET() const;
        void attach(SOCKET sock);    
        SOCKET detach();

        // open socket
        bool create();
        // close socket
        void close();

        //send/recv manager
        //synchronization way
        //return value is the same as ::send(...)
        int send(const char *outbuf, int want) const;
        int recv(char *inbuf, int size) const;

        int sendAll(const char *outbuf, int want) const;
        int recvAll(char *buf, int want) const;

        //asynchronism way
        int recvAsyn(char *buf, int want, DWORD timeout) const;

        int getline(BufferedSocket &bs, std::string &line, const char *eof) const;
        //select action support
        bool isSelected(fd_set *fds) const;
        void setSelect(fd_set *fds) const;

        //config action support
        bool setOption(int optname, void *optval, int optlen, int level = SOL_SOCKET) const;
        bool getOption(int optname, void *optval, int *optlen,int level = SOL_SOCKET) const;

        //check the socket is valid or not
        bool isValid() const;

        //error information manager
        //const char *getErrorMessage();

        //check the socket event
        bool recvReady(const timeval *tv) const;
        bool sendReady(const timeval *tv) const;
        
        DWORD getError() const ;

    protected:
        SOCKET		m_socket;

    private:
        SOCKET_TYPE m_type;
        std::string m_errinfo;
    };

    //////////////////////////////////////////////////////////////////////////////
    // Class Name  : ClientSocket
    // Description : the client specail socket, support connect additional method
    //////////////////////////////////////////////////////////////////////////////
    class ClientSocket : public AbstractSocket
    {
    public:
        ClientSocket();
        ClientSocket(const SocketAddress &serverAddress);
		void setServerAddress(const SocketAddress &serverAddress);
        //连接关联
        bool connect();
        bool connect(const SocketAddress &serverAddress);
        void disconnect();        

        //get the property
        bool		isConnected()	const	{return m_connected && isValid(); }
        const char *getHost()		const   {return m_severAddress.getHost(); }
        u_short		getPort()		const   {return ntohs(m_severAddress.getPort());}

    private:
        bool		    m_connected;
        SocketAddress	m_severAddress;
    };

    //////////////////////////////////////////////////////////////////////////////
    // Class Name  : AcceptedSocket
    // Description : socket from accept
    //////////////////////////////////////////////////////////////////////////////
    class AcceptedSocket : public AbstractSocket
    {
    public:
        AcceptedSocket::AcceptedSocket();
        AcceptedSocket::AcceptedSocket(SOCKET sock);
        void attach(SOCKET sock);

        const char *getHost()const {return m_peerAddress.getHost();}
        u_short		getPort()const {return ntohs(m_peerAddress.getPort());}
    private:
        SocketAddress	m_peerAddress;
    };

    /********************************************************************************************
    the socket for server
    ********************************************************************************************/
    class ServerSocket : public AbstractSocket
    {
    public:
        ServerSocket();
        ServerSocket(const SocketAddress &addr);
		void setServiceAddress(const SocketAddress &serviceAddress);
        //bind and accept
        bool		bind();
        bool		bind(const SocketAddress &addr);
		void		unbind();
        AcceptedSocket accept();

        //check 
        bool		isBinded()const { return (m_binded && isValid());}
        const char *getHost()const  { return m_serviceAddress.getHost();}
        u_short		getPort()const  { return ntohs(m_serviceAddress.getPort());}
    private:
        bool		  m_binded;
        SocketAddress m_serviceAddress;

        //
        enum 
        {
            LISTEN_SIZE = SOMAXCONN
        };
        
    };
};
#endif