IPPrefix.cpp

/*
** libutil++
** $Id: IPPrefix.cpp 1901 2017-06-24 20:03:54Z sella $
** Copyright (c) 2011-2016 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 1901 2017-06-24 20:03:54Z 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)
{
        int family = this->address.getFamily();

        if (cidr == 255) {
                this->cidr = (family == AF_INET) ? 32 : 128;
        } else if (family == AF_INET && cidr > 32) {
                this->cidr = 32;
        } else if (cidr > 128) {
                this->cidr = 128;
        } else {
                this->address.applyCIDR(this->cidr);
        }

        generateMask();
}

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

        if (cidr == 255) {
                this->cidr = (family == AF_INET) ? 32 : 128;
        } else if (family == AF_INET && cidr > 32) {
                this->cidr = 32;
        } else if (cidr > 128) {
                this->cidr = 128;
        } else {
                this->address.applyCIDR(this->cidr);
        }

        generateMask();
}

IPPrefix::IPPrefix(const std::string &prefix) throw (AddressException) :
        mask{0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF},
        hcache(0)
{
#if 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();
#else
        size_t i = prefix.rfind('/');
        const char *p = prefix.c_str();

        if (i == std::string::npos) {
                if (inet_pton(AF_INET, p, &(this->address.addr.v4)) == 1) {
                        this->address.family = AF_INET;
                        this->cidr = 32;
                } else {
                        if (inet_pton(AF_INET6, p, &(this->address.addr.v6)) == 1) {
                                this->address.family = AF_INET6;
                                this->cidr = 128;
                        } else {
                                THROW(AddressException, "unable to parse prefix: '%s' does not represent a valid IPv4 or IPv6 prefix", p);
                        }
                }
        } else {
                char buf[i + 1];
                const char *p = prefix.c_str();

                strncpy(buf, p, i);
                buf[i] = 0;

                if (inet_pton(AF_INET, buf, &(this->address.addr.v4)) == 1) {
                        this->address.family = AF_INET;
                } else {
                        if (inet_pton(AF_INET6, buf, &(this->address.addr.v6)) == 1) {
                                this->address.family = AF_INET6;
                        } else {
                                THROW(AddressException, "unable to parse prefix: '%s' does not represent a valid IPv4 or IPv6 prefix", p);
                        }
                }

                try {
                        this->cidr = std::stoi(p + i + 1);
                } catch (std::exception &e) {
                        THROW(AddressException, "unable to parse prefix: '%s' does not represent a valid IPv4 or IPv6 prefix", p);
                }

                this->address.applyCIDR(this->cidr);
        }

        generateMask();
#endif
}

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

bool IPPrefix::operator<=(const IPPrefix &other) const throw () {
        if (*this <<= other) {
                return true;
        } else if (other << *this) {
                return false;
        }

        return (this->address <= other.address);
}

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

bool IPPrefix::operator<(const IPPrefix &other) const throw () {
        if (*this << other) {
                return true;
        } else if (other <<= *this) {
                return false;
        }

        return (this->address < other.address);
}

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

IPAddress& IPPrefix::getIPAddress(void) 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 IPPrefix::getBroadcast(void) const throw () {
        return this->address | getInverseMask();
}

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 = this->address.str();

                scache.push_back('/');
                scache.append(String::itoa(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[0] = 0xFFFFFFFF;
        mask[1] = 0xFFFFFFFF;
        mask[2] = 0xFFFFFFFF;
        mask[3] = 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 {
                        uint8_t adj = 32 - cidr;

                        mask[0] = 0xFFFFFFFF >> adj << adj;
                }

                //printf("mask: %08X\n", mask[0]);
        } else {
                uint8_t mod = cidr % 32;
                uint8_t adj = 32 - mod;

                for (int i = 4; i > cidr / 32 - 1; i--) {
                        if (i == cidr / 32 && mod != 0) {
            mask[i] = 0xFFFFFFFF >> adj << adj;
         } 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
*/