address.h

Go to the documentation of this file.

// Copyright (C) 1999-2005 Open Source Telecom Corporation.
// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// 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_ADDRESS_H_
#define COMMONCPP_ADDRESS_H_
 
#ifndef COMMONCPP_CONFIG_H_
#include <commoncpp/config.h>
#endif
 
#ifndef COMMONCPP_THREAD_H_
#include <commoncpp/thread.h>
#endif
 
#ifndef COMMMONCPP_EXCEPTION_H_
#include <commoncpp/exception.h>
#endif
 
namespace ost {
 
// 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 in_port_t tpport_t;
 
class IPV4Host;
 
class __EXPORT IPV4Validator
{
private:
    __DELETE_COPY(IPV4Validator);
 
public:
    IPV4Validator() { }
 
    virtual ~IPV4Validator() {}
 
    virtual void
    operator()(const in_addr address) const = 0;
};
 
class __EXPORT IPV4MulticastValidator: public IPV4Validator
{
private:
    __DELETE_COPY(IPV4MulticastValidator);
 
public:
    IPV4MulticastValidator(){}
 
    virtual ~IPV4MulticastValidator(){}
 
    void operator()(const in_addr address) const __OVERRIDE;
};
 
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);
    }
 
    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);
    }
 
    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(_MSWINDOWS_)
    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=(in_addr_t addr);
 
    inline operator bool() const {
        return isInetAddress();
    }
 
    inline bool operator!() const {
        return !isInetAddress();
    }
 
    bool operator==(const IPV4Address &a) const;
 
    bool operator!=(const IPV4Address &a) const;
};
 
class __EXPORT IPV4Mask : public IPV4Address
{
private:
    __DELETE_COPY(IPV4Mask);
 
public:
    IPV4Mask(const char *mask);
 
    friend __EXPORT IPV4Host operator&(const IPV4Host &addr, const IPV4Mask &mask);
 
    IPV4Address &operator=(in_addr_t 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=(in_addr_t addr) {
        return IPV4Address::operator =(addr); 
    }
 
    IPV4Host &operator&=(const IPV4Mask &mask);
 
    friend class 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 IPV6Host;
 
class __EXPORT IPV6Validator
{
private:
    __DELETE_COPY(IPV6Validator);
 
public:
    IPV6Validator() { }
 
    virtual ~IPV6Validator() {}
 
    virtual void operator()(const in6_addr address) const = 0;
};
 
class __EXPORT IPV6MulticastValidator: public IPV6Validator
{
private:
    __DELETE_COPY(IPV6MulticastValidator);
 
public:
    IPV6MulticastValidator(){}
 
    virtual ~IPV6MulticastValidator(){}
 
    void operator()(const in6_addr address) const __OVERRIDE;
};
 
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(_MSWINDOWS_)
    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 operator bool () const {
        return isInetAddress();
    }
 
    inline bool operator!() const {
        return !isInetAddress();
    }
 
    bool operator==(const IPV6Address &a) const;
 
    bool operator!=(const IPV6Address &a) const;
};
 
class __EXPORT IPV6Mask : public IPV6Address
{
private:
    __DELETE_COPY(IPV6Mask);
 
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 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
 
} // namespace ost
 
#endif