socket.h

Go to the documentation of this file.

// Copyright (C) 1999-2005 Open Source Telecom Corporation.
// Copyright (C) 2009 Leandro Melo de Sales <leandroal@gmail.com>
// Copyright (C) 2006-2010 David Sugar, Tycho Softworks,
//
// 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, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  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 GNU
// Common C++.  If you copy code from other releases into a copy of GNU
// 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 GNU 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_ADDRESS_H_
#include <cc++/address.h>
#endif

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

#ifndef _IOLEN64
#define _IOLEN64
#endif

#ifndef _IORET64
#define _IORET64
#endif

#ifndef MSG_DONTWAIT
#define MSG_DONTWAIT    0
#endif

#ifndef MSG_NOSIGNAL
#define MSG_NOSIGNAL    0
#endif

#ifndef SOCK_DCCP
#define SOCK_DCCP       6
#endif
#ifndef IPPROTO_DCCP
#define IPPROTO_DCCP    33
#endif
#ifndef SOL_DCCP
#define SOL_DCCP       269
#endif
#define DCCP_SOCKOPT_AVAILABLE_CCIDS    12
#define DCCP_SOCKOPT_CCID               13
#define DCCP_SOCKOPT_TX_CCID            14
#define DCCP_SOCKOPT_RX_CCID            15

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif

typedef unsigned short tpport_t;

class __EXPORT Socket
{
public:
    enum Family {
#ifdef  CCXX_IPV6
        IPV6 = AF_INET6,
#endif
        IPV4 = AF_INET
    };

    typedef enum Family Family;

    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,
        errLookupFail,
        errSearchErr,
        errInvalidValue
    };

    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:
    static Mutex mutex;

    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 volatile so;
    State volatile state;

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

    inline void error(const char *err) const
        {error(errExtended, err);};

    inline void setError(bool enable)
        {flags.thrown = !enable;};

    void endSocket(void);

    Error connectError(void);

    Error sendLimit(int limit = 2048);

    Error receiveLimit(int limit = 1);

    Error sendTimeout(timeout_t timer);

    Error receiveTimeout(timeout_t timer);

    Error sendBuffer(unsigned size);

    Error receiveBuffer(unsigned size);

    Error bufferSize(unsigned size);

    Error setBroadcast(bool enable);

    Error setMulticastByFamily(bool enable, Family family = IPV4);

    Error setLoopbackByFamily(bool enable, Family family = IPV4);

    Error setTimeToLiveByFamily(unsigned char ttl, Family fam = IPV4);

    Error join(const IPV4Multicast &ia);
#ifdef  CCXX_IPV6
    Error join(const IPV6Multicast &ia);
#endif

    Error drop(const IPV4Multicast &ia);
#ifdef  CCXX_IPV6
    Error drop(const IPV6Multicast &ia);
#endif

    Error setRouting(bool enable);


    Error setNoDelay(bool enable);

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

    Socket(SOCKET fd);

    Socket();

    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();

    static bool check(Family fam);

    Socket &operator=(const Socket &from);

    virtual IPV4Host getIPV4Sender(tpport_t *port = NULL) const;

    inline IPV4Host getSender(tpport_t *port = NULL) const
        {return getIPV4Sender(port);}

#ifdef  CCXX_IPV6
    virtual IPV6Host getIPV6Sender(tpport_t *port = NULL) const;
#endif

    IPV4Host getIPV4Peer(tpport_t *port = NULL) const;

    inline IPV4Host getPeer(tpport_t *port = NULL) const
        {return getIPV4Peer(port);}

#ifdef  CCXX_IPV6
    IPV6Host getIPV6Peer(tpport_t *port = NULL) const;
#endif

    IPV4Host getIPV4Local(tpport_t *port = NULL) const;

    inline IPV4Host getLocal(tpport_t *port = NULL) const
        {return getIPV4Local(port);}

#ifdef  CCXX_IPV6
    IPV6Host getIPV6Local(tpport_t *port = NULL) const;
#endif

    IPV4Host getIPV4NAT(tpport_t *port = NULL) const;

    inline IPV4Host getNAT(tpport_t *port) const
        {return getIPV4NAT(port);}

#ifdef  CCXX_IPV6
    IPV6Host getIPV6NAT(tpport_t *port = NULL) const;
#endif

    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 DCCPSocket : public Socket
{
    union {
        struct sockaddr_in ipv4;
#ifdef  CCXX_IPV6
        struct sockaddr_in6 ipv6;
#endif
    }   peer;

    Family family;

public:
    virtual bool onAccept(const IPV4Host &ia, tpport_t port);
#ifdef  CCXX_IPV6
    virtual bool onAccept(const IPV6Host &ia, tpport_t port);
#endif

    virtual IPV4Host getIPV4Sender(tpport_t *port = NULL) const;

#ifdef  CCXX_IPV6
    virtual IPV6Host getIPV6Sender(tpport_t *port = NULL) const;
#endif

    DCCPSocket(const IPV4Address &bind, tpport_t port, unsigned backlog = 5);
#ifdef  CCXX_IPV6
    DCCPSocket(const IPV6Address &bind, tpport_t port, unsigned backlog = 5);
#endif

    DCCPSocket(const char *name, Family family = IPV4, unsigned backlog = 5);

    DCCPSocket(Family family = IPV4);

    DCCPSocket(DCCPSocket& server, timeout_t timeout = 0);

    void reject(void);

    void disconnect(void);

    bool setCCID(uint8 ccid);

    int getTxCCID();

    int getRxCCID();

    size_t available();

    void connect(const IPV4Host &host, tpport_t port, timeout_t timeout = 0);
#ifdef  CCXX_IPV6
    void connect(const IPV6Host &host, tpport_t port, timeout_t timeout = 0);
#endif

    void connect(const char *name);

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

    virtual ~DCCPSocket();
};

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

protected:
#ifdef  CCXX_IPV6
    union {
        struct sockaddr_in6 ipv6;
        struct sockaddr_in ipv4;
    }   peer;
#else
    union {
        struct sockaddr_in ipv4;
    }   peer;
#endif

    Family family;

public:
    UDPSocket(Family family = IPV4);

    UDPSocket(const char *name, Family family = IPV4);

    UDPSocket(const IPV4Address &bind, tpport_t port);
#ifdef  CCXX_IPV6
    UDPSocket(const IPV6Address &bind, tpport_t port);
#endif

    virtual ~UDPSocket();

    inline Error setLoopback(bool enable)
        {return Socket::setLoopbackByFamily(enable, family);}

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

    inline Error setTimeToLive(char ttl)
        {return Socket::setTimeToLiveByFamily(ttl, family);}

    void setPeer(const IPV4Host &host, tpport_t port);
    void connect(const IPV4Host &host, tpport_t port);
#ifdef  CCXX_IPV6
    void setPeer(const IPV6Host &host, tpport_t port);
    void connect(const IPV6Host &host, tpport_t port);
#endif

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

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


    ssize_t send(const void *buf, size_t len);

    ssize_t receive(void *buf, size_t len, bool reply = false);

    IPV4Host getIPV4Peer(tpport_t *port = NULL) const;
    inline IPV4Host getPeer(tpport_t *port = NULL) const
        {return getIPV4Peer(port);}

#ifdef  CCXX_IPV6
    IPV6Host getIPV6Peer(tpport_t *port = NULL) const;
#endif

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

    void setPeer(const char *service);
    void connect(const char *service);

    Error disconnect(void);
};


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

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

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

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

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

protected:
    UDPTransmit(Family family = IPV4);

    UDPTransmit(const IPV4Address &bind, tpport_t port = 5005);
#ifdef  CCXX_IPV6
    UDPTransmit(const IPV6Address &bind, tpport_t port = 5005);
#endif

    Error connect(const IPV4Host &host, tpport_t port);
#ifdef  CCXX_IPV6
    Error connect(const IPV6Address &host, tpport_t port);
#endif

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

    Error connect(const IPV4Multicast &mgroup, tpport_t port);
#ifdef  CCXX_IPV6
    Error connect(const IPV6Multicast &mgroup, tpport_t port);
#endif

    inline ssize_t send(const void *buf, size_t len)
        {return _IORET64 ::send(so, (const char *)buf, _IOLEN64 len, MSG_NOSIGNAL);}

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

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

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

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

public:
    inline ssize_t transmit(const char *buffer, size_t len)
        {return _IORET64 ::send(so, buffer, _IOLEN64 len, MSG_DONTWAIT|MSG_NOSIGNAL);}

    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 IPV4Address &bind, tpport_t port);
#ifdef  CCXX_IPV6
    UDPReceive(const IPV6Address &bind, tpport_t port);
#endif

    Error connect(const IPV4Host &host, tpport_t port);
#ifdef  CCXX_IPV6
    Error connect(const IPV6Host &host, tpport_t port);
#endif

    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::setMulticastByFamily(enable, family);}

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

#ifdef  CCXX_IPV6
    inline Error join(const IPV6Multicast &ia)
        {return Socket::join(ia);}
#endif

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

#ifdef  CCXX_IPV6
    inline Error drop(const IPV6Multicast &ia)
        {return Socket::drop(ia);}
#endif

public:
    inline ssize_t receive(void *buf, size_t len)
        {return _IORET64 ::recv(so, (char *)buf, _IOLEN64 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 IPV4Address &bind, tpport_t port);
#ifdef  CCXX_IPV6
    UDPDuplex(const IPV6Address &bind, tpport_t port);
#endif

    Error connect(const IPV4Host &host, tpport_t port);
#ifdef  CCXX_IPV6
    Error connect(const IPV6Host &host, tpport_t port);
#endif

    Error disconnect(void);
};


class __EXPORT TCPSocket : protected Socket
{
protected:
    int segsize;
    void setSegmentSize(unsigned mss);

public:
    virtual bool onAccept(const IPV4Host &ia, tpport_t port);

    inline SOCKET getSocket(void)
        {return so;};

    inline int getSegmentSize(void)
        {return segsize;};

    TCPSocket(const IPV4Address &bind, tpport_t port, unsigned backlog = 5, unsigned mss = 536);

    TCPSocket(const char *name, unsigned backlog = 5, unsigned mss = 536);

    inline IPV4Host getRequest(tpport_t *port = NULL) const
        {return Socket::getIPV4Sender(port);}

    void reject(void);

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

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

    virtual ~TCPSocket();
};

#ifdef  CCXX_IPV6

class __EXPORT TCPV6Socket : protected Socket
{
private:
    int segsize;
    void setSegmentSize(unsigned mss);

public:
    virtual bool onAccept(const IPV6Host &ia, tpport_t port);

    inline SOCKET getSocket(void)
        {return so;};

    inline int getSegmentSize(void)
        {return segsize;};

    TCPV6Socket(const IPV6Address &bind, tpport_t port, unsigned backlog = 5, unsigned mss = 536);

    TCPV6Socket(const char *name, unsigned backlog = 5, unsigned mss = 536);

    inline IPV6Host getRequest(tpport_t *port = NULL) const
        {return Socket::getIPV6Sender(port);}

    void reject(void);

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

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

    virtual ~TCPV6Socket();
};

#endif

/*
:\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:
    int doallocate();

    void segmentBuffering(unsigned mss);

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

protected:
    timeout_t timeout;
    size_t bufsize;
    Family family;
    char *gbuf, *pbuf;

public:
    TCPStream(Family family = IPV4, bool throwflag = true, timeout_t to = 0);

    void disconnect(void);

    int getSegmentSize(void);

protected:
    void allocate(size_t size);

    void endStream(void);

    int underflow();

    int uflow();

    int overflow(int ch);

    void connect(const IPV4Host &host, tpport_t port, unsigned mss = 536);
#ifdef  CCXX_IPV6
    void connect(const IPV6Host &host, tpport_t port, unsigned mss = 536);
#endif

    void connect(const char *name, unsigned mss = 536);

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

public:
    TCPStream(TCPSocket &server, bool throwflag = true, timeout_t timeout = 0);
#ifdef  CCXX_IPV6
    TCPStream(TCPV6Socket &server, bool throwflag = true, timeout_t timeout = 0);
#endif

    void connect(TCPSocket &server);
#ifdef  CCXX_IPV6
    void connect(TCPV6Socket &server);
#endif

    TCPStream(const IPV4Host &host, tpport_t port, unsigned mss = 536, bool throwflag = true, timeout_t timeout = 0);
#ifdef  CCXX_IPV6
    TCPStream(const IPV6Host &host, tpport_t port, unsigned mss = 536, bool throwflag = true, timeout_t timeout = 0);
#endif

    TCPStream(const char *name, Family family = IPV4, unsigned mss = 536, bool throwflag = false, timeout_t timer = 0);

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

    TCPStream(const TCPStream &source);

    virtual ~TCPStream();

    int sync(void);

#ifdef  HAVE_SNPRINTF

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

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

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

    inline size_t getBufferSize(void) const
        {return bufsize;};
};

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

    void initial(void);

public:
    TCPSession(const IPV4Host &host,
        tpport_t port, size_t size = 536, int pri = 0, size_t stack = 0);
#ifdef  CCXX_IPV6
    TCPSession(const IPV6Host &host,
        tpport_t port, size_t size = 536, int pri = 0, size_t stack = 0);
#endif

    TCPSession(TCPSocket &server, int pri = 0, size_t stack = 0);
#ifdef  CCXX_IPV6
    TCPSession(TCPV6Socket &server, int pri = 0, size_t stack = 0);
#endif

    virtual ~TCPSession();
};

#if defined(WIN32)

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

#endif // WIN32

class __EXPORT SimpleTCPStream;

class __EXPORT SimpleTCPStream : public Socket
{
private:

    IPV4Host getSender(tpport_t *port) const;

protected:
    SimpleTCPStream();

    void endStream(void);

    void Connect(const IPV4Host &host, tpport_t port, size_t size);


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

    SimpleTCPStream(const IPV4Host &host, tpport_t port, size_t size = 512);

    SimpleTCPStream(const SimpleTCPStream &source);

    virtual ~SimpleTCPStream();

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

    void flush() {}

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

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

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

};

#ifdef  COMMON_STD_EXCEPTION
class __EXPORT SockException : public IOException
{
private:
    Socket::Error _socketError;

public:
    SockException(const 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