socket.h

Go to the documentation of this file.

// Copyright (C) 1999-2003 Open Source Telecom Corporation.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
// As a special exception to the GNU General Public License, permission is
// granted for additional uses of the text contained in its release
// of Common C++.
//
// The exception is that, if you link the Common C++ library with other files
// to produce an executable, this does not by itself cause the
// resulting executable to be covered by the GNU General Public License.
// Your use of that executable is in no way restricted on account of
// linking the Common C++ library code into it.
//
// This exception does not however invalidate any other reasons why
// the executable file might be covered by the GNU General Public License.
//
// This exception applies only to the code released under the
// name Common C++.  If you copy code from other releases into a copy of
// Common C++, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for Common C++, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.

#ifndef CCXX_SOCKET_H_
#define CCXX_SOCKET_H_

#ifndef CCXX_MISSING_H_
#include <cc++/missing.h>
#endif

#ifndef CCXX_THREAD_H_
#include <cc++/thread.h>
#endif

#ifndef CCXX_EXCEPTION_H_
#include <cc++/exception.h>
#endif

#if defined(WIN32) && !defined(__CYGWIN32__)
#define __WINSOCK__
#include <winsock2.h>
#include <io.h>
#define TIMEOUT_INF ~((timeout_t) 0)
typedef int socklen_t;
#else
#define INVALID_SOCKET  -1
typedef int SOCKET;
#endif

#ifndef MSG_DONTWAIT
#define MSG_DONTWAIT    0
#endif

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif



typedef unsigned short tpport_t;

class __EXPORT InetHostAddress;
class __EXPORT SocketPort;
class __EXPORT SocketService;

class __EXPORT InetAddrValidator 
{
public:
        InetAddrValidator() { };

        virtual void 
        operator()(const in_addr address) const = 0;
};

class __EXPORT InetMcastAddrValidator: public InetAddrValidator
{
public:
        InetMcastAddrValidator(){};

        inline void 
        operator()(const in_addr address) const; 
private:
#if __BYTE_ORDER == __BIG_ENDIAN
        enum {
                MCAST_VALID_MASK = 0xF0000000,
                MCAST_VALID_VALUE = 0xE0000000
        };
#else
        enum { 
                MCAST_VALID_MASK = 0x000000F0,
                MCAST_VALID_VALUE = 0x000000E0 
        };
#endif
};

class __EXPORT InetAddress
{
private:
        // The validator given to an InetAddress object must not be a
        // transient object, but that must exist at least until the
        // last address object of its kind is deleted. This is an
        // artifact to be able to do specific checks for derived
        // classes inside constructors.
        const InetAddrValidator *validator;

protected:
        struct in_addr * ipaddr;
        size_t addr_count;
        mutable char* hostname;  // hostname for ipaddr[0]. Used by getHostname
#if defined(WIN32)
        static MutexCounter counter;
#else
        static Mutex mutex;
#endif

        bool setIPAddress(const char *host);

        void setAddress(const char *host);

public:
        InetAddress(const InetAddrValidator *validator = NULL);

        InetAddress(struct in_addr addr, const InetAddrValidator *validator = NULL);

        InetAddress(const char *address, const InetAddrValidator *validator = NULL);

        InetAddress(const InetAddress &rhs);

        virtual ~InetAddress();

        const char *getHostname(void) const;

        bool isInetAddress(void) const;

        struct in_addr getAddress(void) const;

        struct in_addr getAddress(size_t i) const;

        size_t getAddressCount() const { return addr_count; }

        InetAddress &operator=(const char *str);
        InetAddress &operator=(struct in_addr addr);
        InetAddress &operator=(const InetAddress &rhs);

        InetAddress &operator=(unsigned long addr);

        inline InetAddress &operator=(unsigned int addr)
                {return *this = (unsigned long) addr; }

        inline bool operator!() const
                {return !isInetAddress();};

        bool operator==(const InetAddress &a) const;

        bool operator!=(const InetAddress &a) const;
};      

class __EXPORT InetMaskAddress : public InetAddress
{
public:
        InetMaskAddress(const char *mask);

        friend __EXPORT InetHostAddress operator&(const InetHostAddress &addr, 
                                         const InetMaskAddress &mask);

        InetAddress &operator=(unsigned long addr) 
        { return InetAddress::operator =(addr); }
};

class __EXPORT InetHostAddress : public InetAddress
{
public: 
        InetHostAddress(const char *host = NULL);

        InetHostAddress(struct in_addr addr);

        InetAddress &operator=(unsigned long addr) 
        { return InetAddress::operator =(addr); }

        InetHostAddress &operator&=(const InetMaskAddress &mask);

        friend class __EXPORT InetMaskAddress;
        friend __EXPORT InetHostAddress operator&(const InetHostAddress &addr, 
                                         const InetMaskAddress &mask);
};

class __EXPORT BroadcastAddress : public InetAddress
{
public:
        BroadcastAddress(const char *net = "255.255.255.255");
};

class __EXPORT InetMcastAddress: public InetAddress
{
public:
        InetMcastAddress();

        InetMcastAddress(const struct in_addr address);

        InetMcastAddress(const char *address);
        
private:
        static const InetMcastAddrValidator validator;
};

class __EXPORT Socket
{
public:
        enum Error
        {
                errSuccess = 0,
                errCreateFailed,
                errCopyFailed,
                errInput,
                errInputInterrupt,
                errResourceFailure,
                errOutput,
                errOutputInterrupt,
                errNotConnected,
                errConnectRefused,
                errConnectRejected,
                errConnectTimeout,
                errConnectFailed,
                errConnectInvalid,
                errConnectBusy,
                errConnectNoRoute,
                errBindingFailed,
                errBroadcastDenied,
                errRoutingDenied,
                errKeepaliveDenied,
                errServiceDenied,
                errServiceUnavailable,
                errMulticastDisabled,
                errTimeout,
                errNoDelay,
                errExtended
        };

        typedef enum Error Error;

        enum Tos
        {
                tosLowDelay = 0,
                tosThroughput,
                tosReliability,
                tosMinCost,
                tosInvalid
        };
        typedef enum Tos Tos;

        enum Pending
        {
                pendingInput,
                pendingOutput,
                pendingError
        };
        typedef enum Pending Pending;

protected:
        enum State
        {
                INITIAL,
                AVAILABLE,
                BOUND,
                CONNECTED,
                CONNECTING,
                STREAM
        };
        typedef enum State State;

private:
        // used by exception handlers....
        mutable Error errid;
        mutable const char *errstr;
        mutable long syserr;

        void setSocket(void);
        friend SOCKET dupSocket(SOCKET s,Socket::State state);

protected:
        mutable struct
        {
                bool thrown: 1;
                bool broadcast: 1;
                bool route: 1;
                bool keepalive: 1;
                bool loopback: 1;
                bool multicast: 1;
                bool completion: 1;
                bool linger: 1;
                unsigned ttl: 8;
        } flags;

        SOCKET so;
        State state;

        Error error(Error error, char *errstr = NULL, long systemError = 0) const;

        inline void error(char *errstr) const
                {error(errExtended, errstr);};
        
        inline void setError(bool enable)
                {flags.thrown = !enable;};

        void endSocket(void);

        Error connectError(void);

        Error setBroadcast(bool enable);

        Error setMulticast(bool enable);

        Error setLoopback(bool enable);

        Error setTimeToLive(unsigned char ttl);

        Error join(const InetMcastAddress &ia);

        Error drop(const InetMcastAddress &ia);

        Error setRouting(bool enable);


        Error setNoDelay(bool enable);

        Socket(int domain, int type, int protocol = 0);

        Socket(SOCKET fd);

        Socket(const Socket &source);

        ssize_t readLine(char *buf, size_t len, timeout_t timeout = 0);

        virtual ssize_t readData(void * buf,size_t len,char separator=0,timeout_t t=0);

        virtual ssize_t writeData(const void* buf,size_t len,timeout_t t=0);


public:
        virtual ~Socket();

        Socket &operator=(const Socket &from);

        InetHostAddress getSender(tpport_t *port = NULL) const;

        InetHostAddress getPeer(tpport_t *port = NULL) const;

        InetHostAddress getLocal(tpport_t *port = NULL) const;
        
        void setCompletion(bool immediate);

        Error setLinger(bool linger);

        Error setKeepAlive(bool enable);

        Error setTypeOfService(Tos service);

        bool isConnected(void) const;

        bool isActive(void) const;

        bool operator!() const;

        inline bool isBroadcast(void) const
                {return flags.broadcast;};

        inline bool isRouted(void) const
                {return flags.route;};

        inline Error getErrorNumber(void) const {return errid;}
        
        inline const char *getErrorString(void) const {return errstr;}

        inline long getSystemError(void) const {return syserr;}

        const char *getSystemErrorString(void) const;

        virtual bool isPending(Pending pend, timeout_t timeout = TIMEOUT_INF);
};

class __EXPORT UDPSocket : public Socket
{
private:
        inline Error setKeepAlive(bool enable)
                {return Socket::setKeepAlive(enable);};

protected:
        struct sockaddr_in peer;

public:
        UDPSocket(void);

        UDPSocket(const InetAddress &bind, tpport_t port);

        virtual ~UDPSocket();

        void setPeer(const InetHostAddress &host, tpport_t port);

        Socket::Error getInterfaceIndex(const char *ethX,int& InterfaceIndex);

        Socket::Error join(const InetMcastAddress &ia,int InterfaceIndex);


        inline int send(const void *buf, size_t len)
                {return ::sendto(so, (const char*)buf, len, 0, (struct sockaddr *)&peer, (socklen_t)sizeof(peer));};

        inline int receive(void *buf, size_t len)
                {return ::recv(so, (char *)buf, len, 0);};

        InetHostAddress getPeer(tpport_t *port = NULL) const;

        inline int peek(void *buf, size_t len)
                {return ::recv(so, (char *)buf, len, MSG_PEEK);};

        Error disconnect(void);
};


class __EXPORT UDPBroadcast : public UDPSocket
{
private:
        void setPeer(const InetHostAddress &ia, tpport_t port) {};

        Error setBroadcast(bool enable)
                {return Socket::setBroadcast(enable);};

public:
        UDPBroadcast(const InetAddress &ia, tpport_t port);

        void setPeer(const BroadcastAddress &subnet, tpport_t port);
};      

class __EXPORT UDPTransmit : protected UDPSocket
{
private:
        Error cConnect(const InetAddress &ia, tpport_t port);

protected:
        UDPTransmit();

        UDPTransmit(const InetAddress &bind, tpport_t port = 5005);

        Error connect(const InetHostAddress &host, tpport_t port);

        Error connect(const BroadcastAddress &subnet, tpport_t port);

        Error connect(const InetMcastAddress &mgroup, tpport_t port);

        inline int send(const void *buf, int len)
                {return ::send(so, (const char *)buf, len, 0);}

        inline void endTransmitter(void)
                {Socket::endSocket();}

        /*
         * Get transmitter socket.
         *
         * @return transmitter.
         */
        inline SOCKET getTransmitter(void)
                {return so;};

        inline Error setMulticast(bool enable)
                {return Socket::setMulticast(enable);};

        inline Error setTimeToLive(unsigned char ttl)
                {return Socket::setTimeToLive(ttl);};

public:
        inline int transmit(const char *buffer, size_t len)
                {return ::send(so, buffer, len, MSG_DONTWAIT);}

        inline bool isOutputReady(unsigned long timeout = 0l)
                {return Socket::isPending(Socket::pendingOutput, timeout);};


        inline Error setRouting(bool enable)
                {return Socket::setRouting(enable);};

        inline Error setTypeOfService(Tos tos)
                {return Socket::setTypeOfService(tos);};

        inline Error setBroadcast(bool enable)
                {return Socket::setBroadcast(enable);};
};

class __EXPORT UDPReceive : protected UDPSocket
{
protected:
        UDPReceive(const InetAddress &bind, tpport_t port);

        Error connect(const InetHostAddress &host, tpport_t port);

        bool isPendingReceive(timeout_t timeout)
                {return Socket::isPending(Socket::pendingInput, timeout);};

        inline void endReceiver(void)
                {Socket::endSocket();}

        inline SOCKET getReceiver(void) const
                {return so;};

        inline Error setRouting(bool enable)
                {return Socket::setRouting(enable);};

        inline Error setMulticast(bool enable)
                {return Socket::setMulticast(enable);};

        inline Error join(const InetMcastAddress &ia)
                {return Socket::join(ia);}

        inline Error drop(const InetMcastAddress &ia)
                {return Socket::drop(ia);}

public:
        inline int receive(void *buf, size_t len)
                {return ::recv(so, (char *)buf, len, 0);};

        inline bool isInputReady(timeout_t timeout = TIMEOUT_INF)
                {return Socket::isPending(Socket::pendingInput, timeout);};
};

class __EXPORT UDPDuplex : public UDPTransmit, public UDPReceive
{
public:
        UDPDuplex(const InetAddress &bind, tpport_t port);

        Error connect(const InetHostAddress &host, tpport_t port);

        Error disconnect(void);
};


class __EXPORT TCPSocket : protected Socket
{
protected:
        virtual bool onAccept(const InetHostAddress &ia, tpport_t port)
                {return true;};

        friend class TCPStream;
        friend class SocketPort;
        friend class tcpstream;
        friend class SimpleTCPStream; // Added by Mark S. Millard

public:
        TCPSocket(const InetAddress &bind, tpport_t port, int backlog = 5);
        
        inline InetHostAddress getRequest(tpport_t *port = NULL) const
                {return Socket::getSender(port);};

        void reject(void);

        inline InetHostAddress getLocal(tpport_t *port = NULL) const
                {return Socket::getLocal(port);};

        inline bool isPendingConnection(timeout_t timeout = TIMEOUT_INF) /* not const -- jfc */
                {return Socket::isPending(Socket::pendingInput, timeout);}

        virtual ~TCPSocket()
                {endSocket();};
};

/*
:\projects\libraries\cplusplus\commonc++\win32\socket.h(357) : warning C4275: non dll-interface class 'streambuf' used as base for dll-interface class 'TCPStream'
        c:\program files\microsoft visual studio\vc98\include\streamb.h(69) : see declaration of 'streambuf'
c:\projects\libraries\cplusplus\commonc++\win32\socket.h(358) : warning C4275: non dll-interface class 'iostream' used as base for dll-interface class 'TCPStream'
        c:\program files\microsoft visual studio\vc98\include\iostream.h(66) : see declaration of 'iostream'
*/

#ifdef _MSC_VER
#pragma warning(disable:4275) // disable C4275 warning
#endif

class __EXPORT TCPStream : protected std::streambuf, public Socket, public std::iostream
{
private:
        inline Error setBroadcast(bool enable)
                {return Socket::setBroadcast(enable);};

        inline InetHostAddress getSender(tpport_t *port) const
                {return InetHostAddress();};

        int doallocate();

        friend TCPStream& crlf(TCPStream&);
        friend TCPStream& lfcr(TCPStream&);

protected:
        timeout_t timeout;
        int bufsize;
        char *gbuf, *pbuf;

        TCPStream(bool throwflag = true);

        void allocate(int size);

        void endStream(void);

        int underflow();

        int uflow();

        int overflow(int ch);

        void connect(const InetHostAddress &host, tpport_t port, int size);

        std::iostream *tcp(void)
                {return ((std::iostream *)this);};

public:
        TCPStream(TCPSocket &server, int size = 512, bool throwflag = true, timeout_t timeout = 0);

        TCPStream(const InetHostAddress &host, tpport_t port, int size = 512, bool throwflag = true, timeout_t timeout = 0);

        inline void setTimeout(timeout_t to)
                {timeout = to;};

        TCPStream(const TCPStream &source);

        virtual ~TCPStream()
                {
                try { endStream(); }
                catch( ... ) { if ( ! std::uncaught_exception()) throw; }
                };

        int sync(void);

#ifdef  HAVE_SNPRINTF

        int printf(const char *format, ...);
#endif

        bool isPending(Pending pend, timeout_t timeout = TIMEOUT_INF);

         inline int peek(void *buf, size_t len)
                 {return ::recv(so, (char *)buf, len, MSG_PEEK);};

        int getBufferSize(void) const
                {return bufsize;};
};

class __EXPORT tcpstream : public TCPStream
{
public:
        // copy constructor (fix a BUG in msvc7 compiler)
        tcpstream(const tcpstream &rhs):TCPStream(rhs) {};

        tcpstream();

        tcpstream(const char *addr, int buffer = 512);

        tcpstream(TCPSocket &tcp, int buffer = 512);

        void open(const char *addr, int buffer = 512);

        void open(TCPSocket &tcp, int buffer = 512);

        void close(void);

        bool operator!() const;
};              

class __EXPORT TCPSession : public TCPStream, public Thread
{
private:
        TCPSession(const TCPSession &rhs); // not defined
protected:
        int waitConnection(timeout_t timeout = TIMEOUT_INF);

        void initial(void);

        void final(void)
                {delete this;};
public:
        TCPSession(const InetHostAddress &host, 
                   tpport_t port, int size = 512, int pri = 0, int stack = 0);

        TCPSession(TCPSocket &server, int size = 512, 
                   int pri = 0, int stack = 0);
};

extern __EXPORT std::ostream& operator<<(std::ostream &os, const InetAddress &ia);

inline struct in_addr getaddress(const InetAddress &ia)
        {return ia.getAddress();}

#if defined(WIN32)

class init_WSA
{
public:
        init_WSA();
        ~init_WSA();
};

#endif // WIN32

class __EXPORT SimpleTCPStream;

class __EXPORT SimpleTCPStream : protected Socket
{
private:

        inline InetHostAddress getSender(tpport_t *port) const
        { return InetHostAddress(); };

protected:
        SimpleTCPStream();

        void endStream(void);

        void Connect(const InetHostAddress &host, tpport_t port, int size);


public:
        SimpleTCPStream(TCPSocket &server, int size = 512);

        SimpleTCPStream(const InetHostAddress &host, tpport_t port, int size = 512);

        SimpleTCPStream(const SimpleTCPStream &source);

        virtual ~SimpleTCPStream() { endStream(); };

        bool isPending(Pending pend, timeout_t timeout = TIMEOUT_INF);

        void flush() {}

        int read(char *bytes,int length, timeout_t timeout = 0);

        int write(const char *bytes,int length, timeout_t timeout = 0);

        int peek(char *bytes,int length, timeout_t timeout = 0);

};

class __EXPORT SocketService;

class __EXPORT SocketPort : public Socket, public TimerPort
{
private:
        SocketPort *next, *prev;
        SocketService *service;
#ifndef WIN32
        struct timeval porttimer;
#ifdef USE_POLL
        struct pollfd   * ufd;
#endif
#else
        HANDLE event;
#endif
        bool detect_pending;
        bool detect_output;
        bool detect_disconnect;
        
        friend class SocketService;

protected:
        SocketPort(SocketService *svc, TCPSocket &tcp);

        SocketPort(SocketService *svc, const InetAddress &ia, tpport_t port);
        
        SocketPort(SocketService *svc, const InetHostAddress &ih, tpport_t port);

         void attach( SocketService* svc );


        virtual ~SocketPort();

        void setDetectPending( bool );
        
        bool getDetectPending( void ) const
                { return detect_pending; }
        
        void setDetectOutput( bool );
        
        bool getDetectOutput( void ) const
                { return detect_output; }

        virtual void expired(void)
                {return;};

        virtual void pending(void)
                {return;};

        virtual void output(void)
                {return;};

        virtual void disconnect(void)
                {return;};

        Error connect(const InetAddress &ia, tpport_t port);

        inline int send(const void *buf, int len)
                {return ::send(so, (const char *)buf, len, 0);};

        inline int receive(void *buf, size_t len)
                {return ::recv(so, (char *)buf, len, 0);};

        inline int peek(void *buf, size_t len)
                {return ::recv(so, (char *)buf, len, MSG_PEEK);};

public:
        void setTimer(timeout_t timeout = 0);

        void incTimer(timeout_t timeout);
};

class __EXPORT SocketService : public Thread, private Mutex
{
private:
#ifndef WIN32
        fd_set connect;
        int iosync[2];
        int hiwater;
#else
        // private syncronization class
        class Sync;
        Sync* sync;
#endif
        int count;
        SocketPort *first, *last;

        void attach(SocketPort *port);
        void detach(SocketPort *port);
        
        void run(void);

        friend class SocketPort;

protected:
        virtual void onUpdate(unsigned char buf)
                {return;};

        virtual void onEvent(void)
                {return;};

        virtual void onCallback(SocketPort *port)
                {return;};

public:
        void update(unsigned char flag = 0xff);

        SocketService(int pri = 0, size_t stack = 0, const char *id = NULL);

        virtual ~SocketService();

        inline int getCount(void) const
                {return count;};
};

#ifdef  COMMON_STD_EXCEPTION
class __EXPORT SockException : public IOException
{
private:
        Socket::Error _socketError;
        
public:
        SockException(String str, Socket::Error socketError, long systemError = 0) :
                IOException(str, systemError), _socketError(socketError) {};

        inline Socket::Error getSocketError() const
        { return _socketError; }
};
#endif

#ifdef  CCXX_NAMESPACES
};
#endif

#endif

---