MCSocket.h

#if !defined(__MCSOCKET_H_)
#define __MCSOCKET_H_

#ident "@(#)$Id: MCSocket.h,v 1.5 2004/12/02 07:05:20 mike Exp $"

/*
 * Copyright Miba Consulting Ltd. (c) 2000-2003
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 */

#include "mcllib/MCIOBase.h"
#include "mcllib/MCTime.h"
#include "mcllib/MCString.h"

namespace mclpriv {
    // Forward declaration
    class MCNetAddrFactory;
};

namespace mcllib
{
    // Forward declaration
    class MCRecvFromResult;

    class MCNetAddr : public MCBase
    {
    public:
        const void* getAddr() const;
        MCString toString() const;
    private:
        friend class mclpriv::MCNetAddrFactory;
        friend class MCRecvFromResult;

        MCNetAddr(void* impl);
    };

    class MCRecvFromResult
    {
    public:
        mcuint32 getRecvSize() const;
        const MCNetAddr& getRecvFrom() const;

    private:
        friend class mclpriv::MCNetAddrFactory;
        MCRecvFromResult(mcuint32 size, void* impl);
        mcuint32 m_recvSize;
        MCNetAddr m_recvFrom;
    };

    enum MCEAddrType
    {
        MCAFRAW,
        MCAFINET,
        MCAFINETV6,
        MCAFPATH
    };

    extern const mcuint16 MCAnyPort;

    // Network address functions
    MCNetAddr MCGetInetAddrAny(mcuint16 port = MCAnyPort);
    MCNetAddr MCGetInetAddr(const MCString& name, mcuint16 port = MCAnyPort);
    MCNetAddr MCGetPathAddr(const MCString& path);

    class MCSocket : public MCIOBase
    {
    public:
        ~MCSocket();

        mcint32 sendTo(const MCNetAddr& addr,
            const void* buf, mcint32 len,
            mcinterval_t timeout = MCIntervalInfinite);
        MCRecvFromResult recvFrom(void* buf,
            mcint32 len,
            mcinterval_t timeout = MCIntervalInfinite);
        MCNetAddr getSockName() const;
        void bind(const MCNetAddr& addr);
        //
        // Common Socket options - across all socket types
        //
        bool getNonBlock() const;
        bool getReuseAddr() const;
        mcuint32 getSendBufferSize() const;
        mcuint32 getRecvBufferSize() const;
        mcuint32 getTtl() const;
        mcuint32 getTos() const;
        void setNonBlock(bool nonBlock);
        void setReuseAddr(bool reuse);
        void setSendBufferSize(mcuint32 sz);
        void setRecvBufferSize(mcuint32 sz);
        void setTtl(mcuint32 ttl);
        void setTos(mcuint32 tos);

    protected:
        MCSocket();
        MCSocket(void* impl);
    };

    class MCCOSocket : public MCSocket
    {
    public:
        MCNetAddr getPeerName() const;
        mcint32 send(const void* buf, mcint32 len,
            mcinterval_t timeout = MCIntervalInfinite);
        mcint32 recv(void* buf, mcint32 len,
            mcinterval_t timeout = MCIntervalInfinite);
        mcint32 peek(void* buf, mcint32 len,
            mcinterval_t timeout = MCIntervalInfinite);
        void connect(const MCNetAddr& addr,
            mcinterval_t timeout = MCIntervalInfinite);

    protected:
        MCCOSocket();
        MCCOSocket(void* impl);
    };

    class MCCLSocket : public MCSocket
    {
    public:
        // Connection less specific options
        bool getBroadcast() const;
        void setBroadcast(bool broadcast);
        mcuint32 getMulticastTtl() const;
        void setMulticastTtl(mcuint32 mcastTtl);
        MCNetAddr getMulticastIf() const;
        void setMulticastIf(const MCNetAddr& mcastIf);
        void addMulticast(const MCNetAddr& group, const MCNetAddr& mcastIf);
        void dropMulticast(const MCNetAddr& group, const MCNetAddr& mcastIf);
    protected:
        MCCLSocket();
        MCCLSocket(void* impl);
    };


    class MCStreamSocket : public MCCOSocket
    {
    public:
        virtual ~MCStreamSocket();
        virtual void accept(MCStreamSocket* pSock,
            mcinterval_t timeout = MCIntervalInfinite);
        void listen(mcintn queueLength);
        void shutdownSend();
        void shutdownRecv();
        // TCP Socket options
        bool getKeepAlive() const;
        void setKeepAlive(bool keepAlive);
        mcinterval_t getLingerTime() const;
        bool getLinger() const;
        void setLinger(bool linger, mcinterval_t timeout);
        bool getNoDelay() const;
        void setNoDelay(bool noDelay);
        mcuint32 getMss() const;
        void setMss(mcuint32 mss);
    protected:
        MCStreamSocket();
        MCStreamSocket(void* impl);
    private:
        virtual void acceptIf(MCStreamSocket* pSock, mcinterval_t timeout) = 0;
    };

    class MCTCPSocket : public MCStreamSocket
    {
    public:
        MCTCPSocket();
        MCTCPSocket(const MCNetAddr& addr);
        // From MCStreamSocket
        virtual ~MCTCPSocket();
    private:
        friend class MCStreamSocket;
        MCTCPSocket(void* impl);
        // from MCStreamSocket
        virtual void acceptIf(MCStreamSocket* pSock, mcinterval_t timeout);
    };

    class MCCOUDPSocket : public MCCOSocket
    {
    public:
        MCCOUDPSocket();
        MCCOUDPSocket(const MCNetAddr& addr);
    };

    class MCUDPSocket : public MCCLSocket
    {
    public:
        MCUDPSocket();
        MCUDPSocket(const MCNetAddr& addr);
    };
};


#endif

---