address.h

Go to the documentation of this file.

// Copyright (C) 1999-2005 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, 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