address.h

Go to the documentation of this file.

// Copyright (C) 1999-2005 Open Source Telecom Corporation.
// 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_ADDRESS_H_
#define CCXX_ADDRESS_H_

#ifndef CCXX_CONFIG_H_
#include <cc++/config.h>
#endif

#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

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif

// future definition of ipv4 specific classes, now defines

#define INET_IPV4_ADDRESS_SIZE  16
#define CIDR_IPV4_ADDRESS_SIZE  32
#define INET_IPV6_ADDRESS_SIZE  40
#define CIDR_IPV6_ADDRESS_SIZE  45

#define CIDR        IPV4Cidr
#define InetAddress IPV4Address
#define InetHostAddress IPV4Host
#define InetMaskAddress IPV4Mask
#define InetMcastAddress IPV4Multicast
#define InetMcastAddressValidator IPV4MulticastValidator
#define InetAddrValidator IPV4Validator
#define BroadcastAddress IPV4Broadcast

typedef unsigned short tpport_t;

class __EXPORT IPV4Host;

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

    virtual ~IPV4Validator() {};

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

class __EXPORT IPV4MulticastValidator: public IPV4Validator
{
public:
    IPV4MulticastValidator(){};

    virtual ~IPV4MulticastValidator(){};

    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 IPV4Cidr
{
protected:
    struct in_addr netmask, network;

    unsigned getMask(const char *cp) const;
public:
    inline struct in_addr getNetwork(void) const
        {return network;};

    inline struct in_addr getNetmask(void) const
        {return netmask;};

    struct in_addr getBroadcast(void) const;

    void set(const char *cidr);

    IPV4Cidr(const char *cidr);

    IPV4Cidr();

    IPV4Cidr(IPV4Cidr &);

    bool isMember(const struct sockaddr *saddr) const;

    bool isMember(const struct in_addr &inaddr) const;

    inline bool operator==(const struct sockaddr *a) const
        {return isMember(a);};

    inline bool operator==(const struct in_addr &a) const
        {return isMember(a);};
};

#ifdef  CCXX_IPV6

class __EXPORT IPV6Cidr
{
protected:
    struct in6_addr netmask, network;

    unsigned getMask(const char *cp) const;
public:
    inline struct in6_addr getNetwork(void) const
        {return network;};

    inline struct in6_addr getNetmask(void) const
        {return netmask;};

    struct in6_addr getBroadcast(void) const;

    void set(const char *cidr);

    IPV6Cidr(const char *cidr);

    IPV6Cidr();

    IPV6Cidr(IPV6Cidr &);

    bool isMember(const struct sockaddr *saddr) const;

    bool isMember(const struct in6_addr &inaddr) const;

    inline bool operator==(const struct sockaddr *sa) const
        {return isMember(sa);};

    inline bool operator==(const struct in6_addr &a) const
        {return isMember(a);};
};

#endif

class __EXPORT IPV4Address
{
private:
    // The validator given to an IPV4Address 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:
    IPV4Address(const InetAddrValidator *validator = NULL);

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

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

    IPV4Address(const IPV4Address &rhs);

    virtual ~IPV4Address();

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

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

    IPV4Address &operator=(unsigned long addr);

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

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

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

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

class __EXPORT IPV4Mask : public IPV4Address
{
public:
    IPV4Mask(const char *mask);

    friend __EXPORT IPV4Host operator&(const IPV4Host &addr,
                     const IPV4Mask &mask);

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

class __EXPORT IPV4Host : public IPV4Address
{
private:
    static IPV4Host _host_;

public:
    IPV4Host(const char *host = NULL);

    IPV4Host(struct in_addr addr);

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

    IPV4Host &operator&=(const IPV4Mask &mask);

    friend class __EXPORT IPV4Mask;
    friend __EXPORT IPV4Host operator&(const IPV4Host &addr,
                     const IPV4Mask &mask);
};

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

class __EXPORT IPV4Multicast: public IPV4Address
{
public:
    IPV4Multicast();

    IPV4Multicast(const struct in_addr address);

    IPV4Multicast(const char *address);

private:
    static const IPV4MulticastValidator validator;
};

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

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


#ifdef  CCXX_IPV6

class __EXPORT IPV6Host;

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

    virtual ~IPV6Validator() {};

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

class __EXPORT IPV6MulticastValidator: public IPV6Validator
{
public:
    IPV6MulticastValidator(){};

    virtual ~IPV6MulticastValidator(){};

    void operator()(const in6_addr address) const;
};

class __EXPORT IPV6Address
{
private:
    // The validator given to an IPV4Address 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 IPV6Validator *validator;

protected:
    struct in6_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:
    IPV6Address(const IPV6Validator *validator = NULL);

    IPV6Address(struct in6_addr addr, const IPV6Validator *validator = NULL);

    IPV6Address(const char *address, const IPV6Validator *validator = NULL);

    IPV6Address(const IPV6Address &rhs);

    virtual ~IPV6Address();

    const char *getHostname(void) const;

    bool isInetAddress(void) const;

    struct in6_addr getAddress(void) const;

    struct in6_addr getAddress(size_t i) const;

    size_t getAddressCount() const { return addr_count; }

    IPV6Address &operator=(const char *str);
    IPV6Address &operator=(struct in6_addr addr);
    IPV6Address &operator=(const IPV6Address &rhs);

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

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

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

class __EXPORT IPV6Mask : public IPV6Address
{
public:
    IPV6Mask(const char *mask);

    friend __EXPORT IPV6Host operator&(const IPV6Host &addr,
                     const IPV6Mask &mask);
};

class __EXPORT IPV6Host : public IPV6Address
{
public:
    IPV6Host(const char *host = NULL);

    IPV6Host(struct in6_addr addr);

    IPV6Host &operator&=(const IPV6Mask &mask);

    friend class __EXPORT IPV6Mask;
    friend __EXPORT IPV6Host operator&(const IPV6Host &addr, const IPV6Mask &mask);
};

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

class __EXPORT IPV6Multicast: public IPV6Address
{
public:
    IPV6Multicast();

    IPV6Multicast(const struct in6_addr address);

    IPV6Multicast(const char *address);

private:
    static const IPV6MulticastValidator validator;
};

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

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


#endif

#ifdef  CCXX_NAMESPACES
}
#endif

#endif