IPvXAddress.h

Go to the documentation of this file.

//
// Copyright (C) 2005 Andras Varga
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 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 Lesser 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/>.
//

#ifndef __INET_IPVXADDRESS_H
#define __INET_IPVXADDRESS_H

#include <omnetpp.h>
#include <string.h>
#include "INETDefs.h"
#include "IPAddress.h"
#include "IPv6Address.h"


class INET_API IPvXAddress
{
  protected:
    uint32 d[4];
    bool isv6;

  public:
    IPvXAddress() {isv6 = false; d[0] = 0;}

    IPvXAddress(const IPAddress& addr) {set(addr);}

    IPvXAddress(const IPv6Address& addr) {set(addr);}

    IPvXAddress(const char *addr) {set(addr);}

    IPvXAddress(const IPvXAddress& addr) {set(addr);}

    ~IPvXAddress() {}

    bool isIPv6() const {return isv6;}

    IPAddress get4() const {
        if (isv6)
            throw cRuntimeError("IPvXAddress: cannot return IPv6 address %s as IPv4", str().c_str());
        return IPAddress(d[0]);
    }

    IPv6Address get6() const {
        if (!isv6)  {
            if (d[0]==0) // allow null address to be returned as IPv6
                return IPv6Address();
            throw cRuntimeError("IPvXAddress: cannot return IPv4 address %s as IPv6", str().c_str());
        }
        return IPv6Address(d[0], d[1], d[2], d[3]);
    }

    void set(const IPAddress& addr)  {
        isv6 = false;
        d[0] = addr.getInt();
    }

    void set(const IPv6Address& addr)  {
        if (addr.isUnspecified()) {
            // we always represent nulls as IPv4 null
            isv6 = false; d[0] = 0;
            return;
        }
        isv6 = true;
        uint32 *w = const_cast<IPv6Address&>(addr).words();
        d[0] = w[0]; d[1] = w[1]; d[2] = w[2]; d[3] = w[3];
    }

    void set(const IPvXAddress& addr) {
        isv6 = addr.isv6;
        d[0] = addr.d[0];
        if (isv6) {
            d[1] = addr.d[1]; d[2] = addr.d[2]; d[3] = addr.d[3];
         }
    }

    void set(const char *addr) {
        if (!tryParse(addr))
            throw cRuntimeError("IPvXAddress: cannot interpret address string `%s'", addr);
    }

    IPvXAddress& operator=(const IPAddress& addr) {set(addr); return *this;}

    IPvXAddress& operator=(const IPv6Address& addr) {set(addr); return *this;}

    IPvXAddress& operator=(const IPvXAddress& addr) {set(addr); return *this;}

    bool tryParse(const char *addr);

    std::string str() const {return isv6 ? get6().str() : get4().str();}

    bool isUnspecified() const {
        return !isv6 && d[0]==0;
    }

    int wordCount() const {return isv6 ? 4 : 1;}

    const uint32 *words() const {return d;}

    bool equals(const IPAddress& addr) const {
        return !isv6 && d[0]==addr.getInt();
    }

    bool equals(const IPv6Address& addr) const {
        uint32 *w = const_cast<IPv6Address&>(addr).words();
        return isv6 && d[0]==w[0] && d[1]==w[1] && d[2]==w[2] && d[3]==w[3];
    }

    bool equals(const IPvXAddress& addr) const {
        return (isv6 == addr.isv6) && (d[0]==addr.d[0]) && (!isv6 || (d[1]==addr.d[1] && d[2]==addr.d[2] && d[3]==addr.d[3]));
    }

    bool operator==(const IPAddress& addr) const {return equals(addr);}

    bool operator!=(const IPAddress& addr) const {return !equals(addr);}

    bool operator==(const IPv6Address& addr) const {return equals(addr);}

    bool operator!=(const IPv6Address& addr) const {return !equals(addr);}

    bool operator==(const IPvXAddress& addr) const {return equals(addr);}

    bool operator!=(const IPvXAddress& addr) const {return !equals(addr);}

    bool operator<(const IPvXAddress& addr) const {
        if (isv6!=addr.isv6)
            return !isv6;
        else if (!isv6)
            return d[0]<addr.d[0];
        else
            return memcmp(&d, &addr.d, 16) < 0;  // this provides an ordering, though not surely the one one would expect
    }
};

inline std::ostream& operator<<(std::ostream& os, const IPvXAddress& ip)
{
    return os << ip.str();
}

inline void doPacking(cCommBuffer *buf, const IPvXAddress& addr)
{
    if (buf->packFlag(addr.isIPv6()))
        doPacking(buf, addr.get6());
    else
        doPacking(buf, addr.get4());
}

inline void doUnpacking(cCommBuffer *buf, IPvXAddress& addr)
{
    if (buf->checkFlag()) {
        IPv6Address tmp;
        doUnpacking(buf, tmp);
        addr.set(tmp);
    }
    else {
        IPAddress tmp;
        doUnpacking(buf, tmp);
        addr.set(tmp);
    }
}

#endif