commoncpp/socket.h

Go to the documentation of this file.

// Copyright (C) 1999-2005 Open Source Telecom Corporation.
// Copyright (C) 2006-2014 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 Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// 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 COMMONCPP_SOCKET_H_
#define COMMONCPP_SOCKET_H_

#include <cstdio>

#ifndef COMMONCPP_CONFIG_H_
#include <commoncpp/config.h>
#endif

#ifndef COMMONCPP_STRING_H_
#include <commoncpp/string.h>
#endif

#ifndef COMMONCPP_ADDRESS_H_
#include <commoncpp/address.h>
#endif

#ifndef COMMONCPP_EXCEPTION_H_
#include <commoncpp/exception.h>
#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

NAMESPACE_COMMONCPP

typedef socket_t    SOCKET;

class __EXPORT Socket : protected ucommon::Socket
{
public:
    enum State {
        INITIAL,
        AVAILABLE,
        BOUND,
        CONNECTED,
        CONNECTING,
        STREAM
    };
    typedef enum State State;

    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;

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

    void setSocket(void);

protected:
    static socket_t dupSocket(socket_t s,Socket::State state);

    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;

    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_t 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:
    ~Socket();

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

    static bool check(Family fam);

    bool operator!() const;

    operator bool() const;

    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

    void setCompletion(bool immediate);

    Error setLinger(bool linger);

    Error setKeepAlive(bool enable);

    Error setTypeOfService(Tos service);

    bool isConnected(void) const;

    bool isActive(void) const;

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

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


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

#ifdef  CCXX_IPV6
    inline struct in6_addr getaddress(const IPV6Address &ia)
        {return ia.getAddress();}
#endif

};

#if defined(CCXX_EXCEPTIONS)

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

public:
    inline SockException(const String &str, Socket::Error socketError, long systemError = 0) :
        IOException(str, systemError), _socketError(socketError) {};

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

#endif

END_NAMESPACE

#endif

---