/builddir/build/BUILD/libutil++-1.4.0/src/sella/net/IPPrefix.cpp

/*
** libutil++
** $Id: IPPrefix.cpp 1243 2014-11-21 01:01:24Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: IPPrefix.cpp 1243 2014-11-21 01:01:24Z sella $";

#include "IPPrefix.h"
#include "../util/String.h"
#include "../util/CommonMacro.h"

#include <string.h>

#define HASH_ALGO_INT1

using namespace sella::net;
using namespace sella::util;

union __sockaddr_union {
        struct sockaddr_storage         *ss;
        struct sockaddr                         *sa;
        struct sockaddr_in                      *sa_in;
        struct sockaddr_in6                     *sa_in6;
};

IPPrefix::IPPrefix(const IPAddress &address, uint8_t cidr) throw (AddressException) :
        address(address),
        cidr(cidr),
        mask{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF},
        hcache(0)
{
        this->address.applyCIDR(cidr);

        generateMask();
}

IPPrefix::IPPrefix(const std::string &address, uint8_t cidr) throw (AddressException) :
        address(address),
        cidr(cidr),
        mask{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF},
        hcache(0)
{
        this->address.applyCIDR(cidr);

        generateMask();
}

IPPrefix::IPPrefix(const std::string &prefix) throw (AddressException) :
        mask{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF},
        hcache(0)
{
        const auto &parts = String::split(prefix, "/");

        if (parts.empty()) {
                THROW(AddressException, "unable to parse prefix: '%s' does not represent a valid IPv4 or IPv6 prefix", prefix.c_str());
        } else if (parts.size() == 1) {
                address = IPAddress(parts.at(0));
                cidr = (address.getFamily() == AF_INET) ? 32 : 128;
        } else {
                address = IPAddress(parts.at(0));
                cidr = std::stoi(parts.at(1));
        }

        this->address.applyCIDR(cidr);

        generateMask();
}

IPPrefix::IPPrefix(const IPPrefix &other) throw () :
        address(other.address),
        cidr(other.cidr),
        scache(other.scache),
        hcache(other.hcache)
{
        memcpy(mask, other.mask, sizeof(mask));
}

IPPrefix::IPPrefix(const IPPrefix &&other) throw () :
        address(std::move(other.address)),
        cidr(other.cidr),
        scache(std::move(other.scache)),
        hcache(other.hcache)
{
        memcpy(mask, other.mask, sizeof(mask));
}

IPPrefix::~IPPrefix() throw () { }

IPPrefix& IPPrefix::operator=(const IPPrefix &other) throw () {
        if (this != &other) {
                this->address = other.address;
                this->cidr = other.cidr;
                memcpy(this->mask, other.mask, sizeof(mask));
                this->scache = other.scache;
                this->hcache = other.hcache;
        }

        return *this;
}

IPPrefix& IPPrefix::operator=(const IPPrefix &&other) throw () {
        if (this != &other) {
                this->address = std::move(other.address);
                this->cidr = other.cidr;
                memcpy(this->mask, other.mask, sizeof(mask));
                this->scache = std::move(other.scache);
                this->hcache = other.hcache;
        }

        return *this;
}

bool IPPrefix::operator==(const IPPrefix &other) const throw () {
        return (this->cidr == other.cidr) ? ((this->address == other.address) ? true : false) : false;
}

bool IPPrefix::operator!=(const IPPrefix &other) const throw () {
        return !(*this == other);
}

bool IPPrefix::operator>=(const IPPrefix &other) const throw () {
        return (this->address < other.address) ? false : ((this->address > other.address) ? true : (this->cidr >= other.cidr) ? true : false);
}

bool IPPrefix::operator<=(const IPPrefix &other) const throw () {
        return (this->address > other.address) ? false : ((this->address < other.address) ? true : (this->cidr <= other.cidr) ? true : false);
}

bool IPPrefix::operator>(const IPPrefix &other) const throw () {
        return (this->address > other.address) ? true : ((this->address < other.address) ? false : (this->cidr > other.cidr) ? true : false);
}

bool IPPrefix::operator<(const IPPrefix &other) const throw () {
        return (this->address < other.address) ? true : ((this->address > other.address) ? false : (this->cidr < other.cidr) ? true : false);
}

bool IPPrefix::operator<<(const IPPrefix &other) const throw () {
        return other.contains(*this, false);
}

bool IPPrefix::operator<<=(const IPPrefix &other) const throw () {
        return other.contains(*this, true);
}

bool IPPrefix::operator>>(const IPPrefix &other) const throw () {
        return this->contains(other, false);
}

bool IPPrefix::operator>>=(const IPPrefix &other) const throw () {
        return this->contains(other, true);
}

bool IPPrefix::operator<<(const IPAddress &other) const throw () {
        return !(this->contains(other, true));
}

bool IPPrefix::operator<<=(const IPAddress &other) const throw () {
        return !(this->contains(other, false));
}

bool IPPrefix::operator>>(const IPAddress &other) const throw () {
        return this->contains(other, false);
}

bool IPPrefix::operator>>=(const IPAddress &other) const throw () {
        return this->contains(other, true);
}

bool IPPrefix::contains(const IPPrefix &other, bool orEquals) const throw () {
        bool cmp;

        if (this->getFamily() != other.getFamily()) {
                return false;
        }

        if (this->getFamily() == AF_INET) {
                const uint32_t &a = this->address.getIPv4AddressStructure().s_addr;
                const uint32_t &b = other.address.getIPv4AddressStructure().s_addr;
                const uint32_t &m = this->mask[0];

                cmp = ((ntohl(a) & m) == (ntohl(b) & m));
        } else {
                const uint64_t *a = (const uint64_t*) this->address.getIPv6AddressStructure().s6_addr;
                const uint64_t *b = (const uint64_t*) other.address.getIPv6AddressStructure().s6_addr;
                const uint64_t *m =  (const uint64_t*) this->mask;

                cmp = ((ntohll(a[0]) & m[0]) == (ntohll(b[0]) & m[0]) && (ntohll(a[1]) & m[1]) == (ntohll(b[1]) & m[1]));
        }

        return (orEquals) ? cmp : (cmp && this->cidr != other.cidr);
}

bool IPPrefix::contains(const IPAddress &other, bool orEquals) const throw () {
        bool cmp;
        uint8_t ocidr;

        if (this->getFamily() != other.getFamily()) {
                return false;
        }

        if (this->getFamily() == AF_INET) {
                const uint32_t &a = this->address.getIPv4AddressStructure().s_addr;
                const uint32_t &b = other.getIPv4AddressStructure().s_addr;
                const uint32_t &m = this->mask[0];

                ocidr = 32;
                cmp = ((ntohl(a) & m) == (ntohl(b) & m));
        } else {
                const uint64_t *a = (const uint64_t*) this->address.getIPv6AddressStructure().s6_addr;
                const uint64_t *b = (const uint64_t*) other.getIPv6AddressStructure().s6_addr;
                const uint64_t *m =  (const uint64_t*) this->mask;

                ocidr = 128;
                cmp = ((ntohll(a[0]) & m[0]) == (ntohll(b[0]) & m[0]) && (ntohll(a[1]) & m[1]) == (ntohll(b[1]) & m[1]));
        }

        return (orEquals) ? cmp : (cmp && this->cidr != ocidr);
}

int IPPrefix::getFamily(void) const throw () {
        return address.getFamily();
}

const IPAddress& IPPrefix::getIPAddress(void) const throw () {
        return this->address;
}


uint8_t IPPrefix::getCIDR(void) const throw () {
        return this->cidr;
}

IPAddress IPPrefix::getNetmask(void) const throw () {
        if (getFamily() == AF_INET) {
                return IPAddress("255.255.255.255", IPAddress::IPv4Required, cidr);
        } else {
                return IPAddress("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", IPAddress::IPv6Required, cidr);
        }
}

IPAddress IPPrefix::getInverseMask(void) const throw () {
        return ~(getNetmask());
}

IPAddress IPPrefix::getNetwork(void) const throw () {
        return getIPAddress();
}

IPAddress::vector IPPrefix::getIPAddresses(bool usable) const throw () {
        IPAddress::vector addresses;
        IPAddress address = getIPAddress();

        if (usable) {
                if (getFamily() == AF_INET && cidr < 31) {
                        ++address;
                } else if (getFamily() == AF_INET6 && cidr < 127) {
                        ++address;
                }
        }

        while (contains(address, true)) {
                addresses.push_back(address++);
        }

        if (usable) {
                if (getFamily() == AF_INET && cidr < 31) {
                        addresses.pop_back();
                } else if (getFamily() == AF_INET6 && cidr < 127) {
                        addresses.pop_back();
                }
        }

        return addresses;
}

const std::string& IPPrefix::str(void) const throw (AddressException) {
        if (scache.empty()) {
                scache = String::sprintf("%s/%u", this->address.c_str(), cidr);
        }

        return scache;
}

const char* IPPrefix::c_str(void) const throw (AddressException) {
        return str().c_str();
}

uint32_t IPPrefix::getU32(void) const throw () {
        uint32_t c = cidr;

        return (address.getU32() ^ (c | c << 4 | c << 8 | c << 12 | c << 16 | c << 20 | c << 24 | c << 28));
}

uint32_t IPPrefix::getHash(void) const throw () {
        if (hcache != 0) {
                return hcache;
        }

#if defined HASH_ALGO_INT1 /* Fast. Nibble swap. */
        uint32_t k = getU32();

        hcache = ((k & 0xF0F0F0F0) >> 4) | ((k & 0x0F0F0F0F) << 4);
#elif defined HASH_ALGO_INT2
        uint32_t k = getU32();

        hcache = (k<<16)^(k>>16)^k; /* Fast. Mix by XOR shifting.. */
#elif defined HASH_ALGO_INT3 /* Very fast, but not good. */
        hcache = getU32();
#else
        #error No hash algo selected.
#endif

        return hcache;
}

bool IPPrefix::empty(void) const throw () {
        return (address.empty());
}

void IPPrefix::clear(void) throw () {
        address.clear();
        cidr = 0;
        mask = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
        scache.clear();
        hcache = 0;
}

const IPPrefix::shared IPPrefix::shared_ptr(const IPAddress &address, uint8_t cidr) throw (AddressException) {
        return std::make_shared<IPPrefix>(address, cidr);
}

const IPPrefix::shared IPPrefix::shared_ptr(const std::string &address, uint8_t cidr) throw (AddressException) {
        return std::make_shared<IPPrefix>(address, cidr);
}

const IPPrefix::shared IPPrefix::shared_ptr(const std::string &prefix) throw (AddressException) {
        return std::make_shared<IPPrefix>(prefix);
}

void IPPrefix::generateMask(void) throw () {
        if (address.getFamily() == AF_INET) {
                if (cidr == 0) {
                        mask[0] = 0;
                } else {
                        mask[0] = 0xFFFFFFFF >> (32 - cidr) << (32 - cidr);
                }

//              printf("mask: %08X\n", mask[0]);
        } else {
                for (int i = 4; i > cidr / 32 - 1; i--) {
                        if (i == cidr / 32 && cidr % 32 != 0) {
            mask[i] = 0xFFFFFFFF >> (32 - cidr % 32) << (32 - cidr % 32);
         } else {
            mask[i] = 0;
         }
                }

//              printf("mask: %08X:%08X:%08X:%08X\n", mask[0], mask[1], mask[2], mask[3]);
        }
}

/*
** vim: noet ts=3 sw=3
*/

---